import os

import pandas as pd
import numpy as np
import time

from sklearn.neural_network import MLPRegressor

from sklearn.model_selection import train_test_split
from sklearn.metrics import max_error, mean_absolute_error, mean_squared_error

#>>>>>>>------------------------------------------------
# ************ PREVISÂO DE DIREÇÂO ************
#>>>>>>>------------------------------------------------
print("> Carregando base de dados de Direção...")
# Carrega a base de dados
base = pd.read_csv('deepOracleTrader_Data.csv', sep=",", index_col=0,
encoding="utf_16")
# summarize each variable
#print(base.describe())
'''base.hist(bins=30, figsize=(60,60), density=True)
import matplotlib.pyplot as plt
plt.show()'''

# separa o dataframe da base em listas de atributos previsores e classes

print("> separando em atributos e saída...")
atributosMA1 = base.iloc[:, 0:90].values
saidasMA1 = base.iloc[:, 90].values

atributosMA3 = base.iloc[:, 0:90].values

saidasMA3 = base.iloc[:, 91].values

atributosMA5 = base.iloc[:, 0:90].values

saidasMA5 = base.iloc[:, 92].values

'''atributosMA10 = base.iloc[:, 0:110].values

saidasMA10 = base.iloc[:, 113].values

atributosRates10 = base.iloc[:, 0:114].values

saidasRates10 = base.iloc[:, 114].values'''

print("> Separando base em treino e teste...")

atributosMA1_train, atributosMA1_test, saidasMA1_train, saidasMA1_test =
train_test_split(
atributosMA1, saidasMA1, test_size=0.02, random_state=0, shuffle=False)

atributosMA3_train, atributosMA3_test, saidasMA3_train, saidasMA3_test =

train_test_split(
atributosMA3, saidasMA3, test_size=0.02, random_state=0, shuffle=False)

atributosMA5_train, atributosMA5_test, saidasMA5_train, saidasMA5_test =

train_test_split(
atributosMA5, saidasMA5, test_size=0.02, random_state=0, shuffle=False)

'''atributosMA10_train, atributosMA10_test, saidasMA10_train, saidasMA10_test =

train_test_split(
atributosMA10, saidasMA10, test_size=0.01, random_state=0, shuffle=False)

atributosRates10_train, atributosRates10_test, saidasRates10_train,

saidasRates10_test = train_test_split(
atributosRates10, saidasRates10, test_size=0.01, random_state=0,
shuffle=False)'''

from sklearn.preprocessing import StandardScaler

print("> normalizando os dados...")
scAtributosMA1 = StandardScaler().fit(atributosMA1_train)
atributosMA1_train = scAtributosMA1.transform(atributosMA1_train)
atributosMA1_test = scAtributosMA1.transform(atributosMA1_test)

scAtributosMA3 = StandardScaler().fit(atributosMA3_train)
atributosMA3_train = scAtributosMA3.transform(atributosMA3_train)
atributosMA3_test = scAtributosMA3.transform(atributosMA3_test)

scAtributosMA5 = StandardScaler().fit(atributosMA5_train)
atributosMA5_train = scAtributosMA5.transform(atributosMA5_train)
atributosMA5_test = scAtributosMA5.transform(atributosMA5_test)

'''scAtributosMA10 = StandardScaler().fit(atributosMA10_train)
atributosMA10_train = scAtributosMA10.transform(atributosMA10_train)
atributosMA10_test = scAtributosMA10.transform(atributosMA10_test)

scAtributosRates10 = StandardScaler().fit(atributosRates10_train)
atributosRates10_train = scAtributosRates10.transform(atributosRates10_train)
atributosRates10_test = scAtributosRates10.transform(atributosRates10_test)'''

print("> aplicando PCA....")

from sklearn.decomposition import PCA
pcaMA1 = PCA(n_components='mle').fit(atributosMA1_train)
atributosMA1_train = pcaMA1.transform(atributosMA1_train)
atributosMA1_test = pcaMA1.transform(atributosMA1_test)

from sklearn.decomposition import PCA

pcaMA3 = PCA(n_components='mle').fit(atributosMA3_train)
atributosMA3_train = pcaMA3.transform(atributosMA3_train)
atributosMA3_test = pcaMA3.transform(atributosMA3_test)

from sklearn.decomposition import PCA

pcaMA5 = PCA(n_components='mle').fit(atributosMA5_train)
atributosMA5_train = pcaMA5.transform(atributosMA5_train)
atributosMA5_test = pcaMA5.transform(atributosMA5_test)

