Cryptomonnaie

Prédire le prix du Bitcoin avec des nouvelles en utilisant Python

Prédire le prix du Bitcoin avec des nouvelles en utilisant Python


  • Avoir Python 2.6+ ou 3.1+ installé
  • Installer des pandas, sklearn et openblender (avec pip)
$ pip install pandas OpenBlender scikit-learn

Importons les bibliothèques que nous utiliserons:

importer OpenBlender
importer des pandas en tant que pd
importer json
# Il ne contient que l'id, nous ajouterons plus de paramètres plus tard.paramètres = { 
'id_dataset': '5d4c3af79516290b01c83f51'
}
paramètres = {     
'token': 'your_token',
'id_dataset': '5d4c3af79516290b01c83f51'
}
# Cette fonction extrait les données et les commandes par horodatagedef pullObservationsToDF (paramètres):
action = 'API_getObservationsFromDataset'
df = pd.read_json (json.dumps (OpenBlender.call (action, paramètres)['sample']), convert_dates = False, convert_axes = False) .sort_values ​​('timestamp', ascending = False)
df.reset_index (drop = True, inplace = True)
retourner df
df = pullObservationsToDF (paramètres)
df.head ()

Premièrement, nous devons créer notre cible de prédiction ce qui signifie que le «changement» augmentera ou diminuera. Pour ce faire, ajouter une seuil cible pour un succès supérieur à zéro à nos paramètres:

paramètres = {
'token': 'your_token',
'id_dataset': '5d4c3af79516290b01c83f51',
'target_threshold': {'feature': 'change', 'success_thr_over': 0}
}
df = pullObservationsToDF (paramètres)
df.head ()
paramètres = { 
'token': 'your_token',
'id_dataset': '5d4c3af79516290b01c83f51',
'target_threshold': {'feature': 'change', 'success_thr_over': 0},
'lag_target_feature': {'feature': 'change_over_0', 'périodes': 1}
}
df = pullObservationsToDF (paramètres)
df.head ()
target_variable = 'TARGET_change_over_0'
df = df.dropna ()
df.corr ()[target_variable].sort_values ​​()

Après avoir recherché des corrélations sur OpenBlender, j'ai trouvé un ensemble de données de Fox Business News qui permet de générer de bonnes prévisions sur notre cible spécifique.

action = 'API_createTextVectorizer'vectorizer_parameters = {
'token': 'your_token',
'name': 'Fox Business TextVectorizer',
'sources':[{'id_dataset':'5d571f9e9516293a12ad4f6d'[{'id_dataset':'5d571f9e9516293a12ad4f6d'
'traits' : ['title']}],
'ngram_range': {'min': 1, 'max': 2},
'langue': 'en',
'remove_stop_words': 'on',
'min_count_limit': 2
}
  • ancre: L'identifiant de l'ensemble de données et le nom des entités à inclure en tant que source (dans ce cas uniquement «titre»)
  • ngram_range: La longueur minimale et maximale de l'ensemble de mots qui seront symbolisés
  • Langue: Anglais
  • remove_stop_words: Il élimine donc les mots vides de la source
  • min_count_limit: Le minimum de répétitions pour être considéré comme un jeton (les occurrences uniques aident rarement)
res = OpenBlender.call (action, vectorizer_parameters)
res
{  
'message': 'TextVectorizer a été créé avec succès.'
'id_textVectorizer': '5dc1a404951629331f6359dd',
«num_ngrams»: 4270
}

Maintenant, nous voulons mélanger dans le temps les fonctionnalités avec nos données Bitcoin. Cela signifie essentiellement de joindre les deux ensembles de données en utilisant le horodatage comme clé. Voyons ajouter le mélange à notre original paramètres pour extraire des données:

paramètres = { 
'token': 'your_token',
'id_dataset': '5d4c3af79516290b01c83f51',
'target_threshold': {'feature': 'change', 'success_thr_over': 0},
'lag_target_feature': {'feature': 'change_over_0', 'périodes': 1},
«mélanges»:[{'id_blend':'5dc1a404951629331f6359dd'[{'id_blend':'5dc1a404951629331f6359dd'
'blend_type': 'text_ts',
«restriction»: «prédictif»,
'spécifications': {'time_interval_size': 3600 * 12}}]

}
  • blend_type : "Text_ts" pour qu'il sache qu'il s'agit d'un mélange de texte et d'horodatage
  • restriction : «Prédictif», de sorte qu'il ne mélange pas les nouvelles du futur à chaque observation, seulement les nouvelles qui se sont produites avant
  • blend_class : «Observation la plus proche» afin de mélanger les observations les plus proches dans le temps
  • Caractéristiques : le temps maximum au passé duquel il apportera des observations en secondes qui dans ce cas est de 12 heures (3600 * 12). Cela signifie seulement que chaque observation du prix du Bitcoin sera prédite avec des nouvelles des 12 dernières heures
paramètres = { 
'token': 'your_token',
'id_dataset': '5d4c3af79516290b01c83f51',
'target_threshold': {'feature': 'change', 'success_thr_over': 0},
'lag_target_feature': {'feature': 'change_over_0', 'périodes': 1},
«mélanges»:[{'id_blend':'5dc1a404951629331f6359dd'[{'id_blend':'5dc1a404951629331f6359dd'
'blend_type': 'text_ts',
«restriction»: «prédictif»,
'blend_class': 'observation_le plus proche',
'spécifications': {'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 (paramètres)
impression (df.shape)
df.head ()

Maintenant, nous avons enfin l'ensemble de données nettoyé exactement comme nous en avons besoin avec le objectif décalé et le mélangé donnees numeriques.

X = df.loc[:, df.columns != target_variable].valeurs
y = df.loc[:[:[target_variable]].valeurs
div = int (rond (len (X) * 0,29))
# Nous prenons les premières observations comme test et les dernières comme train car l'ensemble de données est ordonné par horodatage décroissant.
X_test = X[:div]
y_test = y[:div]
impression (X_test.shape)
impression (y_test.shape)
X_train = X[div:]
y_train = y[div:]
imprimer (X_train.shape)
imprimer (y_train.shape)
de sklearn.ensemble import RandomForestRegressor
à partir de sklearn.metrics, importez mean_squared_error
à partir de sklearn.metrics import precision_score
de sklearn.metrics importation roc_auc_score
à partir des métriques d'importation sklearn
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 ()
df_res.head ()
seuil = 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 (precision_score (preds, df_res['y_test']))
  • 5 fois nous avons prédit une diminution et elle a augmenté (faux)
  • 1 fois nous avons prédit une augmentation et elle a diminué (faux)
  • Nous avons prévu 2 fois une augmentation et elle a augmenté (correct)
Afficher plus

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Articles similaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page
Fermer