exodus-stock/predictor.py

import os
import sys
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
import tensorflow as tf
import numpy as np
import matplotlib.animation as animation
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from datetime import datetime
from datetime import timedelta
from tqdm import tqdm
sns.set()
import json
tf.compat.v1.random.set_random_seed(1234)
from matplotlib import style
# import matplotlib.backends.backend_qt5agg
# %matplotlib qt
style.use('ggplot')
import math
import yfinance as yf
import time
from datetime import date, timedelta
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
import cProfile
import pstats

# In[34]:

symbols=os.listdir()
symbols
tf.compat.v1.disable_eager_execution()
# INITIAL VARS
test_size = 14
simulation_size = 1

# MODEL VARS
num_layers = 2                       
size_layer = 128
timestamp = 7
epoch = 20
dropout_rate = 0.8
prediction_gap = sys.argv[2]
future_day = test_size
learning_rate = 0.01
graph_loss = []

# In[35]:
# Necessary Dirs
# def date_manage(date1,date2=None):
#     if date2 is None:
#         date2=date1+timedelta(days=365)
#     date_col=[]
#     for n in range(int ((date2 - date1).days)+1): 
#         date_col.append(date1 + timedelta(n))
#     weekdays = [5,6]
#     date_result=[]
#     for dt in date_col:
#         if dt.weekday() not in weekdays:            
#             dt.strftime("%Y-%m-%d")
#     return date_result


# In[36]:
def loss_animate(ax, i):
    json_loss = pd.DataFrame(total_loss)
    ax.plot(i)
    return ax


def loader(symbol,test_size,date):
    # dateparse = lambda dates : pd.datetime.strptime(dates,'%Y-%m')
    # df = pd.read_csv('../dataset/IBMCUT.csv',parse_dates=['Date'], index_col = 'Date', date_parser=dateparse)

    df=yf.Ticker(symbol)
    # df=df.history(period="1y",interval="1d")
    # df=df.history(start=date-timedelta(days=365),end=date,interval="1d")
    df=df.history(start=date-timedelta(days=365*3),end=date,interval="1d")
    df=df.reset_index(level=0)

    # df=df.drop(columns=['Dividends'], axis=1)
    df=df.drop(columns=['Stock Splits'], axis=1)

    df['Up'] = df['High'].ewm(span=6,adjust=False).mean() + 2* df['High'].rolling(window=6).std()
    df['Down']= df['Low'].ewm(span=8,adjust=False).mean() - 2* df['Low'].rolling(window=8).std()

    df=df.dropna()
    df=df.drop(df.tail(5).index)

    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()
#     for i in range(test_size):
#         #date_ori.append(date_ori[-1] + timedelta(days = 1))
#         add=1
#         while ((date_ori[-1]) + timedelta(days = add)).weekday() in [5,6]:
#             add=add+1
#         date_ori.append(date_ori[-1] + timedelta(days = add))
    date_ori = pd.Series(date_ori).dt.strftime(date_format = '%Y-%m-%d').tolist()
    print(len(df),len(date_ori))
    return df,date_ori

def trueloader(symbol,test_size,date):
    #   df2 = pd.read_csv(symbol)
    #   print("LENDF2:",len(df2))

    df2 = yf.Ticker(symbol)
    # df2 = df2.history(start=date-timedelta(days=365),end=date,interval="1d")
    df2 = df2.history(start=date-timedelta(days=365*3),end=date,interval="1d")
    df2 = df2.reset_index(level=0)
    df2 = df2.drop(columns=['Dividends'], axis=1)
    df2 = df2.drop(columns=['Stock Splits'], axis=1)
    df2 = df2.drop(df2.head(7).index)
    # df2 = df2.drop(df2.tail(test_size).index)

    return df2

# In[38]:

def preproc(df):
    minmax = MinMaxScaler().fit(df.iloc[:,1:9].astype('float32')) # Close, Volume, and all
    df_log = minmax.transform(df.iloc[:, 1:9].astype('float32')) # Close, Volume, and all
    df_log = pd.DataFrame(df_log)
    df_log.head()
    return df_log,minmax


# In[39]:


