main.py

import time
import random
import numpy as np

from utils.neural_network import NeuralNetwork
import utils.functions as utils

from utils.graph import graph
from utils.priceGraph import PriceGraph

# xs: (variables, data_length)     --> (6, 1438)
# ys: (data_length,)               --> (1438,)
# w: (w1, variables), (w1, output) -->
# b: (w1, 1), (w2, 1), ?(1, 1)     -->
""" trained_w_2025_MAPE_3_14.txt
--- Itineration 7498 ---
Normalized (Train):   MSE: 0.0007       MAE: 0.0191
Normalized (Test):    MSE: 0.0008       MAE: 0.0190
Norm (Test 2025):     MSE: 0.0175       MAE: 0.1088 --> Very high
Real scale (Train):   RMSE: 104.7396$   MAE: 77.2301$   MAPE: 3.6412%
Real scale (Test):    RMSE: 114.3909$   MAE: 76.6764$   MAPE: 3.8678%
Real (Test 2025):     RMSE: 534.6767$   MAE: 439.3730$   MAPE: 14.2091%
"""

# ---------------------------------------------------------------------
#                       SOME TO-DOs and notes
# To add new ETH prices, we need to preserve X_min and X_max (normParams located at the models' files)

# Data 2017-2024 Starting MAPE: 400% Why???
# Graph errors and predictions without overloading the graph with data (not responding)
# Add new artificial data
# Add ALL the data the model needs to predict (including in 2025)
# Make a general neuralNetwork class: data as atributes, classification/regression
# Add logOuts=False param to every function logging them
# Reduce big-params functions (using lists, global variables, etc)
# Todo en español/inglés
# Borrar comentarios/prints/bloques de código sin uso

print("-" * 10)
# print("- Poder re-entrenar -")
# print("Datos de varios dias")
# print("Añadir Close-n con la media o Close actual en vez de cero")
# print("Probar diferente arquitectura y LR (varios a la vez)")
print("Visualizar error (R^2) con gráficas")
print("Mostrar diferentes predicciones de 2025 (*random(0.98, 1.02)) y dibujar")
# print("Probar otros datos. Cuales?")
# print("-- Comparar predictions con el precio 2025 --")
# print(" HAY OVERFITTING? -> Test loss siempre baja. Raro // (Quitar precios 2021?)")
# print("-- Comprobar que no hay data leakage --")
# print("=== GUARDAR EN GITHUB === ")
print("Average price variation 2025: 85$ (Min: 0.2$, Max: 600$)")
print("-" * 10, "\n")


# Ver notas computación para mejorar la función de activacion
# [Unir y unificar datos en un solo archivo]
# Export model as JSON, not .txt (even to re-download it later for another train)
# Guardar modelos en .csv (JSON)
"""df = pd.DataFrame(data)
df.to_csv('metrics.csv', index=False)

# Cargar
df = pd.read_csv('metrics.csv')"""
# Not currently storing "Date" on 'data' list
# REFACTOR: all_headers vs. model_headers

#                      VERSION FINAL
# Entrenar por batches
# Normalizar con Z-score (estandarización)
# --  Usar Tensorflow --
# BTC price (and volume)
# Fear and greed. Btc/Alt season
# Regularización L1/L2
# [Learning rate variable / Uso de optimizers]
# Probar StochasticGradientDescent (Actualmente usando BatchGradientDescent (entrenando con el lote completo))
# Es mejor usar X(samples, features), segun ChatGPT


X_train, X_test, Y_train, Y_test = [], [], [], []

# -----------------------------------------------------
# ------------------ Hyperparameters ------------------
# -----------------------------------------------------
# Percentage of data used in training
DATA_SPLIT = 80
learning_rate = 0.002 # 0.02  # 0.01, 0.1 
training_steps = 1000 # 400  # 1000, 500


def getPredError(X_real, Y_real, prediction, display_all=False, name=""):
    X, Y, pred = X_real.T, Y_real.T, prediction.T
    up_down_mistakes = 0
    if display_all:
        print("\n-- GETTING PREDICTION ERROR --")
    for i in range(len(Y)):
        # Using previous value to quantify the error (We want at least to predict correctly ups/downs)
        previousPrice = X[i][0]
        predictedPrice = pred[i][0]
        closingPrice = Y[i][0]
        error = abs(closingPrice - predictedPrice)
        # Checking if their signs are equal
        if (closingPrice - previousPrice) * (predictedPrice - closingPrice) > 0:
            # Prediction is correct
            if (display_all):
                print(f"Correct! The prediction is just ${error} off")
        else:
            # Prediction is wrong
            if (display_all):
                print(f"Wrong! The model predicted ${predictedPrice}, but it closed on ${closingPrice}. Open price: ${previousPrice}, error: ${error}")
            up_down_mistakes += 1
    print(f"{name} The model got {up_down_mistakes} errors out of {len(Y)} tests. Accuracy: {100 - 100 * up_down_mistakes / len(Y):02.3f}%")