'''from sklearn.decomposition import PCA

pcaMA10 = PCA(n_components='mle').fit(atributosMA10_train)
atributosMA10_train = pcaMA10.transform(atributosMA10_train)
atributosMA10_test = pcaMA10.transform(atributosMA10_test)

from sklearn.decomposition import PCA

pcaRates10 = PCA(n_components='mle').fit(atributosRates10_train)
atributosRates10_train = pcaRates10.transform(atributosRates10_train)
atributosRates10_test = pcaRates10.transform(atributosRates10_test)'''

from sklearn.svm import LinearSVR

from sklearn.ensemble import GradientBoostingRegressor, VotingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import AdaBoostRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.linear_model import BayesianRidge
'''svr = LinearSVR(C=1, max_iter=100000000, verbose=0, tol=1e-11)
mlp =
MLPRegressor(shuffle=False,early_stopping=True,hidden_layer_sizes=(180,90),activati
on='relu',solver='adam',tol=1e-21,max_iter=10000000, batch_size=30)
bayr = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
gbr = GradientBoostingRegressor(learning_rate=0.00125, max_depth=5, loss='huber',
n_estimators=10000, subsample=0.01, random_state=0)
adab = AdaBoostRegressor(DecisionTreeRegressor(max_depth=6), n_estimators=10000,
loss='linear', learning_rate=0.9, random_state=0)
knn = KNeighborsRegressor(n_neighbors=21,weights="distance")
votRegressorHigh = VotingRegressor(estimators=[('svr',svr),('mlp',mlp),
('bayr',bayr),('gbr',gbr),('adab',adab),('knn',knn)],n_jobs=-1)
'''

inicio = time.time()
#svrMA1 = LinearSVR(C=1, max_iter=100000000, verbose=0, tol=1e-9)
mlpMA1 =
MLPRegressor(shuffle=False,early_stopping=True,hidden_layer_sizes=(180,90),activati
on='relu',solver='adam',tol=1e-9,max_iter=10000000, batch_size=30)
bayrMA1 = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
#gbrMA1 = GradientBoostingRegressor(learning_rate=0.00125, max_depth=5,
loss='huber', n_estimators=1000, subsample=0.1, random_state=0)
#adabMA1 = AdaBoostRegressor(DecisionTreeRegressor(max_depth=6), n_estimators=1000,
loss='linear', learning_rate=0.9, random_state=0)
knnMA1 = KNeighborsRegressor(n_neighbors=21,weights="distance")
#modelMA1 = VotingRegressor(estimators=[('svr',svrMA1),('mlp',mlpMA1),
('bayr',bayrMA1),('gbr',gbrMA1),('adab',adabMA1),('knn',knnMA1)],n_jobs=-1)
modelMA1 = VotingRegressor(estimators=[('mlp',mlpMA1),('bayr',bayrMA1),
('knn',knnMA1)],n_jobs=-1)
print(">> Avaliando modelo de Regressão MA1...")
modelMA1.fit(atributosMA1_train,saidasMA1_train)
y_true = saidasMA1_test
y_pred = modelMA1.predict(atributosMA1_test)
maxe = max_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
print("modelMA1-maxe: ",maxe)
print("modelMA1-mae: ",mae)
print("modelMA1-mse: ",mse)
from matplotlib import pyplot
pyplot.plot(y_true, label='y_true')
pyplot.plot(y_pred, label='modelMA1-y_pred')
pyplot.legend()
pyplot.show()
fim = time.time()
print("Tempo para treinar e avaliar modelMA1 --> ", fim - inicio, " segundos.")

inicio = time.time()
#svrMA3 = LinearSVR(C=1, max_iter=100000000, verbose=0, tol=1e-9)
mlpMA3 =
MLPRegressor(shuffle=False,early_stopping=True,hidden_layer_sizes=(180,90),activati
on='relu',solver='adam',tol=1e-9,max_iter=10000000, batch_size=30)
bayrMA3 = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
#gbrMA3 = GradientBoostingRegressor(learning_rate=0.00125, max_depth=5,
loss='huber', n_estimators=1000, subsample=0.1, random_state=0)
#adabMA3 = AdaBoostRegressor(DecisionTreeRegressor(max_depth=6), n_estimators=1000,
loss='linear', learning_rate=0.9, random_state=0)
knnMA3 = KNeighborsRegressor(n_neighbors=21,weights="distance")
#modelMA3 = VotingRegressor(estimators=[('svr',svrMA3),('mlp',mlpMA3),
('bayr',bayrMA3),('gbr',gbrMA3),('adab',adabMA3),('knn',knnMA3)],n_jobs=-1)
modelMA3 = VotingRegressor(estimators=[('mlp',mlpMA3),('bayr',bayrMA3),
('knn',knnMA3)],n_jobs=-1)
print(">> Avaliando modelo de Regressão MA3...")
modelMA3.fit(atributosMA3_train,saidasMA3_train)
y_true = saidasMA3_test
y_pred = modelMA3.predict(atributosMA3_test)
maxe = max_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
print("modelMA3-maxe: ",maxe)
print("modelMA3-mae: ",mae)
print("modelMA3-mse: ",mse)
from matplotlib import pyplot
pyplot.plot(y_true, label='y_true')
pyplot.plot(y_pred, label='modelMA3-y_pred')
pyplot.legend()
pyplot.show()
fim = time.time()
print("Tempo para treinar e avaliar modelMA3 --> ", fim - inicio, " segundos.")