class Model:
    def __init__(
        self,
        learning_rate,
        num_layers,
        size,
        size_layer,
        output_size,
        forget_bias = 0.1,
    ):
        def lstm_cell(size_layer):
            # print("ASDasdasdasd",len(tf.compat.v1.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple = False))
            return tf.compat.v1.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple = False)

        rnn_cells = tf.compat.v1.nn.rnn_cell.MultiRNNCell(
            [lstm_cell(size_layer) for _ in range(num_layers)],
            state_is_tuple = False,
        )
        self.X = tf.compat.v1.placeholder(tf.float32, (None, None, size))
        self.Y = tf.compat.v1.placeholder(tf.float32, (None, output_size))
#         self.X = tf.keras.Input((None, size),dtype=tf.float32)
#         self.Y = tf.keras.Input((output_size),dtype=tf.float32)
        drop = tf.compat.v1.nn.rnn_cell.DropoutWrapper(
            rnn_cells, output_keep_prob = forget_bias
        )
#         print("XXXX:",self.X)
#         print("XXXX:",self.X.shape)
#         print("XXXX:",self.Y)
#         print("XXXX:",self.Y.shape)
        #print("LOOOASDSDASD")
        self.hidden_layer = tf.compat.v1.placeholder(
            tf.float32, (None, num_layers * 2 * size_layer)
        )
        self.outputs, self.last_state = tf.compat.v1.nn.dynamic_rnn(
            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32
        )
        #rint("INIDIA",self.outputs)
        self.logits = tf.compat.v1.layers.dense(self.outputs[-1], output_size)
        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))
        self.optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate).minimize(
            self.cost
        )
        #print("cost:",self.cost)
        #print("cost:",self.optimizer)
        
def calculate_accuracy(real, predict):
    real = np.array(real) + 1
    predict = np.array(predict) + 1
    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))
    return percentage * 100

def anchor(signal, weight):
    buffer = []
    last = signal[0]
    for i in signal:
        smoothed_val = last * weight + (1 - weight) * i
        buffer.append(smoothed_val)
        last = smoothed_val
    return buffer


# In[40]:
def main_train(df_beta, df_train, df, minmax):

    modelnn = Model(
        learning_rate, num_layers, df_beta.shape[1], size_layer, df_beta.shape[1], dropout_rate
    )
    sess = tf.compat.v1.Session()   
    sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(intra_op_parallelism_threads=64,inter_op_parallelism_threads=64))
    sess.run(tf.compat.v1.global_variables_initializer())
    pbar = tqdm(range(10), desc = 'Main train loop') # Default 500 range
    for i in pbar:
        init_value = np.zeros((1, num_layers * 2 * size_layer))
        total_loss, total_acc = [], []
        print("Degugging : ")
        for k in range(0, df_train.shape[0] - 1, timestamp):
            index = min(k + timestamp, df_train.shape[0] - 1)
            print(index)
            batch_x = np.expand_dims(
                df_train.iloc[k : index, :].values, axis = 0
            )
            
            batch_y = df_train.iloc[k + 1 : index + 1, :].values
            #print("BATCH_X:",batch_x)
            #print("BATCH_Y:",batch_y)
            logits, last_state,__,loss = sess.run(
                [modelnn.logits, modelnn.last_state,modelnn.optimizer, modelnn.cost],
                feed_dict = {
                    modelnn.X: batch_x,
                    modelnn.Y: batch_y,
                    modelnn.hidden_layer: init_value,
                },
            )
            init_value = last_state
            total_loss.append(loss)
            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))
        # json_loss.to_json("./loss.json")
        graph_loss.append(np.mean(total_loss))

        #np.save(loss_file, np.array(graph_loss))
        pbar.set_postfix(cost = np.mean(total_loss), min_acc = np.min(total_acc), mean_acc=np.mean(total_acc))


def forecast(df_beta,df_train,df,minmax):
#     print("DF_BETA:",df_beta)
#     print("DF_TRAIN:",df_train)
    # tf.compat.v1.variable_scope("AAA", reuse=True)
    tf.compat.v1.reset_default_graph()
    modelnn = Model(
        learning_rate, num_layers, df_beta.shape[1], size_layer, df_beta.shape[1], dropout_rate
    )
