Python News Bitcoin Price Prediction

Tâche

• Python 2.6+ ou 3.1+ doit être installé sur le système
• Installer des pandas , sklearn et openblender (en utilisant pip)

$ pip install pandas OpenBlender scikit-learn

Étape 1. Obtenez des données Bitcoin

import OpenBlender
import pandas as pd
import json

# It only contains the id, we'll add more parameters later.
parameters = { 
 'id_dataset':'5d4c3af79516290b01c83f51'
}

parameters = {     
   'token':'your_token',
   'id_dataset':'5d4c3af79516290b01c83f51'
}

# This function pulls the data and orders by timestamp
def pullObservationsToDF(parameters):
    action = 'API_getObservationsFromDataset'
    df = pd.read_json(json.dumps(OpenBlender.call(action,parameters)['sample']), convert_dates=False,convert_axes=False) .sort_values('timestamp', ascending=False)
    df.reset_index(drop=True, inplace=True)
    return df
df = pullObservationsToDF(parameters)

Étape 2. Préparation des données

parameters = {
   'token':'your_token',   
   'id_dataset':'5d4c3af79516290b01c83f51',
   'target_threshold':{'feature':'change', 'success_thr_over': 0}
}

df = pullObservationsToDF(parameters)
df.head() 

parameters = { 
   'token':'your_token',
   'id_dataset':'5d4c3af79516290b01c83f51',
   'target_threshold':{'feature':'change','success_thr_over' : 0},
   'lag_target_feature':{'feature':'change_over_0', 'periods' : 1}
}
df = pullObservationsToDF(parameters)
df.head()

target_variable = 'TARGET_change_over_0'
df = df.dropna()
df.corr()[target_variable].sort_values()

Étape 3. Obtenir des données sur les actualités commerciales

action = 'API_createTextVectorizer'
vectorizer_parameters = {
    'token' : 'your_token',
    'name' : 'Fox Business TextVectorizer',
    'sources':[{'id_dataset' : '5d571f9e9516293a12ad4f6d',
                'features' : ['title']}],
    'ngram_range' : {'min' : 1, 'max' : 2},
    'language' : 'en',
    'remove_stop_words' : 'on',
    'min_count_limit' : 2
}

• nom : appelons-le «Fox Business TextVectorizer» ;
• ancre : identifiant de l'ensemble de données et nom des caractéristiques que nous devrons utiliser comme source (dans notre cas, uniquement la colonne «titre» );
• ngram_range : longueur minimale et maximale d'un ensemble de mots pour la tokenisation;
• langue : anglais
• remove_stop_words : pour supprimer les mots vides de la source;
• min_count_limit : le nombre minimum de répétitions qui doit être considéré comme un jeton (les occurrences simples sont rarement utiles).

res = OpenBlender.call(action, vectorizer_parameters)
res

{  
    'message' : 'TextVectorizer created successfully.'
    'id_textVectorizer' : '5dc1a404951629331f6359dd',
    'num_ngrams': 4270
}

Étape 4. Résumé des nouvelles compatibles avec le jeu de données Bitcoin

parameters = { 
   'token':'your_token',  
   'id_dataset':'5d4c3af79516290b01c83f51',
   'target_threshold' : {'feature':'change','success_thr_over':0},
   'lag_target_feature' : {'feature':'change_over_0', 'periods':1},
   'blends':[{'id_blend':'5dc1a404951629331f6359dd',
               'blend_type' : 'text_ts',
               'restriction' : 'predictive', 
               'specifications':{'time_interval_size' : 3600*12 }}]
}

• id_blend : id de notre textVectorizer;
• blend_type : 'text_ts' pour que Python comprenne qu'il s'agit d'un mélange de texte et d'horodatage;
• restriction : «prédictive» , de sorte qu'il n'y a pas de «mélange» des nouvelles du futur avec toutes les observations, mais uniquement avec celles qui ont été publiées plus tôt que l'heure spécifiée.
• blend_class : ' observation_la plus proche ' , de sorte que seules les observations les plus proches soient "mélangées";
• spécifications : durée maximale possible du transfert d'observation, en l'occurrence 12 heures (3600 * 12). Cela signifie que chaque observation du prix du bitcoin sera prédite en fonction de l'actualité des 12 dernières heures.

parameters = { 
   'token':'your_token',
   'id_dataset':'5d4c3af79516290b01c83f51',
   'target_threshold' : {'feature':'change','success_thr_over':0},
   'lag_target_feature' : {'feature':'change_over_0', 'periods':1},
   'blends':[{'id_blend':'5dc1a404951629331f6359dd',
               'blend_type' : 'text_ts',
               'restriction' : 'predictive',
               'blend_class' : 'closest_observation', 
               'specifications':{'time_interval_size' : 3600*12 }}],
   'date_filter':{'start_date':'2019-08-20T16:59:35.825Z',
                   'end_date':'2019-11-04T17:59:35.825Z'},
   'drop_non_numeric' : 1
}

df = pullObservationsToDF(parameters)
print(df.shape)
df.head()

Étape 5. Appliquer ML à la cible de prédiction

X = df.loc[:, df.columns != target_variable].values
y = df.loc[:,[target_variable]].values
div = int(round(len(X) * 0.29))
# We take the first observations as test and the last as train because the dataset is ordered by timestamp descending.
X_test = X[:div]
y_test = y[:div]
print(X_test.shape)
print(y_test.shape)
X_train = X[div:]
y_train = y[div:]
print(X_train.shape)
print(y_train.shape)

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_auc_score
from sklearn import metrics

rf = RandomForestRegressor(n_estimators = 1000)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

df_res = pd.DataFrame({'y_test':y_test[:,0], 'y_pred':y_pred})
df_res.head()

threshold = 0.5
preds = [1 if val > threshold else 0 for val in df_res['y_pred']]

print(roc_auc_score(preds, df_res['y_test']))
print(metrics.confusion_matrix(preds, df_res['y_test']))
print(accuracy_score(preds, df_res['y_test']))

• 9 fois nous avons prédit une baisse, et le prix a baissé (à droite);
• 5 fois nous avons prédit une baisse, et le prix a augmenté (incorrectement);
• 1 fois nous avons prédit une augmentation, mais le prix a baissé incorrectement);
• 2 fois, nous avons prédit une augmentation, et le prix a augmenté (vrai).