Update app.py

app.py

@@ -1,31 +1,10 @@
-# -*- coding: utf-8 -*-
 """
-Created on Tue Jan 28 09:12:48 2025
-
-@author: Ashmitha
-"""
-
-# -*- coding: utf-8 -*-
-"""
-Created on Sun Nov 24 12:47:37 2024
-
-@author: Ashmitha
-"""
-
-# -*- coding: utf-8 -*-
-"""
-Created on Sun Nov 24 12:25:57 2024
-
-@author: Ashmitha
-"""
-
-# -*- coding: utf-8 -*-
-"""
-Created on Sat Nov  9 15:44:40 2024
+Created on Tue Jan 28 13:43:25 2025
 
 @author: Ashmitha
 """
 
+#---------------------------------------------Libraries--------------------------
 import pandas as pd
 import numpy as np
 import gradio as gr
@@ -48,57 +27,40 @@ from xgboost import XGBRegressor
 import io
 from sklearn.feature_selection import SelectFromModel
 import tempfile
-
-#-------------------------------------Feature selection---------------------------------------------------------------------------------------------
-
-def RandomForestFeatureSelection(trainX, trainy, num_features=60):
-    rf = RandomForestRegressor(n_estimators=1000, random_state=50)
-    rf.fit(trainX, trainy)
-    
-    # Get feature importances
-    importances = rf.feature_importances_
-    
-    # Select the top N important features
-    indices = np.argsort(importances)[-num_features:]
-    return indices 
-#----------------------------------------------------------GRU Model---------------------------------------------------------------------
-
-
-def GRUModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_rate=0.0001, l1_reg=0.001, l2_reg=0.001, dropout_rate=0.2, feature_selection=True):
-    
-    # Apply feature selection using Random Forest Regressor
-    if feature_selection:
-        # Use RandomForestRegressor to rank features by importance
-        rf = RandomForestRegressor(n_estimators=100, random_state=42)
-        rf.fit(trainX, trainy)
-        
-        # Select features with importance greater than a threshold (e.g., mean importance)
-        selector = SelectFromModel(rf, threshold="mean", prefit=True)
-        trainX = selector.transform(trainX)
-        if testX is not None:
-            testX = selector.transform(testX)
-        print(f"Selected {trainX.shape[1]} features based on feature importance.")
-    
-    # Scale the input data using MinMaxScaler to normalize the feature range
-    scaler = MinMaxScaler()
-    trainX_scaled = scaler.fit_transform(trainX)
-    if testX is not None:
-        testX_scaled = scaler.transform(testX)
-    
-    # Scale the target variable using MinMaxScaler
-    target_scaler = MinMaxScaler()
-    trainy_scaled = target_scaler.fit_transform(trainy.reshape(-1, 1))  # Reshape to 2D for scaler
-
+#------------------------------------------GRUModel-------------------------------------
+def GRUModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_rate=0.0001, l1_reg=0.001, l2_reg=0.001, dropout_rate=0.2):
+    """
+    GRU Model for regression tasks.
+
+    Args:
+        trainX (np.array): Training features of shape (samples, features).
+        trainy (np.array): Training target values of shape (samples,).
+        testX (np.array): Testing features of shape (samples, features).
+        testy (np.array): Testing target values of shape (samples,).
+        epochs (int): Number of epochs for training.
+        batch_size (int): Batch size for training.
+        learning_rate (float): Learning rate for the optimizer.
+        l1_reg (float): L1 regularization parameter.
+        l2_reg (float): L2 regularization parameter.
+        dropout_rate (float): Dropout rate for regularization.
+
+    Returns:
+        predicted_train (np.array): Predicted values for the training set.
+        predicted_test (np.array): Predicted values for the testing set.
+        history: Training history.
+    """
     # Reshape trainX and testX to be 3D: (samples, timesteps, features)
-    trainX = trainX_scaled.reshape((trainX.shape[0], 1, trainX.shape[1]))  # Adjusted for general feature count
+    trainX = trainX.reshape((trainX.shape[0], 1, trainX.shape[1]))  # Adjusted for general feature count
     if testX is not None:
-        testX = testX_scaled.reshape((testX.shape[0], 1, testX.shape[1]))  # Reshape testX if it exists
-    
+        testX = testX.reshape((testX.shape[0], 1, testX.shape[1]))  # Reshape testX if it exists
+
+    # Define the GRU model
     model = Sequential()
-    
+
     # GRU Layer