inicio = time.time()
#svrMA5 = LinearSVR(C=1, max_iter=100000000, verbose=0, tol=1e-9)
mlpMA5 =
MLPRegressor(shuffle=False,early_stopping=True,hidden_layer_sizes=(180,90),activati
on='relu',solver='adam',tol=1e-9,max_iter=10000000, batch_size=30)
bayrMA5 = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
#gbrMA5 = GradientBoostingRegressor(learning_rate=0.00125, max_depth=5,
loss='huber', n_estimators=1000, subsample=0.1, random_state=0)
#adabMA5 = AdaBoostRegressor(DecisionTreeRegressor(max_depth=6), n_estimators=1000,
loss='linear', learning_rate=0.9, random_state=0)
knnMA5 = KNeighborsRegressor(n_neighbors=21,weights="distance")
#modelMA5 = VotingRegressor(estimators=[('svr',svrMA5),('mlp',mlpMA5),
('bayr',bayrMA5),('gbr',gbrMA5),('adab',adabMA5),('knn',knnMA5)],n_jobs=-1)
modelMA5 = VotingRegressor(estimators=[('mlp',mlpMA5),('bayr',bayrMA5),
('knn',knnMA5)],n_jobs=-1)
print(">> Avaliando modelo de Regressão MA5...")
modelMA5.fit(atributosMA5_train,saidasMA5_train)
y_true = saidasMA5_test
y_pred = modelMA5.predict(atributosMA5_test)
maxe = max_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
print("modelMA5-maxe: ",maxe)
print("modelMA5-mae: ",mae)
print("modelMA5-mse: ",mse)
from matplotlib import pyplot
pyplot.plot(y_true, label='y_true')
pyplot.plot(y_pred, label='modelMA5-y_pred')
pyplot.legend()
pyplot.show()
fim = time.time()
print("Tempo para treinar e avaliar modelMA5 --> ", fim - inicio, " segundos.")

'''inicio = time.time()
modelMA10 = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
print(">> Avaliando modelo de Regressão MA10...")
modelMA10.fit(atributosMA10_train,saidasMA10_train)
y_true = saidasMA10_test
y_pred = modelMA10.predict(atributosMA10_test)
maxe = max_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
print("modelMA10-maxe: ",maxe)
print("modelMA10-mae: ",mae)
print("modelMA10-mse: ",mse)
from matplotlib import pyplot
pyplot.plot(y_true, label='y_true')
pyplot.plot(y_pred, label='modelMA10-y_pred')
pyplot.legend()
pyplot.show()
fim = time.time()
print("Tempo para treinar e avaliar modelMA10 --> ", fim - inicio, " segundos.")

inicio = time.time()
modelRates10 = BayesianRidge(n_iter=1000,tol=1e-
29,alpha_init=None,lambda_init=0.0001,alpha_1=1e-19,alpha_2=1e-19,lambda_1=1e-
19,lambda_2=1e-19)
print(">> Avaliando modelo de Regressão Rates10...")
modelRates10.fit(atributosRates10_train,saidasRates10_train)
y_true = saidasRates10_test
y_pred = modelRates10.predict(atributosRates10_test)
maxe = max_error(y_true, y_pred)
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
print("modelRates10-maxe: ",maxe)
print("modelRates10-mae: ",mae)
print("modelRates10-mse: ",mse)
from matplotlib import pyplot
pyplot.plot(y_true, label='y_true')
pyplot.plot(y_pred, label='modelRates10-y_pred')
pyplot.legend()
pyplot.show()
fim = time.time()
print("Tempo para treinar e avaliar modelRates10 --> ", fim - inicio, "
segundos.")'''