#     print("MODELX: ",modelnn.X)
#     print("MODELY: ",modelnn.Y)
#     print("MODELLayer: ",modelnn.hidden_layer)
    sess = tf.compat.v1.Session()   
    sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(intra_op_parallelism_threads=64,inter_op_parallelism_threads=64))
    sess.run(tf.compat.v1.global_variables_initializer())
    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()
#     print("INI___!:",df_train.shape[0] - 1, timestamp)
#     print(df_train.shape[0])
    pbar = tqdm(range(epoch), desc = 'train loop')
    for i in pbar:
        # init_value = np.zeros((1, num_layers * 2 * size_layer))
        total_loss, total_acc = [], []
        print("Degugging : ")
        for k in range(0, df_train.shape[0] - 1, timestamp):
            init_value = np.zeros((1, num_layers * 2 * size_layer))
            index = min(k + timestamp, df_train.shape[0] - 1)
            # print(index)
            batch_x = np.expand_dims(
                df_train.iloc[k : index, :].values, axis = 0
            )
            
            batch_y = df_train.iloc[k + 1 : index + 1, :].values
            print("BATCH_X:",batch_x)
            print("BATCH_Y:",batch_y)
            logits, last_state,__,loss = sess.run(
                [modelnn.logits, modelnn.last_state,modelnn.optimizer, modelnn.cost],
                feed_dict = {
                    modelnn.X: batch_x,
                    modelnn.Y: batch_y,
                    modelnn.hidden_layer: init_value,
                },
            )
            #   print("BATCHX:",batch_x)
            #   print("MODELX: ",modelnn.X)
            #   print("MODELY: ",modelnn.Y)
            #   print("MODELLayer: ",modelnn.hidden_layer)
            #   print("OUTSSS:",len(outs))
            #   print("opt:",opt)
            #   print("outs1",batch_x[0])
            #   print("outs2",outs[1])
            #   print("outs3",outs[2])
            #   print("outs4",outs[3])
            #   input()
            init_value = last_state
            total_loss.append(loss)
            #print("LOGITS:",logits[:, 0])
            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))
        # json_loss.to_json("./loss.json")
        graph_loss.append(np.mean(total_loss))

        #np.save(loss_file, np.array(graph_loss))
        pbar.set_postfix(cost = np.mean(total_loss), min_acc = np.min(total_acc), mean_acc=np.mean(total_acc))
    future_day = test_size

    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))
    output_predict[0] = df_train.iloc[0]
    upper_b = (df_train.shape[0] // timestamp) * timestamp
    init_value = np.zeros((1, num_layers * 2 * size_layer))

    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):
        out_logits, last_state = sess.run(
            [modelnn.logits, modelnn.last_state],
            feed_dict = {
                modelnn.X: np.expand_dims(
                    df_train.iloc[k : k + timestamp], axis = 0
                ),
                modelnn.hidden_layer: init_value,
            },
        )
        init_value = last_state
        output_predict[k + 1 : k + timestamp + 1] = out_logits

    if upper_b != df_train.shape[0]:
        out_logits, last_state = sess.run(
            [modelnn.logits, modelnn.last_state],
            feed_dict = {
                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0),
                modelnn.hidden_layer: init_value,
            },
        )
        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits
        future_day -= 1
        date_ori.append(date_ori[-1] + timedelta(days = 1))

    init_value = last_state

    for i in range(future_day):
        o = output_predict[-future_day - timestamp + i:-future_day + i]
        out_logits, last_state = sess.run(
            [modelnn.logits, modelnn.last_state],
            feed_dict = {
                modelnn.X: np.expand_dims(o, axis = 0),
                modelnn.hidden_layer: init_value,
            },
        )
        init_value = last_state
        output_predict[-future_day + i] = out_logits[-1]
        date_ori.append(date_ori[-1] + timedelta(days = 1))

    output_predict = minmax.inverse_transform(output_predict)
    deep_future = anchor(output_predict[:, 0], 0.3)
    sess.close()
    sess.__del__()
    return deep_future


# In[41]:


