Precio de Bitcoin predecido con Business News (Python)

La simplicidad es clave.

Objetivo

En este tutorial, usaremos este conjunto de datos de precio de Bitcoin vs USD .

El conjunto de datos anterior contiene un resumen diario de precios donde el CAMBIO columna es el cambio porcentual del último precio del día ( PRECIO ) con respecto al primero (O PEN ).

Meta: Para simplificar las cosas nos centraremos en predecir si el precio aumentará ( cambiará> 0 ) o caerá ( cambio ≤ 0 ) al día siguiente. (Por lo tanto, podríamos usar las predicciones “en la vida real”).

Requisitos previos

Tener instalado Python 2.6+ o 3.1+
Instalar pandas, sklearn y openblender (con pip)

$ pip install pandas OpenBlender scikit-learn

Paso 1. Obtenga los datos de precio de Bitcoin

Importemos las bibliotecas que usaremos:
import OpenBlender import pandas as pd import json

Ahora saquemos las datos a través de la API OpenBlender .

Primero, definiremos los parámetros (en este caso es solo la identificación del conjunto de datos de precio de Bitcoin ):
# It only contains the id, we'll add more parameters

later.parameters = { 'id_dataset':'5d4c3af79516290b01c83f51' }

agregaremos más parámetros más tarde.

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

Ahora extraigamos los datos en un Marco de datos ‘df’:

# 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)

Echemos un vistazo

df.head ()

Nota: Los valores pueden variar ya que este conjunto de datos se actualiza diariamente .

Precio de Bitcoin: Paso 2. Prepara los datos

Primero, necesitamos crear nuestro p objetivo de prohibición que es si el “cambio” aumentará o disminuirá. Para hacer esto, agregue un umbral objetivo para el éxito sobre cero a nuestros parámetros:
parameters = { 'token':'your_token', 'id_user':'your_id_user', 'id_dataset':'5d4c3af79516290b01c83f51', 'target_threshold':{'feature':'change', 'success_thr_over': 0} }

Si extraemos datos de la API nuevamente:

df = pullObservationsToDF(parameters) df.head()

La característica ‘cambiar’ fue reemplazada por una nueva característica: ‘ change_over_0 ‘ que es 1 si ‘cambio’ fue positivo y 0 si más. Este será nuestro objetivo para el aprendizaje automático.

Si queremos predecir observaciones para ‘mañana’ no podemos usar información del mismo día, así que agreguemos un un período de retraso en el destino.
parameters = { 'token':'your_token', 'id_user':'your_id_user', '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()

Esto simplemente alineó ‘change_over_0’ con los datos del período anterior (día) y cambió su nombre a ‘ TARGET_change_over_0 ‘.

Echemos un vistazo a las correlaciones:

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

No están correlacionados linealmente y es muy poco probable que sean útiles.

Paso 3. Obtener datos de Business News

Después de buscar correlaciones en OpenBlender encontré un conjunto de datos de Fox Business News que ayuda a generar buenas predicciones sobre nuestro objetivo específico.

Lo que queremos es una forma de convertir el ‘título’ en características numéricas contando repeticiones de palabras y grupos de palabras por elemento de noticias y combínalos en el tiempo a nuestro conjunto de datos de precio de Bitcoin. Esto es más simple de lo que parece.

Primero, necesitamos crear un TextVectorizer para la función ‘título’ de la noticia:

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

Crearemos un vectorizador para que podamos obtener todas las funciones como recuentos numéricos de token de palabras. Arriba, especificamos lo siguiente:

name: Lo llamaremos ‘Fox Business TextVectorizer’
anchor : El id del conjunto de datos y el nombre de las características para incluir como fuente (en este caso, solo ‘título’)
ngram_range : La longitud mínima y máxima del conjunto de palabras que se tokenizarán
language: inglés
remove_stop_words : Por lo tanto, elimina las palabras de detención de la fuente
min_count_limit : El mínimo de repeticiones para ser considerado un token (los eventos únicos rara vez ayudan)

Vamos a ejecutarlo :

res = OpenBlender.call(action, vectorizer_parameters) res

Response:

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

El TextVectorizer fue creado y generó 4270 n-gramos con nuestra configuración. Usaremos la identificación generada más tarde: 5dc1a404951629331f6359dd

Paso 4. Mezcle las noticias con el conjunto de datos de precio de Bitcoin

Ahora, queremos mezclar las características en el tiempo Datos de precio de Bitcoin .

Esto básicamente significa unir los dos conjuntos de datos utilizando la marca de tiempo como clave . Agreguemos la mezcla a nuestros parámetros originales para obtener datos:

parameters = { 'token':'your_token', 'id_user':'your_id_user', '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 }}] }

Lo que estamos especificando arriba es lo siguiente:

id_blend : La identificación de nuestro TextVectorizer
blend_type : ‘text_ts’ para que sepa que es una mezcla de texto y marca de tiempo
restriction : ‘predictivo’, para que no mezcle noticias del futuro con cada observación, solo noticias que ocurrieron antes de
blend_class : ‘la observación más cercana’ para que combine las observaciones más cercanas en el tiempo
specificacions : el tiempo máximo al pasado desde el cual traerá observaciones en segundos, que en este caso es de 12 horas (3600 * 12). Esto solo significa que cada observación del precio de Bitcoin se pronosticará con noticias del últimas 12 horas

Finalmente, solo agregaremos un filtro de fecha que comienza el 20 de agosto porque es cuando se inició el conjunto de datos de Fox News y ‘drop_non_numeric’, por lo que solo obtenemos números:

parameters = { 'token':'your_token', 'id_user':'your_id_user', '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 }

Nota: Especifiqué el 4 de noviembre como ‘ end_date ‘ porque ese es el día en que lo escribí, pero puede cambiar el fecha en que lo está leyendo.

Vuelva a extraer los datos:

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

( 57, 2115)

Ahora tenemos más de 2K características con todos los tokens, y tenemos 57 observaciones.

Paso 5. Aplicar ML para predecir el objetivo

Ahora finalmente tenemos el conjunto de datos limpios exactamente como lo necesitamos con el objetivo rezagado y los datos numéricos combinados .

Echemos un vistazo a las correlaciones principales con ‘Target_change_over_0’:

Hay varias características correlacionadas ahora. Separemos o entrenar y prueba establece cronológicamente, por lo que podemos entrenar con observaciones anteriores y prueba en futuras .

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)

Tenemos 40 observaciones para entrenar y 17 para probar.

Ahora, importaremos las bibliotecas necesarias:
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

Ahora, ajustemos RandomForest y hagamos las predicciones:
rf = RandomForestRegressor(n_estimators = 1000) rf.fit(X_train, y_train) y_pred = rf.predict(X_test)
Para que sea más fácil de entender, pongamos las predicciones y el y_test en un Dataframe:

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

df_res.head ()

Nuestro verdadero ‘y_test’ es binario pero nuestras predicciones son flotantes, así que redondeémoslas suponiendo que si son mayores que 0.5 predeciríamos un aumento de precio y menor que 0.5 una disminución.

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

Ahora, para mejor comprensión de nuestros resultados, obtengamos el AUC, la matriz de confusión y el puntaje de precisión:

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']))