def plotPriceGraph(model, X_test_norm, Y_test_norm, Y_test_real, norm_params, days=30, block=False, name="", X_real=None):
    X_test_norm = X_test_norm.T[-days:].T
    Y_test_norm = Y_test_norm.T[-days:].T
    Y_test_real = Y_test_real.T[-days:].T
    _, pred_real = model.testRealData(X_test_norm, Y_test_norm, norm_params)

    if X_real is not None:
        getPredError(X_real, Y_test_real, pred_real)

    # Second prediction with slightly varied inputs
    print("Adding a second prediction")
    X_norm_2 = X_test_norm.copy()
    # Just modifying some inputs
    for i in range(5, len(X_norm_2)):
        for j in range(int(len(X_norm_2[i]) * 0.6), len(X_norm_2[i])):
            offset = 0.08
            X_norm_2[i][j] *= random.uniform(1 - offset, 1 + offset)
    pred_norm_2 = model.feedForward(X_norm_2)
    pred_2 = utils.unNormalizeData(pred_norm_2, norm_params)

    # Plotting the results
    print(f"** {name} **")
    print("test (norm) prices shape:", X_test_norm.shape, Y_test_norm.shape, "pred_real shape:", pred_real.shape)
    priceGraph = PriceGraph(name, np.array(pred_real[0]), np.array(Y_test_real[0]), secondPred=np.array(pred_2[0]))
    diff = np.abs(pred_real - Y_test_real)[0]
    avg = np.mean(diff)
    print(f"\n\nTESTING MODEL WITH THE LAST {days} DAYS {name} DATA:\n  Average price difference: ${avg}\n  {diff[:20]}")
    priceGraph.initializeGraph(block=block)


def main():
    num = 1 ######

    if num == 1:
        trainAndTestModel()
    else:
        trainSeveralModels()


