Change app.py

Signed-off-by: Aadhitya A <aadhitya864@gmail.com>

app.py

@@ -74,340 +74,6 @@ ACCELERATOR = "cpu"
 w = 7
 prax = [0 for x in range(w)] 
 
-# %%
-# Objective function for Optuna (CNN-LSTM)
-def objective(trial, X_train, y_train, X_test, y_test):
-    model = tf.keras.Sequential()
-
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-
-    # LSTM layers
-    model.add(Bidirectional(LSTM(trial.suggest_int("lstm_units_1", 32, 256), return_sequences=True)))
-    model.add(Dropout(trial.suggest_float("dropout_1", 0.1, 0.5)))
-    model.add(Bidirectional(LSTM(trial.suggest_int("lstm_units_2", 32, 256), return_sequences=False)))
-    model.add(Dropout(trial.suggest_float("dropout_2", 0.1, 0.5)))
-
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-
-    # Train the model
-    pruning_callback = TFKerasPruningCallback(trial, "val_loss")
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=15, batch_size=32, verbose=0, callbacks=[pruning_callback])
-
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-
-    return loss
-
-# %%
-# Function to train the model (CNN-LSTM)
-def modelCNNLSTM(csv_file, prax):
-    # Read the data
-    df = csv_file
-    #df = df['Date/Time'].values.astype("float64")
-    temp_data = df.iloc[0:len(df)-100, 1:21]
-    trek = df.iloc[len(df)-100:,1:21]
-    #print(temp_data)
-    data = temp_data
-    sc = MinMaxScaler()
-    # Split the data into training and testing sets
-    train_size = int(len(data) * 0.8)
-    train_data, test_data = data[:train_size], data[train_size:]
-    # Separate the input features and target variable
-    X_train, y_train = train_data, train_data['Close']
-    X_test, y_test = test_data, test_data['Close']
-
-    X_train = X_train[0:len(X_train)-1]
-    y_train = y_train[1:len(y_train)]
-    X_test = X_test[0:len(X_test)-1]
-    y_test = y_test[1:len(y_test)]
-
-    Xt = X_train
-    Xts = X_test
-    Yt = y_train
-    Yts = y_test
-
-    y_train = y_train.values.reshape(-1,1)
-    y_test = y_test.values.reshape(-1,1)
-
-    X_train = sc.fit_transform(X_train)
-    y_train = sc.fit_transform(y_train)
-    X_test = sc.fit_transform(X_test)
-    y_test = sc.fit_transform(y_test)
-
-    x_tr=pd.DataFrame(X_train, index = Xt.index, columns = Xt.columns)
-    y_tr=pd.DataFrame(y_train, index = Yt.index)
-    x_te=pd.DataFrame(X_test, index = Xts.index, columns = Xts.columns)
-    y_te=pd.DataFrame(y_test, index = Yts.index)
-
-    # Reshape the data for the CNN-LSTM model
-    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
-    X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
-
-    study = optuna.create_study(direction="minimize", pruner=optuna.pruners.MedianPruner(n_min_trials=4, n_startup_trials=4))
-    fn = lambda trial: objective(trial, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test)
-    study.optimize(fn, n_trials=5)
-
-    best_params = study.best_params
-    #print(f"Best params: {best_params}")
-
-    model = tf.keras.Sequential()
-
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-
-    # LSTM layers
-    model.add(Bidirectional(LSTM(best_params["lstm_units_1"], return_sequences=True)))
-    model.add(Dropout(best_params["dropout_1"]))
-    model.add(Bidirectional(LSTM(best_params["lstm_units_2"], return_sequences=False)))
-    model.add(Dropout(best_params["dropout_2"]))
-
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-
-    # Train the model
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=32, verbose=0)
-
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-
-    print(f"Final loss (without KFold): {loss}")
-        
-    kfold = KFold(n_splits=10, shuffle=True)
-
-    inputs = np.concatenate((X_train, X_test), axis=0)
-    targets = np.concatenate((y_train, y_test), axis=0)
-    acc_per_fold = []
-    loss_per_fold = []
-    xgb_res = []
-    num_epochs = 10
-    batch_size = 32
-
-    fold_no = 1
-    print('------------------------------------------------------------------------')
-    print("Training for 10 folds... Standby")
-    for train, test in kfold.split(inputs, targets):
-        #print('------------------------------------------------------------------------')
-        #print(f'Training for fold {fold_no} ...')
-        history = model.fit(inputs[train], targets[train],
-                  batch_size=32,
-                  epochs=15,
-                  verbose=0)
-
-        scores = model.evaluate(inputs[test], targets[test], verbose=0)
-        #print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')
-        acc_per_fold.append(scores[1] * 100)
-        loss_per_fold.append(scores[0])
-        fold_no = fold_no + 1
-
-    
-    print('------------------------------------------------------------------------')
-    #print('Score per fold')
-    #for i in range(0, len(acc_per_fold)):
-    #    print('------------------------------------------------------------------------')
-    #    print(f'> Fold {i+1} - Loss: {loss_per_fold[i]} - Loss%: {acc_per_fold[i]}%')
-    #print('------------------------------------------------------------------------')
-    #print('Average scores for all folds:')
-    #print(f'> Possible Loss %: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})')
-    #print(f'> Loss: {np.mean(loss_per_fold)}')
-    #print('------------------------------------------------------------------------')
-    
-    trek = df.iloc[0:len(df), 1:21]
-    Y = trek[0:len(trek)]
-    YP = trek[1:len(trek)]
-    Y1 = Y['Close']
-    Y2 = YP['Close']
-    Yx = pd.DataFrame(YP, index=YP.index, columns=YP.columns)
-    #X = sc.fit_transform(X.reshape(-1,22))
-    Y = np.array(Y)
-    Y1 = np.array(Y1)
-    Y = sc.fit_transform(Y)
-    Y1 = Y1.reshape(-1,1)
-    Y1 = sc.fit_transform(Y1)
-
-    train_X = Y.reshape(Y.shape[0],Y.shape[1],1)
-    #Y = Y.reshape(-1,1)
-    pred = model.predict(train_X, verbose=0)
-    pred = np.array(pred).reshape(-1,1)
-    var2 = max_error(pred.reshape(-1,1), Y1)
-    print('Max Error: %f' % var2)
-    prax[5] = float(var2)
-    pred = sc.inverse_transform(pred)
-
-    print(pred[-2], pred[-1])
-    prax[3] = pred[-2]
-    prax[4] = pred[-1]
-    if(pred[-1]-pred[-2]>0):
-        prax[6] = 1 
-    elif(pred[-1]-pred[-2]==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-
-# %%
-# Function to train the model (CNN-LSTM)
-def modelCNNLSTM_OpenGap(csv_file, prax):
-    # Read the data
-    df = csv_file
-    datLength = len(df)
-    df['O-C'] = 0
-    for i in range(datLength):
-        if i == 0:
-            df['O-C'][i] = 0
-            continue
-        else:
-            df['O-C'][i] = df['Open'][i] - df['Close'][i-1]
-    temp_data = df.iloc[0:datLength-100, 1:22]
-    trek = df.iloc[datLength-100:,1:22]
-    #print(temp_data)
-    data = temp_data
-    #data = data.values.astype("float64")
-    sc = MinMaxScaler()
-    # Split the data into training and testing sets
-    train_size = int(len(data) * 0.8)
-    train_data, test_data = data[:train_size], data[train_size:]
-
-    # Separate the input features and target variable
-    X_train, y_train = train_data, train_data['Close']
-    X_test, y_test = test_data, test_data['Close']
-
-    X_train = X_train[0:len(X_train)-1]
-    y_train = y_train[1:len(y_train)]
-    X_test = X_test[0:len(X_test)-1]
-    y_test = y_test[1:len(y_test)]
-
-    Xt = X_train
-    Xts = X_test
-    Yt = y_train
-    Yts = y_test
-
-    y_train = y_train.values.reshape(-1,1)
-    y_test = y_test.values.reshape(-1,1)
-
-    X_train = sc.fit_transform(X_train)
-    y_train = sc.fit_transform(y_train)
-    X_test = sc.fit_transform(X_test)
-    y_test = sc.fit_transform(y_test)
-
-    x_tr=pd.DataFrame(X_train, index = Xt.index, columns = Xt.columns)
-    y_tr=pd.DataFrame(y_train, index = Yt.index)
-    x_te=pd.DataFrame(X_test, index = Xts.index, columns = Xts.columns)
-    y_te=pd.DataFrame(y_test, index = Yts.index)
-
-    # Reshape the data for the CNN-LSTM model
-    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
-    X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))
-
-    study = optuna.create_study(direction="minimize", pruner=optuna.pruners.MedianPruner(n_min_trials=2, n_startup_trials=2))
-    fn = lambda trial: objective(trial, X_train=X_train, X_test=X_test, y_train=y_train, y_test=y_test)
-    study.optimize(fn, n_trials=5)
-
-    best_params = study.best_params
-    #print(f"Best params: {best_params}")
-
-    model = tf.keras.Sequential()
-
-    # Creating the Neural Network model here...
-    # CNN layers
-    model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
-    # model.add(Dense(5, kernel_regularizer=L2(0.01)))
-
-    # LSTM layers
-    model.add(Bidirectional(LSTM(best_params["lstm_units_1"], return_sequences=True)))
-    model.add(Dropout(best_params["dropout_1"]))
-    model.add(Bidirectional(LSTM(best_params["lstm_units_2"], return_sequences=False)))
-    model.add(Dropout(best_params["dropout_2"]))
-
-    #Final layers
-    model.add(Dense(1, activation='relu'))
-    model.compile(optimizer='adam', loss='mse', metrics=['mse'])
-
-    # Train the model
-    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=32, verbose=0)
-
-    # Evaluate the model
-    loss = model.evaluate(X_test, y_test, verbose=0)[0]
-
-    print(f"Final loss (without KFold): {loss}")
-        
-    kfold = KFold(n_splits=10, shuffle=True)
-
-    inputs = np.concatenate((X_train, X_test), axis=0)
-    targets = np.concatenate((y_train, y_test), axis=0)
-    acc_per_fold = []
-    loss_per_fold = []
-    xgb_res = []
-    num_epochs = 10
-    batch_size = 32
-
-    fold_no = 1
-    print('------------------------------------------------------------------------')
-    print("Training for 10 folds... Standby")
-    for train, test in kfold.split(inputs, targets):
-        #print('------------------------------------------------------------------------')
-        #print(f'Training for fold {fold_no} ...')
-        history = model.fit(inputs[train], targets[train],
-                  batch_size=32,
-                  epochs=15,
-                  verbose=0)
-
-        scores = model.evaluate(inputs[test], targets[test], verbose=0)
-        #print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%')
-        acc_per_fold.append(scores[1] * 100)
-        loss_per_fold.append(scores[0])
-        fold_no = fold_no + 1
-
-    
-    print('------------------------------------------------------------------------')
-    #print('Score per fold')
-    #for i in range(0, len(acc_per_fold)):
-    #    print('------------------------------------------------------------------------')
-    #    print(f'> Fold {i+1} - Loss: {loss_per_fold[i]} - Loss%: {acc_per_fold[i]}%')
-    #print('------------------------------------------------------------------------')
-    #print('Average scores for all folds:')
-    #print(f'> Possible Loss %: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})')
-    #print(f'> Loss: {np.mean(loss_per_fold)}')
-    #print('------------------------------------------------------------------------')
-    
-    trek = df.iloc[0:len(df), 1:22]
-    Y = trek[0:len(trek)]
-    YP = trek[1:len(trek)]
-    Y1 = Y['Close']
-    Y2 = YP['Close']
-    Yx = pd.DataFrame(YP, index=YP.index, columns=YP.columns)
-    #X = sc.fit_transform(X.reshape(-1,22))
-    Y = np.array(Y)
-    Y1 = np.array(Y1)
-    Y = sc.fit_transform(Y)
-    Y1 = Y1.reshape(-1,1)
-    Y1 = sc.fit_transform(Y1)
-
-    train_X = Y.reshape(Y.shape[0],Y.shape[1],1)
-    #Y = Y.reshape(-1,1)
-    pred = model.predict(train_X, verbose=0)
-    pred = np.array(pred).reshape(-1,1)
-    var2 = max_error(pred.reshape(-1,1), Y1)
-    print('Max Error: %f' % var2)
-    prax[5] = float(var2)
-    pred = sc.inverse_transform(pred)
-
-    print(pred[-2], pred[-1])
-    prax[3] = pred[-2]
-    prax[4] = pred[-1]
-    if(pred[-1]-pred[-2]>0):
-        prax[6] = 1 
-    elif(pred[-1]-pred[-2]==0):
-        prax[6] = 0
-    else:
-        prax[6] = -1
-
 # %%
 # Function to train the model (TFT)
 def modelTFT(csv_file, prax):
@@ -909,14 +575,6 @@ def main(files):
         modelTFT_OpenGap(df, prax)
         prax[2] = "TFT_OpenGap"
         generate_csv(prax)
-        #df.set_index('Date/Time', inplace=True)
-        #df = df.drop(['Date/Time'], axis=1)
-        #modelCNNLSTM(df, prax)
-        #prax[2] = "CNNLSTM"
-        #generate_csv(prax)
-        #modelCNNLSTM_OpenGap(df, prax)
-        #prax[2] = "CNNLSTM_OpenGap"
-        #generate_csv(prax)
         # Generate blank line
         prax=["","","","","","",""]
         generate_csv(prax)
@@ -925,7 +583,7 @@ def main(files):
     today = date.today().strftime("%Y_%m_%d")
     return f"result_{today}.csv"
 
-gradioApp = gr.Interface(fn=main, inputs=gr.File(file_count="multiple", file_type=".csv"), outputs="file")
+gradioApp = gr.Interface(fn=main, inputs=gr.File(file_count="multiple"), outputs="file")
 
 if __name__ == "__main__":
     # Calling main function