def newaccuration(accepted_results,truetrend):
    hasilutama=0
    indexbagus=0
    truest=0
    predictest=0
    for i,x in enumerate(accepted_results):
        a=x[-(test_size+2):]

        #a=x[:((test_size+2)/2)]
        print("a",a)
        b=truetrend[-(test_size+1):]
        #print("b",b)
        hasil=0
        true=[]
        predict=[]
        for xy in range(1,len((a))):
            if a[xy]<a[xy-1]:
                predict.append("Down")
            else:
                predict.append("Up")
            if b[xy]<b[xy-1]:

                true.append("Down")
            else:
                true.append("Up")

        print(true)
        print(predict)
        for xz in range(len(true)):
            if true[xz]==predict[xz]:
                hasil=hasil+1
        if hasil > hasilutama:
            hasilutama=hasil
            indexbagus=i
            truest=true
            predictest=predict
            salah=[]
            for xz in range(len(truest)):
                if truest[xz]!=predictest[xz]:
                    salah.append(xz)
                    # if xz!=0:
                        # salah.append(xz-1)
                # print("INI:",b)
    print("TRUEST",truest)
    print("predictest",predictest)
    return hasilutama,indexbagus,salah

# In[42]:


def betaforecast(simulationsize,dfx,dftrain,df,df2,minmax):
    results = []
    for i in range(simulationsize):
        forecast_res = forecast(df,dftrain,dfx,minmax)
        results.append(forecast_res)
    accepted_results = []

    while not (np.array(results[0][-test_size:]) < np.min(dfx['Close'])).sum() == 0 and         (np.array(results[0][-test_size:]) > np.max(dfx['Close']) * 2).sum() == 0:
        print("++++++++++++++++++++++++")
        print("Forecast Recalled...")
        results[0]=forecast(df,dftrain,dfx,minmax)
    return results[0]


# In[43]:


def interval(p1,p2):
     return abs((p1) - (p2))


# In[44]:


def checkaccuracy2(true):
    avg=[]
    for x in range(len(true)-7):
        avg.append(interval(true[x],true[x+1]))
    average=sum(avg) / len(avg)
    return average
    


# In[45]:


def checkaccuracy(predict,true,filterx, test_size):
    print("True Length: ",len(true))
    print("Predict Length: ",len(predict))
    
#     avg=[]
    
#     for x in range(len(true)-5):
#         avg.append(interval(true[x],predict[x]))
#     average=sum(avg) / len(avg)
#     print("AVG1:",average)
#     print("AVG2:",threshold)
    
    temp_predict=predict[-test_size:]
    temp_true=true[-test_size:]
    
#     avg2=interval(max(predict),min(predict))
    count=0
    print("------------------------------------")
    for x in range(test_size):
        # acc_var1 = temp_true[x]-(1/filterx*temp_true[x])
        acc_var1 = temp_true[x]-(filterx/10)
        acc_var2 = temp_predict[x]
        # acc_var3 = temp_true[x]+(1/filterx*temp_true[x])
        acc_var3 = temp_true[x]+(filterx/10)
        acc_condition = acc_var1 <= acc_var2 <= acc_var3
        # print("Var 1 : ",acc_var1)
        # print("Var 2 : ",acc_var2)
        # print("Var 3 : ",acc_var3)
        # print("Day "+str(x+1)+" "+str(int(acc_var1))+" "+str(int(acc_var2))+" "+str(int(acc_var3))+" : ",acc_condition)
        print("Day "+str(x+1)+", Price : "+str(int(temp_true[x]))+" ,Gap = "+str(int(abs(temp_predict[x]-temp_true[x])))+" : ",acc_condition)
        if (acc_condition):
            count=count+1
    print("------------------------------------")
    if count>7:
        print("Result True")
        return True
    else: 
        print("Result False")
        return False
        
#     if average>threshold:
#         return False
#     else:
#         return True


# In[46]:


def findthreshold(simulationsize,dfx,dftrain,df,df2,minmax):
    results=[]
    for i in range(simulationsize):
        results.append(forecast(df,dftrain,dfx,minmax))
    accepted_results = []

    for r in results:

        if (np.array(r[-test_size:]) < np.min(dfx['Close'])).sum() == 0 and             (np.array(r[-test_size:]) > np.max(dfx['Close']) * 2).sum() == 0:
            accepted_results.append(r)

    finalavg=999999
    for o in accepted_results:
        avg=[]
        for x in range(len(o)-5):
            avg.append(interval(o[x],df2[x]))
        average=sum(avg) / len(avg)
        if average<=finalavg:
            finalavg=average

    return finalavg

