Update app.py

app.py

@@ -27,11 +27,9 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 #------------------------------------------GRUModel-------------------------------------
 
+
 def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64, learning_rate=0.0001, 
-             l1_reg=0.001, l2_reg=0.001, dropout_rate=0.2, feature_selection=True, top_k=10):
-    
-    
-    
+             l1_reg=0.001, l2_reg=0.001, dropout_rate=0.2):
 
     # Scale the input data
     scaler = MinMaxScaler()
@@ -42,22 +40,17 @@ def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64,
     target_scaler = MinMaxScaler()
     trainy_scaled = target_scaler.fit_transform(trainy.reshape(-1, 1))
 
-    # Reshape inputs to (samples, timesteps, features)
-    trainX = trainX_scaled.reshape((trainX.shape[0], 1, trainX.shape[1]))
-    if testX is not None:
-        testX = testX_scaled.reshape((testX.shape[0], 1, testX.shape[1]))
-
     # Model definition
     model = Sequential()
-    model.add(GRU(512, input_shape=(trainX.shape[1], trainX.shape[2]), return_sequences=False, 
-                  kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
-    
-    
-    model.add(Dense(512, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+
+    # Input Layer
+    model.add(Dense(512, input_shape=(trainX.shape[1],), kernel_initializer='he_normal',
+                    kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
     model.add(BatchNormalization())
     model.add(Dropout(dropout_rate))
     model.add(LeakyReLU(alpha=0.1))
 
+    # Hidden Layers
     model.add(Dense(256, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
     model.add(BatchNormalization())
     model.add(Dropout(dropout_rate))
@@ -77,9 +70,11 @@ def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64,
     model.add(BatchNormalization())
     model.add(Dropout(dropout_rate))
     model.add(LeakyReLU(alpha=0.1))
-    
-    model.add(Dense(1, activation="relu"))  # Output layer
 
+    # Output Layer
+    model.add(Dense(1, activation="relu"))  
+
+    # Compile Model
     model.compile(loss='mse', optimizer=Adam(learning_rate=learning_rate), metrics=['mse'])
 
     # Callbacks
@@ -89,11 +84,12 @@ def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64,
     ]
 
     # Train model
-    history = model.fit(trainX, trainy_scaled, epochs=epochs, batch_size=batch_size, validation_split=0.1, verbose=1, callbacks=callbacks)
+    history = model.fit(trainX_scaled, trainy_scaled, epochs=epochs, batch_size=batch_size, validation_split=0.1, 
+                        verbose=1, callbacks=callbacks)
 
     # Predictions
-    predicted_train = model.predict(trainX).flatten()
-    predicted_test = model.predict(testX).flatten() if testX is not None else None
+    predicted_train = model.predict(trainX_scaled).flatten()
+    predicted_test = model.predict(testX_scaled).flatten() if testX is not None else None
 
     # Inverse transform predictions
     predicted_train = target_scaler.inverse_transform(predicted_train.reshape(-1, 1)).flatten()
@@ -102,6 +98,81 @@ def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64,
 
     return predicted_train, predicted_test, history
 
+#def GRUModel(trainX, trainy, testX=None, testy=None, epochs=1000, batch_size=64, learning_rate=0.0001, 
+            # l1_reg=0.001, l2_reg=0.001, dropout_rate=0.2, feature_selection=True, top_k=10):
+    
+    
+    
+
+    # Scale the input data
+   # scaler = MinMaxScaler()
+   #trainX_scaled = scaler.fit_transform(trainX)
+   # testX_scaled = scaler.transform(testX) if testX is not None else None
+
+    # Scale the target variable
+    #target_scaler = MinMaxScaler()
+    #trainy_scaled = target_scaler.fit_transform(trainy.reshape(-1, 1))
+
+    # Reshape inputs to (samples, timesteps, features)
+    #trainX = trainX_scaled.reshape((trainX.shape[0], 1, trainX.shape[1]))
+    #if testX is not None:
+       # testX = testX_scaled.reshape((testX.shape[0], 1, testX.shape[1]))
+
+    # Model definition
+    #model = Sequential()
+    #model.add(GRU(512, input_shape=(trainX.shape[1], trainX.shape[2]), return_sequences=False, 
+                  #kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    
+    
+    #model.add(Dense(512, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    #model.add(BatchNormalization())
+    #model.add(Dropout(dropout_rate))
+    #model.add(LeakyReLU(alpha=0.1))
+
+    #model.add(Dense(256, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    #model.add(BatchNormalization())
+    #model.add(Dropout(dropout_rate))
+    #model.add(LeakyReLU(alpha=0.1))
+
+    #model.add(Dense(128, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    #model.add(BatchNormalization())
+    #model.add(Dropout(dropout_rate))
+    #model.add(LeakyReLU(alpha=0.1))
+
+    #model.add(Dense(64, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    #model.add(BatchNormalization())
+    #model.add(Dropout(dropout_rate))
+    #model.add(LeakyReLU(alpha=0.1))
+
+    #model.add(Dense(32, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    #model.add(BatchNormalization())
+    #model.add(Dropout(dropout_rate))
+    #model.add(LeakyReLU(alpha=0.1))
+    
+    #model.add(Dense(1, activation="relu"))  # Output layer
+
+    #model.compile(loss='mse', optimizer=Adam(learning_rate=learning_rate), metrics=['mse'])
+
+    # Callbacks
+    #callbacks = [
+      #  ReduceLROnPlateau(monitor='val_loss', patience=10, verbose=1, factor=0.5, min_lr=1e-6),
+     #   EarlyStopping(monitor='val_loss', verbose=1, restore_best_weights=True, patience=10)
+    #]
+
+    # Train model
+    #history = model.fit(trainX, trainy_scaled, epochs=epochs, batch_size=batch_size, validation_split=0.1, verbose=1, callbacks=callbacks)
+
+    # Predictions
+    #predicted_train = model.predict(trainX).flatten()
+   # predicted_test = model.predict(testX).flatten() if testX is not None else None
+
+    # Inverse transform predictions
+  #  predicted_train = target_scaler.inverse_transform(predicted_train.reshape(-1, 1)).flatten()
+ #   if predicted_test is not None:
+#        predicted_test = target_scaler.inverse_transform(predicted_test.reshape(-1, 1)).flatten()
+
+    #return predicted_train, predicted_test, history
+