def trainSeveralModels():
    print("Testing several models!")
    # --- TRAIN NEW MODELS ---
    X_train, Y_train, X_test, Y_test = utils.loadData(DATA_SPLIT)
    X_train_norm, Y_train_norm, norm_price = utils.normalizeTrainData(X_train, Y_train)
    X_test_norm, Y_test_norm = utils.normalizeTestData(X_test, Y_test, norm_price)
    X_2025, Y_2025 = utils.loadData()
    X_2025_norm, Y_2025_norm = utils.normalizeTestData(X_2025, Y_2025, norm_price)

    # --- Creating the models ---
    # More params/layers can cause overfitting
    # layers0 = [X_train.shape[0], 8, 1]
    layers1 = [X_train.shape[0], 8, 8, 1]
    layers1b = [X_train.shape[0], 16, 8, 1]
    layers2 = [X_train.shape[0], 64, 32, 1] # Regular
    layers3 = [X_train.shape[0], 64, 64, 32, 1] # Mejor
    layers4 = [X_train.shape[0], 32, 16, 1]
    layers5 = [X_train.shape[0], 128, 128, 1] # Regular
    # layers6 = [X_train.shape[0], 32, 32, 16, 1]
    layers7 = [X_train.shape[0], 64, 64, 64, 1]  # Mejor, muy lento
    layers8 = [X_train.shape[0], 64, 64, 1]  # Regular-Bueno
    layers9 = [X_train.shape[0], 64, 32, 16, 1] # MAL

    layers_arr = [layers1, layers2, layers4, layers7, layers8]
    learning_rate = [0.008, 0.01, 0.003]

    models_arr = []
    print(f"Training {len(layers_arr)} models with {len(learning_rate)} different learning rates!")
    print(layers_arr, learning_rate)
    # ----------------------------------------------   LAYERS   ----------------------------------------------
    """
    # TRAINING 1000 steps, learning rate = 0.0008, layers = [9, 64, 64, 32, 1] BUENO
    # TRAINING: 1000 steps, learning rate = 0.01, layers = [9, 64, 64, 32, 1] MUY BUENO (MAPE: 4-6)
    # TRAINING: 1000 steps, learning rate = 0.03, layers = [9, 64, 64, 32, 1] BUENO, UN POCO DE OVERFIT

    # TRAINING: 1000 steps, learning rate = 0.01, layers = [9, 64, 64, 64, 1] BUENO
    # TRAINING: 1000 steps, learning rate = 0.03, layers = [9, 64, 64, 64, 1] MUY BUENO, UN POCO DE OVERFIT
    #
    # Close 1-5
    # TRAINING: 1000 steps, learning rate = 0.01, layers = [9, 64, 64, 32, 1] BUENO
    # TRAINING: 1000 steps, learning rate = 0.03, layers = [9, 64, 64, 32, 1] BUENO
    # TRAINING: 1000 steps, learning rate = 0.005, layers = [9, 64, 64, 32, 1] BUENO

    # TRAINING: 1000 steps, learning rate = 0.001, layers = [9, 64, 64, 64, 1] MALO  6-8 mins
    # TRAINING: 1000 steps, learning rate = 0.0001, layers = [9, 64, 64, 64, 1] MALO
    # TRAINING: 1000 steps, learning rate = 0.0008, layers = [9, 64, 64, 64, 1] MALO
    # TRAINING: 1000 steps, learning rate = 0.01, layers = [9, 64, 64, 64, 1] BUENO!?
    # TRAINING: 1000 steps, learning rate = 0.03, layers = [9, 64, 64, 64, 1] BUENO!?
    # TRAINING: 1000 steps, learning rate = 0.005, layers = [9, 64, 64, 64, 1] MED-BUENO

    # TRAINING: 1000 steps, learning rate = 0.001, layers = [9, 64, 64, 1] MALO 5 mins
    # TRAINING: 1000 steps, learning rate = 0.0001, layers = [9, 64, 64, 1] MALO
    # TRAINING: 1000 steps, learning rate = 0.0008, layers = [9, 64, 64, 1] MALO
    # TRAINING: 1000 steps, learning rate = 0.01, layers = [9, 64, 64, 1] MED-BUENO
    # TRAINING: 1000 steps, learning rate = 0.03, layers = [9, 64, 64, 1] MED-BUENO
    # TRAINING: 1000 steps, learning rate = 0.005, layers = [9, 64, 64, 1] BUENO

    """
    # 9 Xs, TIENE MAPEs MUY ALTOS -> Se usaron datos buenos??   --> 0.03 es el mejor (o 0.01)
    """
    ERRORS (Test data):                       mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test
0 [9, 64, 64, 32, 1] 0.001 4.58 mins          [0.06823, 0.06341, 0.22167, 0.21295, 342.53465, 293.36657]
1 [9, 64, 64, 32, 1] 0.0001 5.42 mins         [0.10537, 0.10063, 0.28179, 0.27464, 401.01674, 344.42084]
2 [9, 64, 64, 32, 1] 0.0008 4.43 mins         [0.07726, 0.07257, 0.2392, 0.2317, 358.2586, 307.63269]
3 [9, 64, 64, 32, 1] 0.01 4.43 mins           [0.00206, 0.00191, 0.03901, 0.03764, 44.88268, 37.35677]
4 [9, 64, 64, 32, 1] 0.03 5.5 mins            [0.00089, 0.00089, 0.02551, 0.02579, 23.26977, 19.90166]    BUENO
5 [9, 64, 64, 32, 1] 0.005 5.61 mins          [0.00807, 0.00754, 0.07024, 0.06746, 121.74889, 102.28052]
6 [9, 64, 64, 64, 1] 0.001 7.89 mins          [0.06339, 0.05921, 0.21516, 0.20793, 328.89867, 281.77319]
7 [9, 64, 64, 64, 1] 0.0001 6.91 mins         [0.09668, 0.0904, 0.26613, 0.25628, 403.68313, 347.13428]
8 [9, 64, 64, 64, 1] 0.0008 7.99 mins         [0.05794, 0.05486, 0.20796, 0.20276, 310.09326, 265.9037]
9 [9, 64, 64, 64, 1] 0.01 6.94 mins           [0.00123, 0.00111, 0.03028, 0.02902, 37.61491, 31.13318]
10 [9, 64, 64, 64, 1] 0.03 7.39 mins          [0.0009, 0.00088, 0.02589, 0.02596, 24.41277, 20.82219]     BUENO
11 [9, 64, 64, 64, 1] 0.005 6.9 mins          [0.00705, 0.0063, 0.06327, 0.05929, 116.49113, 97.32221]
12 [9, 64, 64, 1] 0.001 4.65 mins             [0.06263, 0.05853, 0.214, 0.20701, 326.96392, 280.13595]
13 [9, 64, 64, 1] 0.0001 4.78 mins            [0.10855, 0.10239, 0.28873, 0.27826, 416.59694, 359.7833]
14 [9, 64, 64, 1] 0.0008 4.78 mins            [0.05818, 0.05411, 0.20617, 0.19801, 312.8121, 267.67062]
15 [9, 64, 64, 1] 0.01 4.75 mins              [0.00256, 0.00269, 0.04014, 0.03901, 60.21349, 49.90229]
16 [9, 64, 64, 1] 0.03 5.03 mins              [0.00153, 0.00148, 0.03438, 0.03406, 33.6356, 28.57743]    BUENO
17 [9, 64, 64, 1] 0.005 4.69 mins             [0.00896, 0.00803, 0.07384, 0.06949, 129.99985, 109.05127]
MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)
    """
    # 13 Xs, 500 epochs    --> 0.01 o 0.05 son los mejores
    """
    ERRORS (Test data):                       mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test
0 [13, 64, 32, 1] 0.01 1.18 mins        [0.0136, 0.03358, 0.10064, 0.09257, 184.08171, 15.07731, -0.37071]
1 [13, 64, 32, 1] 0.005 1.16 mins        [0.0307, 0.00667, 0.15432, 0.06274, 272.37435, 10.36963, 0.7278]   BUENO
2 [13, 64, 32, 1] 0.0001 1.16 mins        [0.12912, 0.02007, 0.3263, 0.12206, 548.82442, 23.28423, 0.18071]
3 [13, 64, 64, 32, 1] 0.01 2.1 mins     [0.00177, 0.0226, 0.034, 0.0609, 58.95277, 9.13786, 0.07763]        BUENO
4 [13, 64, 64, 32, 1] 0.005 2.24 mins     [0.01036, 0.03011, 0.08621, 0.08144, 162.46477, 12.75992, -0.22892]
5 [13, 64, 64, 32, 1] 0.0001 2.16 mins     [0.13666, 0.02386, 0.33799, 0.13271, 559.345, 29.31725, 0.02619]
6 [13, 64, 64, 64, 1] 0.01 2.79 mins     [0.00221, 0.00281, 0.04037, 0.03847, 66.88974, 7.27316, 0.88515]   BUENO
7 [13, 64, 64, 64, 1] 0.005 2.55 mins     [0.02177, 0.04627, 0.12973, 0.11862, 228.83435, 19.352, -0.88861]
8 [13, 64, 64, 64, 1] 0.0001 2.51 mins     [0.12498, 0.04961, 0.31877, 0.17956, 532.25265, 29.51857, -1.02497]
9 [13, 64, 64, 1] 0.01 1.66 mins        [0.00692, 0.03507, 0.0701, 0.08236, 131.71499, 12.0938, -0.43141]
10 [13, 64, 64, 1] 0.005 1.64 mins        [0.02216, 0.02629, 0.13148, 0.10045, 227.64759, 16.22933, -0.07309] MAL
11 [13, 64, 64, 1] 0.0001 1.63 mins        [0.12791, 0.02658, 0.32493, 0.14071, 546.66737, 26.87907, -0.08486]"""
    # 7 Xs, 500 epochs     --> 0.005 es el mejor
    """ERRORS (Test data) Epochs: 500                       mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test, r^2
0 [7, 64, 32, 1] 0.01 1.16 mins        [0.00914, 0.03058, 0.08098, 0.08157, 151.3374, 12.52069, -0.24845]
1 [7, 64, 32, 1] 0.005 1.15 mins        [0.039, 0.01779, 0.1755, 0.10453, 301.08935, 17.03243, 0.27399]     BIEN
2 [7, 64, 32, 1] 0.0001 1.16 mins        [0.13862, 0.02181, 0.33955, 0.13078, 565.7446, 26.97826, 0.10965]
3 [7, 64, 64, 32, 1] 0.01 1.98 mins     [0.00244, 0.0076, 0.04144, 0.04667, 75.1895, 7.58049, 0.68983]
4 [7, 64, 64, 32, 1] 0.005 1.93 mins     [0.01393, 0.00496, 0.10204, 0.04898, 187.21702, 7.51773, 0.79752]  BUENO
5 [7, 64, 64, 32, 1] 0.0001 2.0 mins     [0.17771, 0.08076, 0.40517, 0.27128, 595.2832, 56.88411, -2.29662]
6 [7, 64, 64, 64, 1] 0.01 2.51 mins     [0.00345, 0.02581, 0.04967, 0.07473, 88.55648, 11.20028, -0.05367]
7 [7, 64, 64, 64, 1] 0.005 2.55 mins     [0.02499, 0.00996, 0.13773, 0.074, 247.69645, 12.1802, 0.59327]     BUENO
8 [7, 64, 64, 64, 1] 0.0001 2.49 mins     [0.12997, 0.03856, 0.32455, 0.16026, 542.42412, 26.68377, -0.57395]
9 [7, 64, 64, 1] 0.01 1.68 mins        [0.00324, 0.02436, 0.04558, 0.06024, 90.6325, 8.82425, 0.00551]
10 [7, 64, 64, 1] 0.005 1.7 mins        [0.0279, 0.05181, 0.15005, 0.14144, 250.93373, 22.82858, -1.11485]
11 [7, 64, 64, 1] 0.0001 1.77 mins        [0.12831, 0.01982, 0.32506, 0.12446, 547.95514, 24.42679, 0.19104] REGULAR
"""

    # 11 Xs, 1000 epochs VERSION 2 --> 0.03 (o 0.01, pero es más lento)
    """ERRORS (Test data) Epochs: 1000        mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test, r^2 test
0 [11, 64, 32, 1] 0.007 2.05 mins        [0.00261, 0.05914, 0.04126, 0.1315, 8.99228, 16.07149, -4.07022]
1 [11, 64, 32, 1] 0.01 2.86 mins        [0.00324, 0.03008, 0.0448, 0.10063, 10.24092, 12.33238, -1.57896]
2 [11, 64, 32, 1] 0.03 3.63 mins        [0.00128, 0.00142, 0.02593, 0.02992, 5.56819, 3.799, 0.87787]        BUENO
3 [11, 64, 64, 32, 1] 0.007 4.12 mins     [0.00214, 0.05602, 0.03432, 0.12382, 7.40435, 15.05415, -3.80209]
4 [11, 64, 64, 32, 1] 0.01 3.74 mins     [0.00123, 0.02579, 0.0249, 0.09146, 5.55238, 11.22081, -1.21101]
5 [11, 64, 64, 32, 1] 0.03 5.6 mins     [0.00092, 0.00161, 0.02229, 0.03234, 4.54875, 4.09316, 0.86202]      BUENO
6 [11, 64, 64, 64, 1] 0.007 7.03 mins     [0.00381, 0.05372, 0.04886, 0.13385, 10.78391, 16.45269, -3.60541]
7 [11, 64, 64, 64, 1] 0.01 6.39 mins     [0.00136, 0.0217, 0.02615, 0.08511, 5.58666, 10.44936, -0.86032]
8 [11, 64, 64, 64, 1] 0.03 3.62 mins     [0.00089, 0.00118, 0.02067, 0.02579, 4.20549, 3.28632, 0.89873]     BUENO
9 [11, 64, 64, 1] 0.007 4.5 mins        [0.00475, 0.00535, 0.05498, 0.04981, 13.18385, 6.19738, 0.54116]
10 [11, 64, 64, 1] 0.01 4.52 mins        [0.00254, 0.00152, 0.03842, 0.03088, 8.99813, 3.87082, 0.8694]  !!  BUENO
11 [11, 64, 64, 1] 0.03 4.57 mins        [0.00135, 0.02397, 0.02656, 0.08673, 5.43681, 10.69681, -1.05473]
MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)"""
    # 11 Xs 1000 epochs VERSION 2 --> 0.03 (O 0.08)
    """ERRORS (Test data) Epochs: 1000        mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test, r^2 train, r^2 test
0 [11, 8, 8, 1] 0.08 0.48 mins        [0.00144, 0.0034, 0.02785, 0.04385, 5.78289, 5.5314, 0.96696, 0.70879]
1 [11, 8, 8, 1] 0.01 0.46 mins        [0.00196, 0.0225, 0.0315, 0.08267, 6.95682, 10.1039, 0.9548, -0.92888]
2 [11, 8, 8, 1] 0.03 0.44 mins        [0.00136, 0.00304, 0.02637, 0.04095, 5.53608, 5.19172, 0.96869, 0.73897]    BIEN
3 [11, 16, 8, 1] 0.08 0.64 mins        [0.00075, 0.00447, 0.02043, 0.04305, 4.20015, 5.38749, 0.98263, 0.61696]   BIEN
4 [11, 16, 8, 1] 0.01 0.62 mins        [0.01829, 0.01497, 0.11652, 0.10472, 25.64948, 12.56432, 0.57911, -0.28344]
5 [11, 16, 8, 1] 0.03 0.61 mins        [0.00206, 0.03977, 0.03356, 0.11579, 6.7373, 14.34364, 0.95253, -2.40926]
6 [11, 64, 32, 1] 0.08 2.41 mins        [0.00088, 0.02484, 0.02188, 0.08404, 4.39369, 10.28465, 0.97966, -1.12984]
7 [11, 64, 32, 1] 0.01 2.66 mins        [0.0049, 0.01983, 0.05848, 0.09063, 13.12475, 11.04969, 0.88725, -0.70004]
8 [11, 64, 32, 1] 0.03 1.38 mins        [0.00134, 0.00405, 0.02668, 0.04743, 5.52254, 5.98115, 0.96906, 0.65251]  BIEN
9 [11, 32, 16, 1] 0.08 0.68 mins        [0.00087, 0.02113, 0.02111, 0.08306, 4.31741, 10.24442, 0.98003, -0.81108]
10 [11, 32, 16, 1] 0.01 0.67 mins        [0.00188, 0.00465, 0.02964, 0.04295, 7.03696, 5.41909, 0.95684, 0.60164]
11 [11, 32, 16, 1] 0.03 0.68 mins        [0.00128, 0.00279, 0.02605, 0.03746, 5.34946, 4.76896, 0.97047, 0.76118] BIEN
12 [11, 64, 64, 1] 0.08 2.57 mins        [0.00063, 0.0034, 0.01872, 0.03783, 3.77296, 4.7101, 0.98548, 0.70838]   BIEN
13 [11, 64, 64, 1] 0.01 1.83 mins        [0.00404, 0.01473, 0.05166, 0.07219, 12.29651, 8.77883, 0.90694, -0.26232]
14 [11, 64, 64, 1] 0.03 1.84 mins        [0.00118, 0.02368, 0.02481, 0.08928, 5.16954, 10.92443, 0.97282, -1.02989]"""
    # 18 Xs 1000 epochs VERSION 2 -->
    """ERRORS (Test data) Epochs: 1000        mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test, r^2 train, r^2 test
0 [18, 8, 8, 1] 0.008 0.23 mins        [0.01436, 0.01312, 0.10018, 0.09631, 21.67375, 11.69411, 0.66963, -0.12453]
1 [18, 8, 8, 1] 0.01 0.23 mins        [0.01464, 0.01081, 0.10295, 0.08549, 23.10827, 10.32574, 0.66304, 0.07343]
2 [18, 8, 8, 1] 0.03 0.23 mins        [0.00244, 0.00471, 0.03494, 0.05289, 6.77517, 6.85206, 0.94386, 0.59653]
3 [18, 16, 8, 1] 0.008 0.34 mins        [0.01703, 0.01152, 0.11268, 0.08854, 25.11175, 10.76934, 0.60818, 0.01255]
4 [18, 16, 8, 1] 0.01 0.56 mins        [0.01635, 0.01081, 0.1087, 0.08124, 24.3822, 9.8179, 0.62386, 0.07339]
5 [18, 16, 8, 1] 0.03 0.59 mins        [0.00208, 0.00547, 0.03335, 0.0541, 6.90476, 6.97026, 0.95205, 0.53127]
6 [18, 64, 32, 1] 0.008 2.57 mins        [0.00411, 0.00996, 0.05091, 0.06501, 12.15028, 8.08719, 0.9054, 0.14657]
7 [18, 64, 32, 1] 0.01 2.52 mins        [0.00181, 0.02063, 0.03317, 0.07905, 7.62805, 9.68049, 0.95832, -0.76885]
8 [18, 64, 32, 1] 0.03 2.59 mins        [0.00127, 0.03061, 0.02584, 0.09829, 5.25913, 12.08372, 0.97074, -1.62451]
9 [18, 32, 16, 1] 0.008 1.25 mins        [0.00365, 0.0047, 0.04804, 0.04412, 11.47568, 5.33349, 0.91606, 0.5969]
10 [18, 32, 16, 1] 0.01 1.36 mins        [0.01049, 0.00691, 0.08601, 0.06602, 19.35459, 8.05743, 0.75859, 0.40797]
11 [18, 32, 16, 1] 0.03 1.29 mins        [0.00149, 0.00317, 0.02814, 0.04422, 5.67762, 5.621, 0.96581, 0.72805]
12 [18, 64, 64, 1] 0.008 92.22 mins        [0.00573, 0.03151, 0.06232, 0.10604, 14.35234, 12.872, 0.86803, -1.70113]
13 [18, 64, 64, 1] 0.01 4.74 mins        [0.00234, 0.00773, 0.03663, 0.06294, 7.91183, 7.8075, 0.94605, 0.33707]
14 [18, 64, 64, 1] 0.03 4.78 mins        [0.00114, 0.00361, 0.02395, 0.04124, 4.8698, 5.18769, 0.97368, 0.69039]"""
    data_num = X_train.shape[1]
    print(data_num, X_train.shape)
    # Training all models, one by one
    modelCount = 0
    for i in range(len(layers_arr)):
        for lr in learning_rate:
            model = NeuralNetwork(layers_arr[i], data_num, lr)
            print(f"\n========== MODEL {modelCount + 1}/{len(learning_rate)*len(layers_arr)} ==========")
            modelCount += 1
            print(
                f"TRAINING: {training_steps} steps, learning rate = {lr}, layers = {layers_arr[i]}"
            )

            # --- Training the model ---
            t0 = time.time()
            model.train(
                X_train_norm,
                Y_train_norm,
                X_test_norm,
                Y_test_norm,
                X_2025_norm,
                Y_2025_norm,
                norm_price,
                training_steps,
                printErrors=2,
                showGraph=False
            )

            print(f"           - - - FINAL TEST: MODEL #{modelCount} - - -")
            print(
                f"TRAINING: {training_steps} steps, learning rate = {lr}, layers = {layers_arr[i]}"
            )
            errors = model.test(
                X_train_norm, Y_train_norm, X_test_norm, Y_test_norm, X_2025_norm, Y_2025_norm, norm_price, showGraph=False
            )
            errors = [round(float(err), 5) for err in errors]
            t_f = time.time()
            runningTime = round((t_f - t0) / 60, 2)
            print(f"Training took {runningTime} minutes!")
            models_arr.append({"model": model, "errors": errors, "t": runningTime, "lr": lr})

    print("=" * 15, "END", "=" * 15)

    # Prints all models
    print(
        f"\nERRORS (Test data) Epochs: {training_steps}{" " * 8}mse_norm_train, mse_norm_test, mae_norm_train, mae_norm_test, mape_train, mape_test, r^2 train, r^2 test, acc_train, acc_test, acc_2025"
    )
    for i in range(len(models_arr)):
        layers = models_arr[i]["model"].layers
        formatting = " " * 3 * int(6 - len(layers))
        print(i, layers, models_arr[i]["lr"], f"{models_arr[i]["t"]} mins", formatting, models_arr[i]["errors"])
    # --- Option to save the model ---
    print("MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)")
    index = int(input("Choose a model to save and/or train: "))
    save = input(f"\nDo you want to save the model {index}? (Y/n) ")
    if save.lower() == "y":
        name = input("Write the model name (without the extension): ")
        models_arr[index]["model"].saveModel(name, norm_price)

    # Option to make a second training process ---
    double_train = input(
        f"\nWrite the new [low] learning rate used ({models_arr[index]["model"].lr}) or 'n': "
    )
    if double_train != "n":
        models_arr[index]["model"].lr = float(double_train)
        new_steps = int(input("Write the number of training steps [high]: "))
        print(models_arr[index])
        t0 = time.time()
        models_arr[index]["model"].train(
            X_train_norm,
            Y_train_norm,
            X_test_norm,
            Y_test_norm,
            X_2025_norm,
            Y_2025_norm,
            norm_price,
            new_steps,
            prevStepsCount=training_steps,
            showGraph=False
        )
        t_f = time.time()
        print(f"Training took {np.round((t_f - t0) / 60, 2)} minutes!")

        print("\nTEST WITH 2025 DATA:")
        models_arr[index]["model"].testRealData(X_2025_norm, Y_2025_norm, norm_price)

    # --- Option to save the new model ---
    print("MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)")
    save = input("\nDo you want to save the NEW model: (Y/n) ")
    if save.lower() == "y":
        name = input("Write the model name (without the extension): ")
        models_arr[index]["model"].saveModel(name, norm_price)