print(">> treinando modelo Final...")

scAtributosMA1 = StandardScaler().fit(atributosMA1)
atributosMA1 = scAtributosMA1.transform(atributosMA1)
pcaMA1 = PCA(n_components='mle').fit(atributosMA1)
atributosMA1 = pcaMA1.transform(atributosMA1)

scAtributosMA3 = StandardScaler().fit(atributosMA3)
atributosMA3 = scAtributosMA3.transform(atributosMA3)
pcaMA3 = PCA(n_components='mle').fit(atributosMA3)
atributosMA3 = pcaMA3.transform(atributosMA3)
scAtributosMA5 = StandardScaler().fit(atributosMA5)
atributosMA5 = scAtributosMA5.transform(atributosMA5)
pcaMA5 = PCA(n_components='mle').fit(atributosMA5)
atributosMA5 = pcaMA5.transform(atributosMA5)

'''scAtributosMA10 = StandardScaler().fit(atributosMA10)
atributosMA10 = scAtributosMA10.transform(atributosMA10)
pcaMA10 = PCA(n_components='mle').fit(atributosMA10)
atributosMA10 = pcaMA10.transform(atributosMA10)

scAtributosRates10 = StandardScaler().fit(atributosRates10)
atributosRates10 = scAtributosRates10.transform(atributosRates10)
pcaRates10 = PCA(n_components='mle').fit(atributosRates10)
atributosRates10 = pcaRates10.transform(atributosRates10) '''

modelMA1.fit(atributosMA1,saidasMA1)
modelMA3.fit(atributosMA3,saidasMA3)
modelMA5.fit(atributosMA5,saidasMA5)
'''modelMA10.fit(atributosMA10,saidasMA10)
modelRates10.fit(atributosRates10,saidasRates10)'''

print(">> modelo pronto!")

while(True):

if(os.path.isfile('deepOracleTrader_RequestData.csv')):

try:

requestData = pd.read_csv('deepOracleTrader_RequestData.csv', sep=",",

index_col=0, encoding="utf_16")
#print(requestData)
requestMA1 = requestData.iloc[:, 0:90].values
requestMA3 = requestData.iloc[:, 0:90].values
requestMA5 = requestData.iloc[:, 0:90].values
'''requestMA10 = requestData.iloc[:, 0:110].values
requestRates10 = requestData.iloc[:, 0:110].values '''

try:
print("> Padronizando requisição.")
requestMA1 = scAtributosMA1.transform(requestMA1)
requestMA1 = pcaMA1.transform(requestMA1)

requestMA3 = scAtributosMA3.transform(requestMA3)
requestMA3 = pcaMA3.transform(requestMA3)

requestMA5 = scAtributosMA5.transform(requestMA5)
requestMA5 = pcaMA5.transform(requestMA5)

'''requestMA10 = scAtributosMA10.transform(requestMA10)
requestMA10 = pcaMA10.transform(requestMA10) '''

print("Calculando resposta da requisição...")

MA1Predict = modelMA1.predict(requestMA1)
MA3Predict = modelMA3.predict(requestMA3)
MA5Predict = modelMA5.predict(requestMA5)
''' MA10Predict = modelMA10.predict(requestMA1)

requestRates10 =
np.concatenate((requestRates10,MA1Predict.reshape(-1,1)),axis=1)
requestRates10 =
np.concatenate((requestRates10,MA3Predict.reshape(-1,1)),axis=1)
requestRates10 =
np.concatenate((requestRates10,MA5Predict.reshape(-1,1)),axis=1)
requestRates10 =
np.concatenate((requestRates10,MA10Predict.reshape(-1,1)),axis=1)

requestRates10 = scAtributosRates10.transform(requestRates10)
requestRates10 = pcaRates10.transform(requestRates10)

Rates10Predict = modelRates10.predict(requestRates10) '''

response = str(MA1Predict[0])+","+str(MA3Predict[0])
+","+str(MA5Predict[0])
print("> previsão: ",response)

try:
responsefile = open('deepOracleTrader_ResponseData.txt', 'w')
responsefile.write(str(response))
responsefile.close()
os.remove('deepOracleTrader_RequestData.csv') #deleta o arquivo
de requisição .
time.sleep(1)
except:
print("ERRO durante a gravação da resposta!")
time.sleep(1)

except:
print("ERRO durante a execução do algoritmo!")

except:
print("Aguardando autorização para acessar o request...")
time.sleep(1)

# -*- coding: utf-8 -*-'''