def temp_data(date, xi, resultfinal, df2, date_col,x):
    print("Called . . . ")
    if os.path.isdir("TempData/") == False:
        os.mkdir("TempData/")
    if os.path.isdir("TempData/%s"%x) == False:
        os.mkdir("TempData/%s"%x)
    if os.path.isdir("TempData/%s/"%x+str(date)) == False:
        os.mkdir("TempData/%s/"%x+str(date))
    with open("TempData/%s/"%x+str(date)+"/"+x+str(xi)+".vezpal2","w+") as oop:
        main=[]
        main.append(resultfinal) # prediction
        main.append(list(df2['Close']))
        main.append(date_col)
#         main.append(3)
#         main.append([0])
        json.dump(main,oop)

def automaton(simulationsize,date):

    # symbols=["AAPL"]
    symbols = sys.argv[1]
    times=[]
    x=symbols
    # for x in symbols:
    temp_time=[]
    temp_time.append(x)
    counter=0
    validity=0
    df,date_col=loader(x,test_size,date)
    # print(type(df))
    dfx=df
    # print("ASDSAD")
    df2=trueloader(x,test_size,date)
    df,minmax=preproc(df)
    dftrain=df
    wrong=[1,2,3,4,5]
    # avg=checkaccuracy2(list(df2["Close"]))
    # start=time.time()
    # avg=findthreshold(50,dfx,dftrain,df,list(df2["Close"]),minmax)
    # temp_time.append(time.time()-start)
    start=time.time()
    filterx = int(prediction_gap)
    able=False
    print("============== || Initial Train || =============")
    main_train(df,dftrain,dfx,minmax)
    for xi in range(5):
        decision=False
        while (decision==False):
            print()
            print("====== [ Foreacasting Attempt : "+str(counter+1)+"  ] ===========")
            print("====== [ Progress  : "+str(xi)+"/5  ] ")
            resultfinal=betaforecast(simulationsize,dfx,dftrain,df,df2,minmax)
            # validity=valid
            decision=checkaccuracy(resultfinal,list(df2["Close"]),filterx, test_size)
            # wrong=invalid
            if decision==True:
                able=True
                print("ABLE")
                print(str(filterx))
            if counter > 10 and decision != True:
                counter = 0
                filterx=filterx+10
                print("Filter X new value : "+str(filterx))
                print("Decision Status : ", decision)
                print("**************************************")
#                         avg=avg+(1/3*avg)
            if filterx>1000:
                print("====== [ GG, we gave up] =====")
                continue
            counter=counter+1
            temp_data(date, xi, resultfinal, df2, date_col, x)
        print("[ Loop : "+x+" done ] =========================")
        print()

        if os.path.isdir("Backtest/") == False:
            os.mkdir("Backtest/")
        if os.path.isdir("Backtest/%s"%x) == False:
            os.mkdir("Backtest/%s"%x)
        if os.path.isdir("Backtest/%s/"%x+str(date)) == False:
            os.mkdir("Backtest/%s/"%x+str(date))
        with open("Backtest/%s/"%x+str(date)+"/"+x+str(xi)+".vezpal2","w+") as oop:
            main=[]
            main.append(resultfinal) #prediction
            main.append(list(df2['Close']))
            main.append(date_col)
#                     main.append(3)
#                     main.append([0])
            json.dump(main,oop)
    print("Time for %s  :"%x,time.time()-start)
    temp_time.append(time.time()-start)
    times.append(temp_time)
    return times

def predictor(simulationsize,current):
    for x in range(52):
        tf.compat.v1.reset_default_graph()
        current+=timedelta(days=7)
        automaton(simulationsize,current)

current_date=date(2020,1,1)
if os.path.isdir("Loss/") == False:
    os.mkdir("Loss/")
if os.path.isdir("Loss/"+str(current_date)) == False:
    os.mkdir("Loss/"+str(current_date))

# loss_file = time.strftime("%Y%m%d-%H%M%S")
# loss_file = "Loss/"+str(date.today())+"/"+loss_file
global_start = time.time()
# profile = cProfile.Profile()

# main_func = "predictor(simulation_size,current_date)"
predictor(simulation_size,current_date)
# ps = pstats.Stats(profile.run(main_func))
print("Overall time consumption ", str(time.time()-global_start))
# ps.dump_stats("./Cprofile_model_01.ps")