def trainAndTestModel():
    model_name = "model_v3.3.txt"       # 56%
    model_name = "model_v3b.5_18.txt"   # 60%   [18, 64, 64, 64, 1] Lr: 0.05
    # model_name = "model_v4.3_18.txt"    # 54%
    # model_name = "model_v5.1b_11.txt"   # 40%

    user_input = input(f"Do you want to load {model_name}? (Y/n) ").lower()
    # Whether to create a new model or test a saved one
    if user_input == "n":
        # --- TRAIN NEW MODEL ---
        # --- Loading and parsing data ---
        # print("-- Loading and parsing data --")
        X_train, Y_train, X_test, Y_test = utils.loadData(DATA_SPLIT)

        # --- Normalizing train data ---
        # Returning the min and max prices to reverse normalisation in MAPE
        X_train_norm, Y_train_norm, norm_price = utils.normalizeTrainData(
            X_train, Y_train
        )
        X_test_norm, Y_test_norm = utils.normalizeTestData(X_test, Y_test, norm_price)

        # --- Loading train data (2025 prices) ---
        X_2025, Y_2025 = utils.loadData()
        X_2025_norm, Y_2025_norm = utils.normalizeTestData(X_2025, Y_2025, norm_price)

        # --- Creating the model ---
        layers = [X_train.shape[0], 64, 64, 32, 1]
        # layers = [X_train.shape[0], 64, 32, 1]
        # layers = [X_train.shape[0], 32, 16, 1]

        data_num = X_train.shape[1]
        model = NeuralNetwork(layers, data_num, learning_rate)
        print(
            f"------\nTRAINING: {training_steps} steps, learning rate = {learning_rate}, layers = {layers}\n------"
        )
        # --- Training the model & testing with 2025 data ---
        t0 = time.time()
        model.train(
            X_train_norm,
            Y_train_norm,
            X_test_norm,
            Y_test_norm,
            X_2025_norm,
            Y_2025_norm,
            norm_price,
            training_steps,
        )
        t_f = time.time()
        print(f"Training took {np.round((t_f - t0) / 60, 2)} minutes!")
        print("=" * 15, "END", "=" * 15)

        pred_train = model.feedForward(X_train)
        pred_test = model.feedForward(X_test)
        pred_2025 = model.feedForward(X_2025)
        getPredError(X_train, Y_train, pred_train, name="\n[Train]")
        getPredError(X_test, Y_test, pred_test, name="[Test]")
        getPredError(X_2025, Y_2025, pred_2025, name="[2025]")

        # print("\n=== Tamaños de datasets ===")
        # print("Train samples:", X_train.shape)
        # print("Test samples:", X_test.shape)
        # print("2025 samples:", X_2025.shape)

        # print("\n=== Rangos de precios ===")
        # print("Train - min: ${:.2f}, max: ${:.2f}".format(Y_train.min(), Y_train.max()))
        # print("Test - min: ${:.2f}, max: ${:.2f}".format(Y_test.min(), Y_test.max()))
        # print("2025 - min: ${:.2f}, max: ${:.2f}".format(Y_2025.min(), Y_2025.max()))

        # predictions_2025 = model.feedForward(X_2025_norm)

        # errors = np.abs(Y_2025_norm - predictions_2025)

        # print("\n=== Distribución de errores 2025 ===")
        # print("Error medio:", errors.mean())
        # print("Error mediano:", np.median(errors))
        # print("Error máximo:", errors.max())
        # print("% muestras con error < 0.05:", ((errors < 0.05).sum() / len(errors)) * 100)

        # # Volatilidad relativa (coeficiente de variación)
        # cv_train = np.std(Y_train) / np.mean(Y_train)
        # cv_test = np.std(Y_test) / np.mean(Y_test)
        # cv_2025 = np.std(Y_2025) / np.mean(Y_2025)

        # print("\n=== Volatilidad relativa ===")
        # print(f"Train CV: {cv_train:.4f}")
        # print(f"Test CV:  {cv_test:.4f}")
        # print(f"2025 CV:  {cv_2025:.4f}")

        # Si test tiene menor CV → más "aburrido" para el modelo
        # =====================================================================================

        # --- Predicting new data at the end ---
        print("\nTEST WITH 2025 DATA:")
        model.testRealData(X_2025_norm, Y_2025_norm, norm_price)
        # Plotting data
        print("--- PLOTTING 2025 DATA ---")
        plotPriceGraph(model, X_2025_norm, Y_2025_norm, Y_2025, norm_price, name="2025", X_real=X_2025)

        # --- Option to save the model ---
        print("MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)")

        return
        save = input("\nDo you want to save the model: (Y/n) ")
        if save.lower() == "y":
            name = input("Write the model name (without the extension): ")
            model.saveModel(name, norm_price)

        # Option to make a second training process ---
        double_train = input(
            f"\nWrite the new [low] learning rate used ({model.lr}) or 'n': "
        )
        if double_train != "n":
            model.lr = float(double_train)
            new_steps = int(input("Write the number of training steps [high]: "))
            print(model)
            t0 = time.time()
            # global graph
            # graph.resetGraph()
            model.train(
                X_train_norm,
                Y_train_norm,
                X_test_norm,
                Y_test_norm,
                X_2025_norm,
                Y_2025_norm,
                norm_price,
                new_steps,
                prevStepsCount=training_steps,
                showGraph=True
            )
            t_f = time.time()
            print(f"Training took {np.round((t_f - t0) / 60, 2)} minutes!")

            print("\n Predictions and errors:")
            pred_train = model.feedForward(X_train)
            pred_test = model.feedForward(X_test)
            pred_2025 = model.feedForward(X_2025)
            getPredError(X_train, Y_train, pred_train, name="\n[Train]")
            getPredError(X_test, Y_test, pred_test, name="[Test]")
            getPredError(X_2025, Y_2025, pred_2025, name="[2025]")

            print("\nTEST WITH 2025 DATA:")
            model.testRealData(X_2025_norm, Y_2025_norm, norm_price)

        # --- Option to save the new model ---
        print("MSE < 0.01        MAE < 0.03       MAPE < 10%    (1-5%; 85$)")
        # Plotting the predictions
        print("--- PLOTTING 2025 DATA ---")
        plotPriceGraph(model, X_2025_norm, Y_2025_norm, Y_2025, norm_price, name="2025", X_real=X_2025)

        save = input("\nDo you want to save the NEW model: (Y/n) ")
        if save.lower() == "y":
            name = input("Write the model name (without the extension): ")
            model.saveModel(name, norm_price)
    else:
        # --- LOADING A SAVED MODEL ---
        # --- Loading data ---
        # Model loaded from the text file (Weights, biases, layers, learning rate...)
        loaded_params = utils.loadModel("models/" + model_name)
        print("Params:", loaded_params.keys(), loaded_params["layers"])
        print("B\n", loaded_params["B"][0][:5])

        # --- Initializing data and replacing by loaded data
        model = NeuralNetwork(loaded_params["layers"], loaded_params["num"])
        model.loadWsAndBs(loaded_params["W"], loaded_params["B"])
        print("Printing loaded model:\n", model)

        # --- Predicting real data ---
        # Loading and normalizing 2025 data
        X_2025, Y_2025 = utils.loadData(num_features=loaded_params["layers"][0])
        X_2025_norm, Y_2025_norm = utils.normalizeTestData(
            X_2025, Y_2025, loaded_params["norm_price"]
        )
        # Predictions
        print("\nPREDICTIONS WITH 2025 DATA:")
        print(
            f"\nloaded_params {loaded_params.keys()}\nLoaded[norm_price]: {loaded_params["norm_price"]}\n"
        )
        model.testRealData(X_2025_norm, Y_2025_norm, loaded_params["norm_price"])

        # --- Predict future prices (last month of 2025) ---
        X_norm = X_2025_norm # Xs to predict from
        realPrices_norm = Y_2025_norm.T # Ys to calculate the error
        realPrices = Y_2025 # Ys to plot on the graph
        print(X_norm.shape, realPrices_norm.shape)
        print("--- PLOTTING 2025 DATA ---")
        plotPriceGraph(model, X_norm, realPrices_norm, realPrices, loaded_params["norm_price"], block=True, name="2025", X_real=X_2025)


if __name__ == "__main__":
    main()