-    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(GRU(512, input_shape=(trainX.shape[1], trainX.shape[2]), return_sequences=False, 
+                  kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+
     # Dense Layers with Batch Normalization, Dropout, LeakyReLU
     model.add(Dense(256, kernel_initializer='he_normal', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
     model.add(BatchNormalization())
@@ -109,31 +71,31 @@ def GRUModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_
     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))
-    
+
     # Output Layer with ReLU activation to prevent negative predictions
     model.add(Dense(1, activation="relu"))
-    
+
     # Compile the model
     model.compile(loss='mse', optimizer=Adam(learning_rate=learning_rate), metrics=['mse'])
-    
+
     # Callbacks for learning rate reduction and early stopping
     learning_rate_reduction = ReduceLROnPlateau(monitor='val_loss', patience=10, verbose=1, factor=0.5, min_lr=1e-6)
     early_stopping = EarlyStopping(monitor='val_loss', verbose=1, restore_best_weights=True, patience=10)
-    
+
     # Train the model
-    history = model.fit(trainX, trainy_scaled, epochs=epochs, batch_size=batch_size, validation_split=0.1, verbose=1, 
+    history = model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, validation_split=0.1, verbose=1, 
                         callbacks=[learning_rate_reduction, early_stopping])
-    
+
     # Predict train and test
     predicted_train = model.predict(trainX)
     predicted_test = model.predict(testX) if testX is not None else None
@@ -142,30 +104,11 @@ def GRUModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_
     predicted_train = predicted_train.flatten()
     if predicted_test is not None:
         predicted_test = predicted_test.flatten()
-    else:
-        predicted_test = np.zeros_like(predicted_train)
-
-    # Inverse scale the predictions to get them back to original range
-    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
 
-
-
-
-#-----------------------------------------------------------DeepMap-------------------------------------------------------------------------------
+#--------------------------------------------------CNNModel-------------------------------------------
 def CNNModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_rate=0.0001, l1_reg=0.0001, l2_reg=0.0001, dropout_rate=0.3,feature_selection=True):
-    if feature_selection:
-        rf=RandomForestRegressor(n_estimators=100,random_state=60)
-        rf.fit(trainX,trainy)
-        
-        selector=SelectFromModel(rf, threshold="mean",prefit=True)
-        trainX=selector.transform(trainX)
-        if testX is not None:
-            testX=selector.transform(testX)
-        print(f"Selected {trainX.shape[1]} feature based on the important feature")
     
    
     
@@ -183,10 +126,14 @@ def CNNModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_
     model = Sequential()
     
     # Convolutional layers
-    model.add(Conv1D(256, kernel_size=3, activation='relu', input_shape=(trainX.shape[1], 1), kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    model.add(Conv1D(512, kernel_size=3, activation='relu', input_shape=(trainX.shape[1], 1), kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
     model.add(MaxPooling1D(pool_size=2))
     model.add(Dropout(dropout_rate))
     
+    model.add(Conv1D(256, kernel_size=3, activation='relu', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
+    model.add(MaxPooling1D(pool_size=2))
+    model.add(Dropout(dropout_rate))
+
     model.add(Conv1D(128, kernel_size=3, activation='relu', kernel_regularizer=regularizers.l1_l2(l1=l1_reg, l2=l2_reg)))
     model.add(MaxPooling1D(pool_size=2))
     model.add(Dropout(dropout_rate))
@@ -214,18 +161,9 @@ def CNNModel(trainX, trainy, testX, testy, epochs=1000, batch_size=64, learning_
     predicted_test = model.predict(testX).flatten() if testX is not None else None
     
     return predicted_train, predicted_test, history
-
-#-------------------------------------------------------------------------Random Forest----------------------------------------------------
+#------------------------------------------RFModel---------------------------------------------------
 def RFModel(trainX, trainy, testX, testy, n_estimators=100, max_depth=None,feature_selection=True):
-    if feature_selection:
-        rf=RandomForestRegressor(n_estimators=100, random_state=60)
-        rf.fit(trainX, trainy)
-        selector=SelectFromModel(rf, threshold="mean", prefit=True)
-        trainX=selector.transform(trainX)
-        if testX is not None:
-            testX=selector.transform(testX)
-        print(f"Selected {trainX.shape[1]} feature based on the feature selection")
-        
+    
     
     # Log transformation of the target variable
    
@@ -245,39 +183,25 @@ def RFModel(trainX, trainy, testX, testy, n_estimators=100, max_depth=None,featu
     predicted_test = rf_model.predict(testX_scaled) if testX is not None else None
     
     return predicted_train, predicted_test,history
-#------------------------------------------------------------------------------XGboost---------------------------------------------------------------
+#-------------------------------------------------XGBoost--------------------------------------------
 def XGBoostModel(trainX, trainy, testX, testy,learning_rate,min_child_weight,feature_selection=True, n_estimators=100, max_depth=None):
-    if feature_selection:
-        rf=RandomForestRegressor(n_estimators=100,random_state=60)
-        rf.fit(trainX,trainy)
-        selector=SelectFromModel(rf,threshold="mean",prefit=True)
-        trainX=selector.transform(trainX)
-        if testX is not None:
-            testX=selector.transform(testX)
-        print(f"Selected {trainX.shape[1]} features based on feature importance")
-        
     
-    #trainy_log = np.log1p(trainy)  # Log-transform to handle large phenotypic values
-    #if testy is not None:
-       # testy_log = np.log1p(testy)
-
+    
+    
     # Scale the features
     scaler = MinMaxScaler()
     trainX_scaled = scaler.fit_transform(trainX)
     if testX is not None:
         testX_scaled = scaler.transform(testX)
 
-    # Define and train the XGBoost model
-   # xgb_model = XGBRegressor(n_estimators=n_estimators, max_depth=100, random_state=42)
-    #xgb_model = XGBRegressor(objective ='reg:linear', 
-               #   n_estimators = 100, seed = 100) 
-    xgb_model=XGBRegressor(objective="reg:squarederror",random_state=60)
+    
+    xgb_model=XGBRegressor(objective="reg:squarederror",random_state=42)
     history=xgb_model.fit(trainX, trainy)
     param_grid={
         "learning_rate":0.01,
         "max_depth" : 10,
          "n_estimators": 100,
-         "min_child_weight": 5
+         "min_child_weight": 10
         }
     
 
@@ -287,19 +211,7 @@ def XGBoostModel(trainX, trainy, testX, testy,learning_rate,min_child_weight,fea
     
 
     return predicted_train, predicted_test,history
-
-
-
-
-
-
-#----------------------------------------reading file----------------------------------------------------------------------------------------
-
-
-
-
-
-# Helper function to read the uploaded CSV file
+#------------------------------------------------------------------File--------------------------------------------
 def read_csv_file(uploaded_file):
     if uploaded_file is not None:
         if hasattr(uploaded_file, 'data'):  # For NamedBytes
@@ -307,37 +219,34 @@ def read_csv_file(uploaded_file):
         elif hasattr(uploaded_file, 'name'):  # For NamedString
             return pd.read_csv(uploaded_file.name)
     return None
+#------------------------------------------------------------Calculating TOPSIS score---------------------------
+def calculate_topsis_score(df):
+    # Normalize the data
+    norm_df = (df.iloc[:, 1:] - df.iloc[:, 1:].min()) / (df.iloc[:, 1:].max() - df.iloc[:, 1:].min())
 
+    # Calculate the positive and negative ideal solutions
+    ideal_positive = norm_df.max(axis=0)
+    ideal_negative = norm_df.min(axis=0)
 
+    # Calculate the Euclidean distances
+    dist_positive = np.sqrt(((norm_df - ideal_positive) ** 2).sum(axis=1))
+    dist_negative = np.sqrt(((norm_df - ideal_negative) ** 2).sum(axis=1))
 
+    # Calculate the TOPSIS score
+    topsis_score = dist_negative / (dist_positive + dist_negative)
 
-#--------------------------------------------------- Nested Cross validation---------------------------------------------------------------------------
+    # Add the TOPSIS score to the dataframe
+    df['TOPSIS_Score'] = topsis_score
 
+    return df
+#_-------------------------------------------------------------NestedKFold Cross Validation---------------------
 def NestedKFoldCrossValidation(training_data, training_additive, testing_data, testing_additive, 
                                 training_dominance, testing_dominance, epochs, learning_rate, min_child_weight, batch_size=64,
                                 outer_n_splits=2, output_file='cross_validation_results.csv',
                                 predicted_phenotype_file='predicted_phenotype.csv', feature_selection=True):
     
     # Define calculate_topsis_score before using it
-    def calculate_topsis_score(df):
-        # Normalize the data
-        norm_df = (df.iloc[:, 1:] - df.iloc[:, 1:].min()) / (df.iloc[:, 1:].max() - df.iloc[:, 1:].min())
-
-        # Calculate the positive and negative ideal solutions
-        ideal_positive = norm_df.max(axis=0)
-        ideal_negative = norm_df.min(axis=0)
-
-        # Calculate the Euclidean distances
-        dist_positive = np.sqrt(((norm_df - ideal_positive) ** 2).sum(axis=1))
-        dist_negative = np.sqrt(((norm_df - ideal_negative) ** 2).sum(axis=1))
-
-        # Calculate the TOPSIS score
-        topsis_score = dist_negative / (dist_positive + dist_negative)
-
-        # Add the TOPSIS score to the dataframe
-        df['TOPSIS_Score'] = topsis_score
-
-        return df
+    
 
     # Original function logic continues here
     if 'phenotypes' not in training_data.columns:
@@ -360,20 +269,6 @@ def NestedKFoldCrossValidation(training_data, training_additive, testing_data, t
     training_genotypic_data_merged = training_data_merged.iloc[:, 2:].values
     testing_genotypic_data_merged = testing_data_merged.iloc[:, 1:].values
 
-    # Feature selection
-    if feature_selection:
-        rf = RandomForestRegressor(n_estimators=100, random_state=60)
-        rf.fit(training_genotypic_data_merged, phenotypic_info)
-        selector = SelectFromModel(rf, threshold="mean", prefit=True)
-        training_genotypic_data_merged = selector.transform(training_genotypic_data_merged)
-        testing_genotypic_data_merged = selector.transform(testing_genotypic_data_merged)
-        print(f"Selected {training_genotypic_data_merged.shape[1]} features based on importance.")
-
-    # Standardize the genotypic data
-    scaler = StandardScaler()
-    training_genotypic_data_merged = scaler.fit_transform(training_genotypic_data_merged)
-    testing_genotypic_data_merged = scaler.transform(testing_genotypic_data_merged)
-
     outer_kf = KFold(n_splits=outer_n_splits)
 
     results = []
@@ -397,7 +292,22 @@ def NestedKFoldCrossValidation(training_data, training_additive, testing_data, t
         outer_trainX = training_genotypic_data_merged[outer_train_index]
         outer_trainy = phenotypic_info[outer_train_index]
 
-        outer_testX = testing_genotypic_data_merged
+        # Feature selection (inside the outer loop to prevent data leakage)
+        if feature_selection:
+            rf = RandomForestRegressor(n_estimators=100, random_state=42)
+            rf.fit(outer_trainX, outer_trainy)  # Fit only on outer_trainX
+            selector = SelectFromModel(rf, threshold="mean", prefit=True)
+            outer_trainX = selector.transform(outer_trainX)
+            testing_genotypic_data_merged_fold = selector.transform(testing_genotypic_data_merged)  # Transform testing data
+        else:
+            testing_genotypic_data_merged_fold = testing_genotypic_data_merged
+
+        # Standardization (inside the outer loop to prevent data leakage)
+        scaler = StandardScaler()
+        outer_trainX = scaler.fit_transform(outer_trainX)  # Fit and transform on outer_trainX
+        testing_genotypic_data_merged_fold = scaler.transform(testing_genotypic_data_merged_fold)  # Transform testing data
+
+        outer_testX = testing_genotypic_data_merged_fold
         outer_testy = phenotypic_test_info
 
         for model_name, model_func in models:
@@ -468,18 +378,14 @@ def NestedKFoldCrossValidation(training_data, training_additive, testing_data, t
         predicted_all_df.to_csv(predicted_phenotype_file, index=False)
 
     return avg_results_df, predicted_all_df if all_predicted_phenotypes else None
-
-
-
-#--------------------------------------------------------------------Gradio interface---------------------------------------------------------------
-
+#-------------------------------------------------------------------Gradio Interface----------------------------------
 def run_cross_validation(training_file, training_additive_file, testing_file, testing_additive_file, 
                          training_dominance_file, testing_dominance_file,feature_selection,learning_rate,min_child_weight):
 
     # Default parameters
     epochs = 1000
     batch_size = 64
-    outer_n_splits = 10
+    outer_n_splits = 2
     #inner_n_splits = 2
     min_child_weight=5
     learning_rate=0.001
@@ -552,3 +458,5 @@ with gr.Blocks() as interface:
 
 # Launch the interface
 interface.launch()
+
+