Previsão de preço do Bitcoin News em Python

Tarefa

• O Python 2.6+ ou 3.1+ deve estar instalado no sistema
• Instale pandas , sklearn e openblender (usando pip)

$ pip install pandas OpenBlender scikit-learn

Etapa 1. Obter dados de 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)

Etapa 2. Preparação dos Dados

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

Etapa 3. Obter dados de notícias de negócios

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
}

• nome : vamos chamá-lo de 'Fox Business TextVectorizer' ;
• anchor : id do conjunto de dados e o nome das características que precisaremos usar como fonte (no nosso caso, apenas a coluna 'title' );
• ngram_range : comprimento mínimo e máximo de um conjunto de palavras para tokenização;
• idioma : inglês
• remove_stop_words : para remover palavras de parada da fonte;
• min_count_limit : o número mínimo de repetições que devem ser consideradas como um token (ocorrências únicas raramente são úteis).

res = OpenBlender.call(action, vectorizer_parameters)
res

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

Etapa 4. Resumo de notícias compatível com conjunto de dados 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 do nosso textVectorizer;
• blend_type : 'text_ts' para que o Python entenda que é uma mistura de texto e carimbo de data e hora;
• restrição : 'preditiva' , para que não haja "mistura" de notícias do futuro com todas as observações, mas apenas com aquelas publicadas antes do tempo especificado.
• blend_class : 'closest_observation' , para que apenas as observações mais próximas sejam "misturadas";
• especificações : a quantidade máxima possível de tempo decorrido para a transferência da observação, neste caso 12 horas (3600 * 12). Isso significa que todas as observações sobre o preço do bitcoin serão previstas com base nas notícias das últimas 12 horas.

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

Etapa 5. Aplique ML ao destino de previsão

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 vezes previmos um declínio e o preço diminuiu (à direita);
• 5 vezes previmos uma queda e o preço aumentou (incorretamente);
• Uma vez previmos um aumento, mas o preço diminuiu incorretamente);
• Prevemos duas vezes um aumento e o preço aumentou (verdadeiro).