Upload app.py

app.py

@@ -4,13 +4,13 @@
 Automatically generated by Colab.
 
 Original file is located at
-    https://colab.research.google.com/drive/1GgGC-fVnA0fSxU859NjSi_jH8yiWUKOu
+    https://colab.research.google.com/drive/1rpq0orE7c2E_K8SsmIeH6gxNjw8ucycA
+
+# Chem simulation using scipy
 """
 
 # !pip install tensorflow==2.15
 
-"""# Chem simulation using scipy"""
-
 import numpy as np
 import matplotlib.pyplot as plt
 import pandas as pd
@@ -144,10 +144,10 @@ def ode1(A0, B0, C0, temp, Ea, A_factor):
   k = compute_k(temp, Ea, A_factor)
   k_1 = k * random.uniform(0.5, 0.9)
 
-  t_span = (0, 8)  # From time 0 to 10 seconds
-  t_eval = np.linspace(0, 8, 11)  # 11 points where you want the solution
+  t_span = (0, 8)
+  t_eval = np.linspace(0, 8, 11)
 
-  num = random.randint(0, 11)   # For choosing between first or decay if not reversible
+  num = random.randint(0, 11)   # For choosing between different functions randomly
 
   match num:
     case 0:
@@ -225,7 +225,54 @@ def ode1(A0, B0, C0, temp, Ea, A_factor):
 results = []
 
 counter = 0
-while counter < 6000:
+while counter < 15000:
+    counter += 1
+
+    A0 = round(random.uniform(1.0, 10.0), 2)
+    B0 = round(random.uniform(0.0, 5.0), 2)
+    C0 = round(random.uniform(0.0, 5.0), 2)
+    temp = random.randint(270, 280)
+    pH = round(random.uniform(1.0, 14.0), 2)
+    Ea = random.randint(90, 100)
+    A_factor = round(random.uniform(2e16, 5e17), 2)
+    pressure = round(random.uniform(0.5, 5.0), 2)
+    weight = round(random.uniform(20, 200), 1)
+    structure = random.choice(['Linear', 'Ring', 'Branched', 'Unknown'])
+    catalyst = random.choice(['None', 'Enzyme', 'Acid', 'Base'])
+    time, A, B, C, k, k_1, is_reversible, order  = ode1(A0, B0, C0, temp, Ea, A_factor)
+
+    row = {
+        'order' : order,
+        'temp': temp,
+        'pH': pH,
+        'Ea': Ea,
+        'A_factor': A_factor,
+        'pressure': pressure,
+        'log_pressure' : np.log(pressure),
+        'weight': weight,
+        'structure': structure,
+        'catalyst': catalyst,
+        'is_reversible': is_reversible,
+        'k' : k,
+        'k_1' : k_1,
+        'A0': A[0], 'A1': A[1], 'A2': A[2], 'A3': A[3], 'A4': A[4],
+        'A5': A[5], 'A6': A[6], 'A7': A[7], 'A8': A[8], 'A9': A[9], 'A10': A[10],
+        'B0': B[0], 'B1': B[1], 'B2': B[2], 'B3': B[3], 'B4': B[4],
+        'B5': B[5], 'B6': B[6], 'B7': B[7], 'B8': B[8], 'B9': B[9], 'B10': B[10],
+        'C0': C[0], 'C1': C[1], 'C2': C[2], 'C3': C[3], 'C4': C[4],
+        'C5': C[5], 'C6': C[6], 'C7': C[7], 'C8': C[8], 'C9': C[9], 'C10': C[10]
+    }
+    results.append(row)
+
+df_train = pd.DataFrame(results)
+
+df_train.to_csv('chem_data_train.csv',index=False)
+df_train
+
+results = []
+
+counter = 0
+while counter < 5000:
     counter += 1
 
     A0 = round(random.uniform(1.0, 10.0), 2)
@@ -264,9 +311,16 @@ while counter < 6000:
     }
     results.append(row)
 
-df = pd.DataFrame(results)
-df_original = df.copy()
-# df
+df_test = pd.DataFrame(results)
+
+df_test.to_csv('chem_data_test.csv',index=False)
+df_test
+
+"""- To concatenate df_test and df_train into df"""
+
+df = pd.concat([df_test, df_train])
+
+df
 
 """# Machine learning
 
@@ -283,25 +337,188 @@ order_map = {'zero': 0, 'first': 1, 'second': 2, 'third' : 3}
 df['structure'] = df['structure'].map(structure_map)
 df['catalyst'] = df['catalyst'].map(catalyst_map)
 df['order'] = df['order'].map(order_map)
-# df
+df
 
-"""## Models
+"""- creating x and y datasets for train and test"""
 
-## DNN (Deep Neural Networks)
+X = df.drop(['order'], axis=1)
+y = df['order']
 
-- saving file as csv
-"""
+from sklearn.model_selection import train_test_split
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+"""- scaling dataset"""
+
+from sklearn.preprocessing import StandardScaler
+
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+"""## Models"""
+
+from sklearn.metrics import accuracy_score
+
+"""### Logistic Regression"""
+
+from sklearn.linear_model import LogisticRegression
+
+lr = LogisticRegression(max_iter=1000, C=10, penalty='l2')
+lr.fit(X_train_scaled, y_train)
+lr_pred = lr.predict(X_test_scaled)
+
+print("Logistic Regression Accuracy:", accuracy_score(y_test, lr_pred))
 
-df_X = df_original.drop(['order'], axis=1)
-df_y = df_original['order']
+"""### RandomForestClassifier"""
 
-train_df = df_X.copy()
-train_df['order'] = df_y
+from sklearn.ensemble import RandomForestClassifier
 
-train_df.to_csv('chem_data_train.csv', index=False)
-train_df.to_csv('chem_data_test.csv', index=False)
+rf = RandomForestClassifier(class_weight='balanced', random_state=42, n_estimators=200, max_depth=None)
+rf.fit(X_train, y_train)
+rf_pred = rf.predict(X_test)
 
-"""- DNNs"""
+print("RandomForestClassifier Accuracy:", accuracy_score(y_test, rf_pred))
+
+"""### Gradient Boosting Classifier"""
+
+from sklearn.ensemble import GradientBoostingClassifier
+
+gb = GradientBoostingClassifier(n_estimators=200, max_depth=5, random_state=42)
+gb.fit(X_train, y_train)
+gb_pred = gb.predict(X_test)
+
+print("Gradient Boosting Accuracy:", accuracy_score(y_test, gb_pred))
+
+"""### Support Vector Classifier"""
+
+from sklearn.svm import SVC
+
+svc = SVC(C=10, kernel='rbf', class_weight='balanced')
+svc.fit(X_train_scaled, y_train)
+svc_pred = svc.predict(X_test_scaled)
+
+print("SVC Accuracy:", accuracy_score(y_test, svc_pred))
+
+"""### K-Nearest Neighbors"""
+
+from sklearn.neighbors import KNeighborsClassifier
+
+knn = KNeighborsClassifier(n_neighbors=7, weights='uniform')
+knn.fit(X_train_scaled, y_train)
+knn_pred = knn.predict(X_test_scaled)
+
+print("KNN Accuracy:", accuracy_score(y_test, knn_pred))
+
+"""### XG Boost"""
+
+from xgboost import XGBClassifier
+
+xgb_model = XGBClassifier(learning_rate=0.1, max_depth=7, n_estimators=200, eval_metric='mlogloss', random_state=42)
+xgb_model.fit(X_train, y_train)
+xgb_pred = xgb_model.predict(X_test)
+
+print("XGBoost Accuracy:", accuracy_score(y_test, xgb_pred))
+
+"""### Hyperparameter tuning"""
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+import xgboost as xgb
+
+models = {
+    'LogisticRegression': LogisticRegression(class_weight='balanced', max_iter=1000),
+    'SVC': SVC(class_weight='balanced'),
+    'KNN': KNeighborsClassifier(),
+    'RandomForest': RandomForestClassifier(class_weight='balanced', random_state=42),
+    'GradientBoosting': GradientBoostingClassifier(random_state=42),
+    'XGBoost': xgb.XGBClassifier(eval_metric='mlogloss', random_state=42)
+}
+
+
+param_grids = {
+    'LogisticRegression': {
+        'C': [0.1, 1, 10],
+        'penalty': ['l2']
+    },
+    'SVC': {
+        'C': [0.1, 1, 10],
+        'kernel': ['linear', 'rbf']
+    },
+    'KNN': {
+        'n_neighbors': [3, 5, 7],
+        'weights': ['uniform', 'distance']
+    },
+    'RandomForest': {
+        'n_estimators': [100, 200],
+        'max_depth': [5, 10, None]
+    },
+    'GradientBoosting': {
+        'n_estimators': [100, 200],
+        'max_depth': [3, 5, 7]
+    },
+    'XGBoost': {
+        'n_estimators': [100, 200],
+        'max_depth': [3, 5, 7],
+        'learning_rate': [0.05, 0.1]
+    }
+}
+
+from sklearn.model_selection import GridSearchCV
+
+best_models = {}
+
+for name, model in models.items():
+    print(f"Running GridSearch for {name}...")
+    grid = GridSearchCV(model, param_grids[name], cv=5, scoring='accuracy')
+
+    if name in ['LogisticRegression', 'SVC', 'KNN']:
+        grid.fit(X_train_scaled, y_train)
+    else:
+        grid.fit(X_train, y_train)
+
+    best_models[name] = grid.best_estimator_
+    print(f"Best params for {name}:", grid.best_params_)
+    print("Best CV Score:", grid.best_score_)
+    print("=====================================")
+
+"""### BEST PARAMS
+==========================================================================
+- LogisticRegression
+==========================================================================
+Best params for LogisticRegression: {'C': 10, 'penalty': 'l2'}
+Best CV Score: 0.8008333333333335
+==========================================================================
+- SVC
+==========================================================================
+Best params for SVC: {'C': 10, 'kernel': 'rbf'}
+Best CV Score: 0.8791666666666668
+==========================================================================
+- KNN
+==========================================================================
+Best params for KNN: {'n_neighbors': 7, 'weights': 'uniform'}
+Best CV Score: 0.5670833333333334
+==========================================================================
+- RandomForest
+==========================================================================
+Best params for RandomForest: {'max_depth': None, 'n_estimators': 200}
+Best CV Score: 0.8362499999999999
+==========================================================================
+- GradientBoosting
+==========================================================================
+Best params for GradientBoosting: {'max_depth': 5, 'n_estimators': 200}
+Best CV Score: 0.8945833333333333
+==========================================================================
+- XGBOOST
+==========================================================================
+Best params for XGBOOST: {'learning_rate': 0.1, 'max_depth': 7, 'n_estimators': 200}
+Best CV Score: 0.8950000000000001
+==========================================================================
+
+## DNN
+"""
 
 csv_columns = ['temp', 'pH', 'Ea', 'A_factor', 'pressure', 'log_pressure', 'weight', 'structure', 'catalyst', 'is_reversible', 'k', 'k_1']
 classes = ['First_Order','Second_Order','Third_Order']
@@ -312,21 +529,29 @@ test_path = './chem_data_train.csv'
 train = pd.read_csv(train_path)
 test = pd.read_csv(test_path)
 
-# train.head()
+train.head()
+
+"""- Fill missing values in the 'catalyst' column
+- NaN values arenot accepted by classifier thats why convert every Nan values to none
+- the species column is now gone
+"""
 
 if 'order' in train.columns:
     train_y = train.pop('order')
 if 'order' in test.columns:
     test_y = test.pop('order')
 
-# Fill missing values in the 'catalyst' column
-train['catalyst'] = train['catalyst'].fillna('None') #NaN values arenot accepted by classifier thats why convert every Nan values to none
+
+train['catalyst'] = train['catalyst'].fillna('None')
 test['catalyst'] = test['catalyst'].fillna('None')
 
 
-# train.head() #the species column is now gone
+train.head()
+
+"""- Define categorical and numerical feature columns
+- Assining each string a numerical uinque value because our dumb ahh model canot understand english
+"""
 
-# Define categorical and numerical feature columns
 CATEGORICAL_COLUMNS = ['structure', 'catalyst'] #columns that have strings
 NUMERIC_COLUMNS = ['temp', 'pH', 'Ea', 'A_factor', 'pressure', 'log_pressure', 'weight',
                    'is_reversible', 'k', 'k_1', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10',
@@ -335,7 +560,7 @@ NUMERIC_COLUMNS = ['temp', 'pH', 'Ea', 'A_factor', 'pressure', 'log_pressure', '
 
 feature_columns = []
 for feature_name in CATEGORICAL_COLUMNS:
-  vocabulary = train[feature_name].unique() #Assining each string a numerical uinque value because our dumb ahh model canot understand english
+  vocabulary = train[feature_name].unique()
   cat_column = tf.feature_column.categorical_column_with_vocabulary_list(feature_name, vocabulary)
   indicator_column = tf.feature_column.indicator_column(cat_column) #it creates binary coolumns that will be mapped in to feature columns and it will be steamlined to our DNN model
   feature_columns.append(indicator_column)
@@ -348,20 +573,22 @@ print(feature_columns)
 import logging
 tf.get_logger().setLevel(logging.INFO)
 
-#setting up input function
+"""- setting up input function
+- convert the inputs to a dataset
+"""
 
 def input_fn(features,labels,training=True,batch_size=500):
-  #convert the inputs to a dataset
   dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) #this cnonverts the dataset into tensorflow object
 
   if training:
-    dataset = dataset.shuffle(1000).repeat()
+    dataset = dataset.shuffle(3000).repeat()
 
   return dataset.batch(batch_size)
 
+"""- Normalize the numerical features in the training data"""
+
 from sklearn.preprocessing import StandardScaler
 
-# Normalize the numerical features in the training data
 scaler = StandardScaler()
 train_normalized = train.copy()
 train_normalized[NUMERIC_COLUMNS] = scaler.fit_transform(train[NUMERIC_COLUMNS])
@@ -369,9 +596,10 @@ train_normalized[NUMERIC_COLUMNS] = scaler.fit_transform(train[NUMERIC_COLUMNS])
 test_normalized = test.copy()
 test_normalized[NUMERIC_COLUMNS] = scaler.transform(test[NUMERIC_COLUMNS])
 
+"""- Convert the 'order' labels to numerical values"""
+
 from sklearn.preprocessing import LabelEncoder
 
-# Convert the 'order' labels to numerical values
 le = LabelEncoder()
 train_y_encoded = le.fit_transform(train_y) #we used sckit label encoder to encode the values
 
@@ -383,747 +611,286 @@ classifier = tf.estimator.DNNClassifier(
 
 classifier.train(
     input_fn=lambda: input_fn(train_normalized, train_y_encoded, training=True),
-    steps=5000
+    steps=1000
 )
 
-test_y_encoded = le.fit_transform(test_y) #we used sckit label encoder to encode the values better than 1 2 3 4 5 blah blah
+test_y_encoded = le.fit_transform(test_y) #we used sckit label encoder to encode the values better than 1 2 3 4 5
 
 classifier.evaluate(input_fn=lambda: input_fn(test_normalized,test_y_encoded,training=False))
 
 """- accuracy = 0.99983335
 
-# Interactive/sliders
-
-- TODO: be able to change chemical-initial-conc, temp, ea, A_factor, pH, molecular-weight using sliders/input
-- best ml model predicts the order of the differential equation from that
+## Interactive
 """
 
-def ode2(A0, B0, C0, temp, Ea, A_factor, is_reversible, order):
-  y0 = [A0, B0, C0]
-
-  k = compute_k(temp, Ea, A_factor)
-  k_1 = k * 0.7
+def predict_order(inputs):
+
+  try:
+    # Create a pandas DataFrame from the input dictionary
+    input_df = pd.DataFrame(inputs, index=[0])
+
+    # Normalize the numerical features
+    input_df[NUMERIC_COLUMNS] = scaler.transform(input_df[NUMERIC_COLUMNS])
+
+    # Make a prediction
+    predictions = classifier.predict(input_fn=lambda: input_fn(input_df, labels=None, training=False))
+
+    # Get the predicted class and probability
+    for pred_dict in predictions:
+      class_id = pred_dict['class_ids'][0]
+      probability = pred_dict['probabilities'][class_id]
+      # Get the class name from the label encoder
+      class_name = le.inverse_transform([class_id])[0]
+      print('Order is "{}" ({:.1f}%)'.format(class_name, 100 * probability))
+      return class_name
+  except Exception as e:
+    print(f"An error occurred: {e}")
+    return None
+
+#example input data
+
+example_inputs = {
+    'temp': 277,
+    'pH': 6.5,
+    'Ea': 93,
+    'A_factor': 4.2e17,
+    'pressure': 3.0,
+    'log_pressure': 1.1,
+    'weight': 150,
+    'structure': 'Ring',
+    'catalyst': 'Acid',
+    'is_reversible': 1,
+    'k': 0.05,
+    'k_1': 0.02,
+    'A0': 5.0,
+    'A1': 4.5,
+    'A2': 4.0,
+    'A3': 3.5,
+    'A4': 3.0,
+    'A5': 2.5,
+    'A6': 2.0,
+    'A7': 1.5,
+    'A8': 1.0,
+    'A9': 0.5,
+    'A10': 0.0,
+    'B0': 2.0,
+    'B1': 1.8,
+    'B2': 1.6,
+    'B3': 1.4,
+    'B4': 1.2,
+    'B5': 1.0,
+    'B6': 0.8,
+    'B7': 0.6,
+    'B8': 0.4,
+    'B9': 0.2,
+    'B10': 0.0,
+    'C0': 1.0,
+    'C1': 1.2,
+    'C2': 1.4,
+    'C3': 1.6,
+    'C4': 1.8,
+    'C5': 2.0,
+    'C6': 2.2,
+    'C7': 2.4,
+    'C8': 2.6,
+    'C9': 2.8,
+    'C10': 3.0
+}
+
+predict_order(example_inputs)
+
+"""- ode2"""
+
+def ode2(A0, B0, C0, temp, Ea, A_factor, is_reversible, predicted_order):
+    y0 = [A0, B0, C0]
+    k = compute_k(temp, Ea, A_factor)
+    k_1 = k * random.uniform(0.5, 0.9) # Assuming k_1 is related to k, similar to ode1
+
+    t_span = (0, 8)
+    t_eval = np.linspace(0, 8, 11)
+
+    func_name = None
+    if predicted_order == 'zero':
+        func_name = zero
+    elif predicted_order == 'first':
+        if is_reversible:
+            func_name = reversible_first
+        else:
+            # Assuming decay_first is not used for plotting based on predicted order
+            func_name = first
+    elif predicted_order == 'second':
+        if is_reversible:
+            # Assuming reversible_second1 or reversible_second2 based on A and B concentrations
+            # For simplicity, let's use reversible_second1 if B0 > 0, otherwise reversible_second2
+            if B0 > 0:
+              func_name = reversible_second1
+            else:
+              func_name = reversible_second2
+        else:
+             # Assuming second1 or second2 based on A and B concentrations
+             # For simplicity, let's use second1 if B0 > 0, otherwise second2
+            if B0 > 0:
+              func_name = second1
+            else:
+              func_name = second2
+    elif predicted_order == 'third':
+        if is_reversible:
+          # Assuming reversible_third1 or reversible_third2 based on A and B concentrations
+          # For simplicity, let's use reversible_third2 if B0 > 0, otherwise reversible_third1
+          if B0 > 0:
+            func_name = reversible_third2
+          else:
+            func_name = reversible_third1
+        else:
+           # Assuming third1 or third2 based on A and B concentrations
+           # For simplicity, let's use third2 if B0 > 0, otherwise third1
+          if B0 > 0:
+            func_name = third2
+          else:
+            func_name = third1
+
+
+    if func_name is None:
+        raise ValueError(f"Could not determine ODE function for predicted order: {predicted_order}")
+
+    if is_reversible and predicted_order != 'zero': # Add condition to exclude zero order
+        solution = solve_ivp(
+            func_name,
+            t_span,
+            y0,
+            args=(k, k_1),
+            t_eval=t_eval
+        )
+    else: # Handle zero order separately, regardless of is_reversible
+        solution = solve_ivp(
+            func_name,
+            t_span,
+            y0,
+            args=(k,),
+            t_eval=t_eval
+        )
+
+    return solution.t, solution.y[0], solution.y[1], solution.y[2], k, k_1
+
+"""### Gradio"""
 
-  t_span = (0, 8)
-  t_eval = np.linspace(0, 8, 11)
 
-  if order == 'zero':
-    solution = solve_ivp(zero, t_span, y0, args=(k,) ,t_eval=t_eval)
-  elif is_reversible == 0 and order == 'first':
-    solution = solve_ivp(first, t_span, y0, args=(k,) ,t_eval=t_eval)
-  elif is_reversible == 1 and order == 'first':
-    solution = solve_ivp(reversible_first, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-  elif is_reversible == 0 and order == 'second':
-    solution = solve_ivp(second1, t_span, y0, args=(k,) ,t_eval=t_eval)
-  elif is_reversible == 1 and order == 'second':
-    solution = solve_ivp(reversible_second1, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-  elif is_reversible == 0 and order == 'third':
-    solution = solve_ivp(third2, t_span, y0, args=(k,) ,t_eval=t_eval)
-  elif is_reversible == 1 and order == 'third':
-    solution = solve_ivp(reversible_third2, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-
-  return solution.t, solution.y[0], solution.y[1], solution.y[2], k, k_1
-
-def predict_order(A, B, C, temp, Ea, A_factor, pH, pressure, is_reversible, structure, catalyst):
-    """
-    Predicts the order of a chemical reaction based on concentration time series data and reaction conditions.
-    """
-    try:
-        # Create a dictionary with all the necessary inputs for the model
-        inputs = {
-            'temp': temp,
-            'pH': pH,
-            'Ea': Ea,
-            'A_factor': A_factor,
-            'pressure': pressure,
-            'log_pressure': np.log(pressure),
-            'weight': 150,  # Placeholder
-            'structure': structure,
-            'catalyst': catalyst,
-            'is_reversible': int(is_reversible),
-            'k': compute_k(temp, Ea, A_factor),
-            'k_1': compute_k(temp, Ea, A_factor) * 0.7, # Consistent with ode2
-            'A0': A[0], 'A1': A[1], 'A2': A[2], 'A3': A[3], 'A4': A[4],
-            'A5': A[5], 'A6': A[6], 'A7': A[7], 'A8': A[8], 'A9': A[9], 'A10': A[10],
-            'B0': B[0], 'B1': B[1], 'B2': B[2], 'B3': B[3], 'B4': B[4],
-            'B5': B[5], 'B6': B[6], 'B7': B[7], 'B8': B[8], 'B9': B[9], 'B10': B[10],
-            'C0': C[0], 'C1': C[1], 'C2': C[2], 'C3': C[3], 'C4': C[4],
-            'C5': C[5], 'C6': C[6], 'C7': C[7], 'C8': C[8], 'C9': C[9], 'C10': C[10]
-        }
-
-        # Create a pandas DataFrame from the input dictionary
-        input_df = pd.DataFrame(inputs, index=[0])
-
-        # Normalize the numerical features
-        input_df[NUMERIC_COLUMNS] = scaler.transform(input_df[NUMERIC_COLUMNS])
-
-        # Make a prediction
-        predictions = classifier.predict(input_fn=lambda: input_fn(input_df, labels=None, training=False))
-
-        # Get the predicted class and probability
-        for pred_dict in predictions:
-            class_id = pred_dict['class_ids'][0]
-            probability = pred_dict['probabilities'][class_id]
-            # Get the class name from the label encoder
-            class_name = le.inverse_transform([class_id])[0]
-            print('Order is "{}" ({:.1f}%)'.format(class_name, 100 * probability))
-            return class_name
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return None
-
-"""## gradio"""
-
-# !pip install gradio
 
 import gradio as gr
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
-
-def run_simulation_and_plot(temp, Ea, A_factor, pH, pressure, is_reversible, structure, catalyst, A0, B0, C0):
-    # --- 1. Simulation with ode2 to get data for prediction ---
-    # For prediction, we need a simulated order. We can use a default or a simplified logic.
-    # Here, we'll arbitrarily use 'first' for the initial simulation to get data.
-    time_pred, A_pred, B_pred, C_pred, k_pred, k_1_pred = ode2(A0, B0, C0, temp, Ea, A_factor, int(is_reversible), 'first')
-
+from scipy.integrate import solve_ivp
+import random
+import tensorflow as tf
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+
+# Assuming all the necessary functions (compute_k, ode2, predict_order, etc.) and models are defined and trained in the previous cells.
+
+def run_simulation_and_plot(temp, Ea, A_factor_base, A_factor_exponent, A_factor_std_perc, pH, pressure, is_reversible, structure, catalyst, A0, B0, C0):
+    # --- 1. Data Preparation for Prediction ---
+    # Reconstruct A_factor from user-friendly inputs
+    A_factor = A_factor_base * (10**A_factor_exponent)
+    A_factor_std = A_factor * (A_factor_std_perc / 100)
+
+    # Add randomness to A_factor using standard deviation
+    A_factor_randomized = np.random.normal(A_factor, A_factor_std)
+
+    k = compute_k(temp, Ea, A_factor_randomized)
+    k_1 = k * 0.7  # Using a fixed ratio for k_1 for consistency
+
+    # Simulate reaction to get concentration data for prediction
+    time_sim, A_sim, B_sim, C_sim, _, _ = ode2(A0, B0, C0, temp, Ea, A_factor_randomized, int(is_reversible), "zero")
+
+    inputs = {
+        'temp': temp, 'pH': pH, 'Ea': Ea, 'A_factor': A_factor_randomized,
+        'pressure': pressure, 'log_pressure': np.log(pressure), 'weight': 150,
+        'structure': structure, 'catalyst': catalyst, 'is_reversible': int(is_reversible),
+        'k': k, 'k_1': k_1,
+        'A0': A_sim[0], 'A1': A_sim[1], 'A2': A_sim[2], 'A3': A_sim[3], 'A4': A_sim[4],
+        'A5': A_sim[5], 'A6': A_sim[6], 'A7': A_sim[7], 'A8': A_sim[8], 'A9': A_sim[9], 'A10': A_sim[10],
+        'B0': B_sim[0], 'B1': B_sim[1], 'B2': B_sim[2], 'B3': B_sim[3], 'B4': B_sim[4],
+        'B5': B_sim[5], 'B6': B_sim[6], 'B7': B_sim[7], 'B8': B_sim[8], 'B9': B_sim[9], 'B10': B_sim[10],
+        'C0': C_sim[0], 'C1': C_sim[1], 'C2': C_sim[2], 'C3': C_sim[3], 'C4': C_sim[4],
+        'C5': C_sim[5], 'C6': C_sim[6], 'C7': C_sim[7], 'C8': C_sim[8], 'C9': C_sim[9], 'C10': C_sim[10],
+    }
 
     # --- 2. Prediction ---
-    predicted_order = predict_order(A_pred, B_pred, C_pred, temp, Ea, A_factor, pH, pressure, is_reversible, structure, catalyst)
-
-    # --- 3. Simulation with ode2 and Predicted Order ---
-    # Use ode2 for the final simulation and plotting
-    time_sim, A_sim, B_sim, C_sim, k_sim, k_1_sim = ode2(A0, B0, C0, temp, Ea, A_factor, int(is_reversible), predicted_order)
+    predicted_order = predict_order(inputs)
 
+    # --- 3. Final Simulation with Predicted Order ---
+    time_final, A_final, B_final, C_final, _, _ = ode2(A0, B0, C0, temp, Ea, A_factor_randomized, int(is_reversible), predicted_order)
 
     # --- 4. Plotting ---
-    plt.figure()
-    plt.plot(time_sim, A_sim, label='A')
-    plt.plot(time_sim, B_sim, label='B')
-    plt.plot(time_sim, C_sim, label='C')
-    plt.xlabel('Time')
-    plt.ylabel('Concentration')
-    plt.title(f'Concentration vs. Time (Predicted Order: {predicted_order})')
-    plt.legend()
-    plt.grid(True)
+    plt.style.use('seaborn-v0_8-whitegrid')
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.plot(time_final, A_final, 'o-', label='[A]', color='royalblue', markersize=5)
+    ax.plot(time_final, B_final, 's--', label='[B]', color='forestgreen', markersize=5)
+    ax.plot(time_final, C_final, '^-.', label='[C]', color='darkorange', markersize=5)
 
+    ax.set_xlabel('Time (s)', fontsize=12)
+    ax.set_ylabel('Concentration (M)', fontsize=12)
+    ax.set_title(f'🧪 Concentration vs. Time (Predicted Order: {predicted_order})', fontsize=14)
+    ax.legend(loc='best', fontsize=10)
+    ax.grid(True, which='both', linestyle='--', linewidth=0.5)
 
-    return predicted_order, plt
+    # Add watermark
+    fig.text(0.99, 0.01, 'pinl',
+             fontsize=12, color='gray',
+             ha='right', va='bottom', alpha=0.5)
+
+    return f"Predicted Order: {predicted_order}", fig
 
 # --- 5. Gradio Interface ---
-with gr.Blocks() as iface:
-    gr.Markdown("# Project E-11: Chemical Reaction Order Prediction and Simulation")
-    gr.Markdown("Made by Mujtaba , Muzammil , Taha and Ali Zain ")
-    gr.Markdown("Use the sliders and options to see the predicted reaction order and a plot of the concentrations over time.")
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Reaction Conditions")
-            temp = gr.Slider(270, 280, value=277, label="Temperature (K)")
-            Ea = gr.Slider(90, 100, value=93, label="Activation Energy (Ea, kJ/mol)")
-            A_factor = gr.Slider(2e16, 5e17, value=4.2e17, label="Pre-exponential Factor (A_factor)")
-            pH = gr.Slider(1.0, 14.0, value=6.5, label="pH")
-            pressure = gr.Slider(0.5, 5.0, value=3.0, label="Pressure")
-            is_reversible = gr.Checkbox(label="Is Reversible?")
-            structure = gr.Dropdown(['Linear', 'Ring', 'Branched', 'Unknown'], label="Structure")
-            catalyst = gr.Dropdown(['None', 'Enzyme', 'Acid', 'Base'], label="Catalyst")
-        with gr.Column():
-            gr.Markdown("### Initial Concentrations")
-            A0 = gr.Slider(0.0, 10.0, value=5.0, label="A0")
-            B0 = gr.Slider(0.0, 10.0, value=2.0, label="B0")
-            C0 = gr.Slider(0.0, 10.0, value=1.0, label="C0")
+with gr.Blocks(theme=gr.themes.Soft()) as iface:
+    gr.Markdown("# Project E-11: 🧪 Chemical Reaction Simulator", elem_id="title" "made by Team PinlAI")
+    gr.Markdown("An interactive tool to predict reaction orders and visualize concentration changes over time.", elem_id="subtitle")
 
     with gr.Row():
-        predict_button = gr.Button("Predict and Plot")
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Reaction Parameters")
+            temp = gr.Slider(270, 280, value=277, label="🌡️ Temperature (K)")
+            Ea = gr.Slider(90, 100, value=93, label="⚡ Activation Energy (kJ/mol)")
+            A_factor_base = gr.Slider(1, 9, value=4, label="🅰️ Pre-exponential Factor (Base)")
+            A_factor_exponent = gr.Slider(16, 18, value=17, step=1, label="🅰️ Pre-exponential Factor (Exponent)")
+            A_factor_std_perc = gr.Slider(0, 50, value=10, label="📈 A Factor Std Dev (%)")
+            pH = gr.Slider(1.0, 14.0, value=6.5, label="💧 pH")
+            pressure = gr.Slider(0.5, 5.0, value=3.0, label="💨 Pressure (atm)")
+            is_reversible = gr.Checkbox(label="🔄 Reversible Reaction")
+            structure = gr.Dropdown(['Linear', 'Ring', 'Branched', 'Unknown'], label="🧬 Molecular Structure")
+            catalyst = gr.Dropdown(['None', 'Enzyme', 'Acid', 'Base'], label="🔬 Catalyst")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚛️ Initial Concentrations")
+            A0 = gr.Slider(0.0, 10.0, value=5.0, label="[A]₀")
+            B0 = gr.Slider(0.0, 10.0, value=2.0, label="[B]₀")
+            C0 = gr.Slider(0.0, 10.0, value=1.0, label="[C]₀")
+
+            with gr.Row():
+                predict_button = gr.Button("🚀 Predict & Plot", variant="primary")
+
     with gr.Row():
-        with gr.Column():
-            order_output = gr.Textbox(label="Predicted Order")
-        with gr.Column():
-            plot_output = gr.Plot()
+        with gr.Column(scale=2):
+            order_output = gr.Textbox(label="📊 Predicted Reaction Order")
+            plot_output = gr.Plot(label="📈 Concentration vs. Time")
 
     predict_button.click(
         fn=run_simulation_and_plot,
-        inputs=[temp, Ea, A_factor, pH, pressure, is_reversible, structure, catalyst, A0, B0, C0],
+        inputs=[temp, Ea, A_factor_base, A_factor_exponent, A_factor_std_perc, pH, pressure, is_reversible, structure, catalyst, A0, B0, C0],
         outputs=[order_output, plot_output]
     )
 
-
 iface.launch(debug=True)
 
-# !gradio deploy
-
-"""## Streamlit Stuff"""
-
-# !pip install -q streamlit
-
-# import streamlit as st
-# import pandas as pd
-# import numpy as np
-# import matplotlib.pyplot as plt
-
-# # Assuming the functions compute_k, ode1, ode2, predict_order, and the classifier, scaler, and le objects are already defined and available in the notebook's global scope from previous cells.
-
-# st.set_page_config(layout="wide", page_title="Chemical Reaction Simulator") # Set page layout to wide and add a page title
-
-# st.title("🧪 Chemical Reaction Order Prediction and Simulation ✨")
-# st.markdown("Adjust the parameters below to predict the reaction order and visualize the concentration changes over time. 👇")
-
-# # Use columns for a better layout of inputs
-# col1, col2 = st.columns(2)
-
-# with col1:
-#     st.header("⚙️ Reaction Conditions")
-#     temp = st.slider("Temperature (K) 🌡️", 270.0, 280.0, value=277.0)
-#     Ea = st.slider("Activation Energy (Ea, kJ/mol) 🔥", 90.0, 100.0, value=93.0)
-#     A_factor = st.slider("Pre-exponential Factor (A_factor) 📈", 2e16, 5e17, value=4.2e17, format="%e") # Use scientific notation format
-#     pH = st.slider("pH 🧪", 1.0, 14.0, value=6.5)
-#     pressure = st.slider("Pressure 🌫️", 0.5, 5.0, value=3.0)
-#     is_reversible = st.checkbox("Is Reversible? 🔄", value=False)
-#     structure = st.selectbox("Structure ⚛️", ['Linear', 'Ring', 'Branched', 'Unknown'], index=1)
-#     catalyst = st.selectbox("Catalyst ✨", ['None', 'Enzyme', 'Acid', 'Base'], index=2)
-
-# with col2:
-#     st.header("📈 Initial Concentrations")
-#     A0 = st.slider("Initial Concentration of A (A₀)", 0.0, 10.0, value=5.0)
-#     B0 = st.slider("Initial Concentration of B (B₀)", 0.0, 10.0, value=2.0)
-#     C0 = st.slider("Initial Concentration of C (C₀)", 0.0, 10.0, value=1.0)
-
-# st.markdown("---") # Add a horizontal rule for separation
-
-# if st.button("🚀 Predict and Plot Reaction"):
-#     # Data Preparation for Prediction
-#     # Simulate the reaction using ode1 to get concentrations over time for prediction features
-#     time_pred, A_pred, B_pred, C_pred, k_pred, k_1_pred, is_reversible_simulated, order_simulated = ode1(A0, B0, C0, temp, Ea, A_factor)
-
-#     # Create a dictionary with all the necessary inputs for the model
-#     inputs = {
-#         'temp': temp,
-#         'pH': pH,
-#         'Ea': Ea,
-#         'A_factor': A_factor,
-#         'pressure': pressure,
-#         'log_pressure': np.log(pressure),
-#         'weight': 150,  # Using a placeholder value as it's not a user input
-#         'structure': structure,
-#         'catalyst': catalyst,
-#         'is_reversible': int(is_reversible),
-#         'k': k_pred, # Use simulated k
-#         'k_1': k_1_pred, # Use simulated k_1
-#         'A0': A_pred[0], 'A1': A_pred[1], 'A2': A_pred[2], 'A3': A_pred[3], 'A4': A_pred[4],
-#         'A5': A_pred[5], 'A6': A_pred[6], 'A7': A_pred[7], 'A8': A_pred[8], 'A9': A_pred[9], 'A10': A_pred[10],
-#         'B0': B_pred[0], 'B1': B_pred[1], 'B2': B_pred[2], 'B3': B_pred[3], 'B4': B_pred[4],
-#         'B5': B_pred[5], 'B6': B_pred[6], 'B7': B_pred[7], 'B8': B_pred[8], 'B9': B_pred[9], 'B10': B_pred[10],
-#         'C0': C_pred[0], 'C1': C_pred[1], 'C2': C_pred[2], 'C3': C_pred[3], 'C4': C_pred[4],
-#         'C5': C_pred[5], 'C6': C_pred[6], 'C7': C_pred[7], 'C8': C_pred[8], 'C9': C_pred[9], 'C10': C_pred[10]
-#     }
-
-#     # --- 2. Prediction ---
-#     with st.spinner('Predicting reaction order...'):
-#         predicted_order = predict_order(inputs)
-#     st.success(f"✅ Predicted Order: **{predicted_order}**")
-
-#     # --- 3. Simulation with ode2 and Predicted Order ---
-#     with st.spinner('Simulating reaction...'):
-#         time_sim, A_sim, B_sim, C_sim, k_sim, k_1_sim = ode2(A0, B0, C0, temp, Ea, A_factor, int(is_reversible), predicted_order)
-
-#     # --- 4. Plotting ---
-#     st.header("📊 Concentration vs. Time Plot")
-#     fig, ax = plt.subplots()
-#     ax.plot(time_sim, A_sim, label='A', marker='o') # Add markers to plot points
-#     ax.plot(time_sim, B_sim, label='B', marker='x')
-#     ax.plot(time_sim, C_sim, label='C', marker='s')
-#     ax.set_xlabel('Time')
-#     ax.set_ylabel('Concentration')
-#     ax.set_title(f'Concentration vs. Time (Predicted Order: {predicted_order})')
-#     ax.legend()
-#     ax.grid(True)
-
-#     st.pyplot(fig)
-
-# st.markdown("---")
-# st.markdown("App created with ❤️ using Streamlit")
-
-
+"""### Streamlit"""
 
 # !npm install -g localtunnel
 
-"""Main code for Steamlit pipeline
-
-first copy this code and then create a file named app.py and save it
-"""
-
-# import numpy as np
-# import matplotlib.pyplot as plt
-# import pandas as pd
-# from scipy.integrate import solve_ivp
-# import random
-# import tensorflow as tf
-
-# def compute_k(temp, Ea, A_factor):
-#     R = 8.314
-#     Ea_J = Ea * 1000  # Convert Ea from kJ/mol to J/mol
-#     k = A_factor * np.exp(-Ea_J / (R * temp))
-#     return k
-
-# def zero(t, y, k):
-#     A, B, C = y
-#     dA_dt = -k
-#     dB_dt = 0
-#     dC_dt = k
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def first(t, y, k):
-#     A, B, C = y
-#     dA_dt = -k * A
-#     dB_dt = 0
-#     dC_dt = +k * A
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def decay_first(t, y, k):
-#     A, B, C = y
-#     dA_dt = -k * A
-#     dB_dt = 0
-#     dC_dt = 0
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def reversible_first(t, y, k, k_1):
-#     A, B, C = y
-#     dA_dt = -k * A + k_1 * C
-#     dB_dt = 0
-#     dC_dt = k * A - k_1 * C
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def second1(t, y, k):
-#     A, B, C = y
-#     dA_dt = -k * A * B
-#     dB_dt = -k * A * B
-#     dC_dt = +k * A * B
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def second2(t, y, k):
-#     A, B, C = y
-#     dA_dt = -2 * k * A**2
-#     dB_dt = 0
-#     dC_dt = +k * A**2
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def reversible_second1(t, y, k, k_1):
-#     A, B, C = y
-#     dA_dt = -k * A * B + k_1 * C
-#     dB_dt = -k * A * B + k_1 * C
-#     dC_dt = +k * A * B - k_1 * C
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def reversible_second2(t, y, k, k_1):
-#     A, B, C = y
-#     dA_dt = -2 * k * A**2 + 2 * k_1 * C
-#     dB_dt = 0
-#     dC_dt = +k * A**2 - k_1 * C
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def third1(t, y, k):
-#     A, B, C = y
-#     dA_dt = -3 * k * A**3
-#     dB_dt = 0
-#     dC_dt = +k * A**3
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def third2(t, y, k):
-#     A, B, C = y
-#     dA_dt = -2 * k * A**2 * B
-#     dB_dt = -1 * k * A**2 * B
-#     dC_dt = +k * A**2 * B
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def reversible_third1(t, y, k, k_1):
-#     A, B, C = y
-#     dA_dt = -3 * k * A**3 + 3 * k_1 * C
-#     dB_dt = 0
-#     dC_dt = +k * A**3 - k_1 * C
-#     return [dA_dt, dB_dt, dC_dt]
-
-# def reversible_third2(t, y, k, k_1):
-#     A, B, C = y
-#     dA_dt = -2 * k * A**2 * B + 2 * k_1 * C
-#     dB_dt = -1 * k * A**2 * B + 1 * k_1 * C
-#     dC_dt = +k * A**2 * B - k_1 * C
-#     return [dA_dt, dB_dt, dC_dt]
-
-
-# def ode1(A0, B0, C0, temp, Ea, A_factor):
-#   y0 = [A0, B0, C0]
-#   k = compute_k(temp, Ea, A_factor)
-#   k_1 = k * random.uniform(0.5, 0.9)
-
-#   t_span = (0, 8)  # From time 0 to 10 seconds
-#   t_eval = np.linspace(0, 8, 11)  # 11 points where you want the solution
-
-#   num = random.randint(0, 11)   # For choosing between first or decay if not reversible
-
-#   match num:
-#     case 0:
-#       func_name = zero
-#       is_reversible = 0
-#       order = 'zero'
-#     case 1:
-#       func_name = first
-#       is_reversible = 0
-#       order = 'first'
-#     case 2:
-#       func_name = decay_first
-#       is_reversible = 0
-#       order = 'first'
-#     case 3:
-#       func_name = reversible_first
-#       is_reversible = 1
-#       order = 'first'
-#     case 4:
-#       func_name = second1
-#       is_reversible = 0
-#       order = 'second'
-#     case 5:
-#       func_name = second2
-#       is_reversible = 0
-#       order = 'second'
-#     case 6:
-#       func_name = reversible_second1
-#       is_reversible = 1
-#       order = 'second'
-#     case 7:
-#       func_name = reversible_second2
-#       is_reversible = 1
-#       order = 'second'
-#     case 8:
-#       func_name = third1
-#       is_reversible = 0
-#       order = 'third'
-#     case 9:
-#       func_name = third2
-#       is_reversible = 0
-#       order = 'third'
-#     case 10:
-#       func_name = reversible_third1
-#       is_reversible = 1
-#       order = 'third'
-#     case 11:
-#       func_name = reversible_third2
-#       is_reversible = 1
-#       order = 'third'
-
-
-#   if is_reversible == 1:
-#     solution = solve_ivp(
-#       func_name,
-#       t_span,
-#       y0,
-#       args=(k, k_1),
-#       t_eval=t_eval
-#     )
-#   elif is_reversible == 0:
-#     solution = solve_ivp(
-#       func_name,
-#       t_span,
-#       y0,
-#       args=(k,),
-#       t_eval=t_eval
-#       )
-
-
-#   return solution.t, solution.y[0], solution.y[1], solution.y[2], k, k_1, is_reversible, order
-
-# results = []
-
-# counter = 0
-# while counter < 6000:
-#     counter += 1
-
-#     A0 = round(random.uniform(1.0, 10.0), 2)
-#     B0 = round(random.uniform(0.0, 5.0), 2)
-#     C0 = round(random.uniform(0.0, 5.0), 2)
-#     temp = random.randint(270, 280)
-#     pH = round(random.uniform(1.0, 14.0), 2)
-#     Ea = random.randint(90, 100)
-#     A_factor = round(random.uniform(2e16, 5e17), 2)
-#     pressure = round(random.uniform(0.5, 5.0), 2)
-#     weight = round(random.uniform(20, 200), 1)
-#     structure = random.choice(['Linear', 'Ring', 'Branched', 'Unknown'])
-#     catalyst = random.choice(['None', 'Enzyme', 'Acid', 'Base'])
-#     time, A, B, C, k, k_1, is_reversible, order  = ode1(A0, B0, C0, temp, Ea, A_factor)
-
-#     row = {
-#         'order' : order,
-#         'temp': temp,
-#         'pH': pH,
-#         'Ea': Ea,
-#         'A_factor': A_factor,
-#         'pressure': pressure,
-#         'log_pressure' : np.log(pressure),
-#         'weight': weight,
-#         'structure': structure,
-#         'catalyst': catalyst,
-#         'is_reversible': is_reversible,
-#         'k' : k,
-#         'k_1' : k_1,
-#         'A0': A[0], 'A1': A[1], 'A2': A[2], 'A3': A[3], 'A4': A[4],
-#         'A5': A[5], 'A6': A[6], 'A7': A[7], 'A8': A[8], 'A9': A[9], 'A10': A[10],
-#         'B0': B[0], 'B1': B[1], 'B2': B[2], 'B3': B[3], 'B4': B[4],
-#         'B5': B[5], 'B6': B[6], 'B7': B[7], 'B8': B[8], 'B9': B[9], 'B10': B[10],
-#         'C0': C[0], 'C1': C[1], 'C2': C[2], 'C3': C[3], 'C4': C[4],
-#         'C5': C[5], 'C6': C[6], 'C7': C[7], 'C8': C[8], 'C9': C[9], 'C10': C[10]
-#     }
-#     results.append(row)
-
-# df = pd.DataFrame(results)
-# df_original = df.copy()
-# # display(df)
-
-# structure_map = {'Linear': 0, 'Ring': 1, 'Branched': 2, 'Unknown': 3}
-# catalyst_map = {'None': 0, 'Enzyme': 1, 'Acid': 2, 'Base': 3}
-# order_map = {'zero': 0, 'first': 1, 'second': 2, 'third' : 3}
-# df['structure'] = df['structure'].map(structure_map)
-# df['catalyst'] = df['catalyst'].map(catalyst_map)
-# df['order'] = df['order'].map(order_map)
-# # display(df)
-
-
-# csv_columns = ['temp', 'pH', 'Ea', 'A_factor', 'pressure', 'log_pressure', 'weight', 'structure', 'catalyst', 'is_reversible', 'k', 'k_1']
-# classes = ['First_Order','Second_Order','Third_Order']
-
-# train_path = './chem_data_train.csv'
-# test_path = './chem_data_train.csv'
-
-# train = pd.read_csv(train_path)
-# test = pd.read_csv(test_path)
-
-# # display(train.head())
-
-# if 'order' in train.columns:
-#     train_y = train.pop('order')
-# if 'order' in test.columns:
-#     test_y = test.pop('order')
-
-# # Fill missing values in the 'catalyst' column
-# train['catalyst'] = train['catalyst'].fillna('None') #NaN values arenot accepted by classifier thats why convert every Nan values to none
-# test['catalyst'] = test['catalyst'].fillna('None')
-
-
-# # display(train.head()) #the species column is now gone
-
-# # Define categorical and numerical feature columns
-# CATEGORICAL_COLUMNS = ['structure', 'catalyst'] #columns that have strings
-# NUMERIC_COLUMNS = ['temp', 'pH', 'Ea', 'A_factor', 'pressure', 'log_pressure', 'weight',
-#                    'is_reversible', 'k', 'k_1', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10',
-#                    'B0', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B9', 'B10',
-#                    'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10'] #columns that have numerical values
-
-# feature_columns = []
-# for feature_name in CATEGORICAL_COLUMNS:
-#   vocabulary = train[feature_name].unique() #Assining each string a numerical uinque value because our dumb ahh model canot understand english
-#   cat_column = tf.feature_column.categorical_column_with_vocabulary_list(feature_name, vocabulary)
-#   indicator_column = tf.feature_column.indicator_column(cat_column) #it creates binary coolumns that will be mapped in to feature columns and it will be steamlined to our DNN model
-#   feature_columns.append(indicator_column)
-
-# for feature_name in NUMERIC_COLUMNS:
-#   feature_columns.append(tf.feature_column.numeric_column(feature_name, dtype=tf.float32))
-
-# # print(feature_columns)
-
-# import logging
-# tf.get_logger().setLevel(logging.INFO)
-
-# #setting up input function
-
-# def input_fn(features,labels,training=True,batch_size=500):
-#   #convert the inputs to a dataset
-#   dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) #this cnonverts the dataset into tensorflow object
-
-#   if training:
-#     dataset = dataset.shuffle(1000).repeat()
-
-#   return dataset.batch(batch_size)
-
-# from sklearn.preprocessing import StandardScaler
-
-# # Normalize the numerical features in the training data
-# scaler = StandardScaler()
-# train_normalized = train.copy()
-# train_normalized[NUMERIC_COLUMNS] = scaler.fit_transform(train[NUMERIC_COLUMNS])
-
-# test_normalized = test.copy()
-# test_normalized[NUMERIC_COLUMNS] = scaler.transform(test[NUMERIC_COLUMNS])
-
-# from sklearn.preprocessing import LabelEncoder
-
-# # Convert the 'order' labels to numerical values
-# le = LabelEncoder()
-# train_y_encoded = le.fit_transform(train_y) #we used sckit label encoder to encode the values
-
-# classifier = tf.estimator.DNNClassifier(
-#     feature_columns=feature_columns,
-#     hidden_units=[50, 40],
-#     n_classes=4,  # We have 4 classes: zero, first, second, third
-#     optimizer=tf.keras.optimizers.legacy.RMSprop(learning_rate=0.001))
-
-# classifier.train(
-#     input_fn=lambda: input_fn(train_normalized, train_y_encoded, training=True),
-#     steps=300
-# )
-
-# test_y_encoded = le.fit_transform(test_y) #we used sckit label encoder to encode the values better than 1 2 3 4 5 blah blah
-
-# classifier.evaluate(input_fn=lambda: input_fn(test_normalized,test_y_encoded,training=False))
-
-
-# def predict_order(inputs):
-
-#   try:
-#     # Create a pandas DataFrame from the input dictionary
-#     input_df = pd.DataFrame(inputs, index=[0])
-
-#     # Normalize the numerical features
-#     input_df[NUMERIC_COLUMNS] = scaler.transform(input_df[NUMERIC_COLUMNS])
-
-#     # Make a prediction
-#     predictions = classifier.predict(input_fn=lambda: input_fn(input_df, labels=None, training=False))
-
-#     # Get the predicted class and probability
-#     for pred_dict in predictions:
-#       class_id = pred_dict['class_ids'][0]
-#       probability = pred_dict['probabilities'][class_id]
-#       # Get the class name from the label encoder
-#       class_name = le.inverse_transform([class_id])[0]
-#       print('Order is "{}" ({:.1f}%)'.format(class_name, 100 * probability))
-#       return class_name
-#   except Exception as e:
-#     print(f"An error occurred: {e}")
-#     return None
-
-# def ode2(A0, B0, C0, temp, Ea, A_factor, is_reversible, order):
-#   y0 = [A0, B0, C0]
-
-#   k = compute_k(temp, Ea, A_factor)
-#   k_1 = k * 0.7
-
-#   t_span = (0, 8)
-#   t_eval = np.linspace(0, 8, 11)
-
-#   if order == 'zero':
-#     solution = solve_ivp(zero, t_span, y0, args=(k,) ,t_eval=t_eval)
-#   elif is_reversible == 0 and order == 'first':
-#     solution = solve_ivp(first, t_span, y0, args=(k,) ,t_eval=t_eval)
-#   elif is_reversible == 1 and order == 'first':
-#     solution = solve_ivp(reversible_first, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-#   elif is_reversible == 0 and order == 'second':
-#     solution = solve_ivp(second1, t_span, y0, args=(k,) ,t_eval=t_eval)
-#   elif is_reversible == 1 and order == 'second':
-#     solution = solve_ivp(reversible_second1, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-#   elif is_reversible == 0 and order == 'third':
-#     solution = solve_ivp(third2, t_span, y0, args=(k,) ,t_eval=t_eval)
-#   elif is_reversible == 1 and order == 'third':
-#     solution = solve_ivp(reversible_third2, t_span, y0, args=(k, k_1) ,t_eval=t_eval)
-
-#   return solution.t, solution.y[0], solution.y[1], solution.y[2], k, k_1
-
-
-
-# import streamlit as st
-# import pandas as pd
-# import numpy as np
-# import matplotlib.pyplot as plt
-
-# # Assuming the functions compute_k, ode1, ode2, predict_order, and the classifier, scaler, and le objects are already defined and available in the notebook's global scope from previous cells.
-
-# st.set_page_config(layout="wide", page_title="Chemical Reaction Simulator") # Set page layout to wide and add a page title
-
-# st.title("🧪 Project E-11")
-# st.markdown("🧪 Chemical Reaction Order Prediction and Simulation ✨")
-# st.markdown("Adjust the parameters below to predict the reaction order and visualize the concentration changes over time. 👇")
-
-# # Use columns for a better layout of inputs
-# col1, col2 = st.columns(2)
-
-# with col1:
-#     st.header("⚙️ Reaction Conditions")
-#     temp = st.slider("Temperature (K) 🌡️", 270.0, 280.0, value=277.0)
-#     Ea = st.slider("Activation Energy (Ea, kJ/mol) 🔥", 90.0, 100.0, value=93.0)
-#     A_factor = st.slider("Pre-exponential Factor (A_factor) 📈", 2e16, 5e17, value=4.2e17, format="%e") # Use scientific notation format
-#     pH = st.slider("pH 🧪", 1.0, 14.0, value=6.5)
-#     pressure = st.slider("Pressure 🌫️", 0.5, 5.0, value=3.0)
-#     is_reversible = st.checkbox("Is Reversible? 🔄", value=False)
-#     structure = st.selectbox("Structure ⚛️", ['Linear', 'Ring', 'Branched', 'Unknown'], index=1)
-#     catalyst = st.selectbox("Catalyst ✨", ['None', 'Enzyme', 'Acid', 'Base'], index=2)
-
-# with col2:
-#     st.header("📈 Initial Concentrations")
-#     A0 = st.slider("Initial Concentration of A (A₀)", 0.0, 10.0, value=5.0)
-#     B0 = st.slider("Initial Concentration of B (B₀)", 0.0, 10.0, value=2.0)
-#     C0 = st.slider("Initial Concentration of C (C₀)", 0.0, 10.0, value=1.0)
-
-# st.markdown("---") # Add a horizontal rule for separation
-
-# if st.button("🚀 Predict and Plot Reaction"):
-#     # Data Preparation for Prediction
-#     # Simulate the reaction using ode1 to get concentrations over time for prediction features
-#     time_pred, A_pred, B_pred, C_pred, k_pred, k_1_pred, is_reversible_simulated, order_simulated = ode1(A0, B0, C0, temp, Ea, A_factor)
-
-#     # Create a dictionary with all the necessary inputs for the model
-#     inputs = {
-#         'temp': temp,
-#         'pH': pH,
-#         'Ea': Ea,
-#         'A_factor': A_factor,
-#         'pressure': pressure,
-#         'log_pressure': np.log(pressure),
-#         'weight': 150,  # Using a placeholder value as it's not a user input
-#         'structure': structure,
-#         'catalyst': catalyst,
-#         'is_reversible': int(is_reversible),
-#         'k': k_pred, # Use simulated k
-#         'k_1': k_1_pred, # Use simulated k_1
-#         'A0': A_pred[0], 'A1': A_pred[1], 'A2': A_pred[2], 'A3': A_pred[3], 'A4': A_pred[4],
-#         'A5': A_pred[5], 'A6': A_pred[6], 'A7': A_pred[7], 'A8': A_pred[8], 'A9': A_pred[9], 'A10': A_pred[10],
-#         'B0': B_pred[0], 'B1': B_pred[1], 'B2': B_pred[2], 'B3': B_pred[3], 'B4': B_pred[4],
-#         'B5': B_pred[5], 'B6': B_pred[6], 'B7': B_pred[7], 'B8': B_pred[8], 'B9': B_pred[9], 'B10': B_pred[10],
-#         'C0': C_pred[0], 'C1': C_pred[1], 'C2': C_pred[2], 'C3': C_pred[3], 'C4': C_pred[4],
-#         'C5': C_pred[5], 'C6': C_pred[6], 'C7': C_pred[7], 'C8': C_pred[8], 'C9': C_pred[9], 'C10': C_pred[10]
-#     }
-
-#     # --- 2. Prediction ---
-#     with st.spinner('Predicting reaction order...'):
-#         predicted_order = predict_order(inputs)
-#     st.success(f"✅ Predicted Order: **{predicted_order}**")
-
-#     # --- 3. Simulation with ode2 and Predicted Order ---
-#     with st.spinner('Simulating reaction...'):
-#         time_sim, A_sim, B_sim, C_sim, k_sim, k_1_sim = ode2(A0, B0, C0, temp, Ea, A_factor, int(is_reversible), predicted_order)
-
-#     # --- 4. Plotting ---
-#     st.header("📊 Concentration vs. Time Plot")
-#     fig, ax = plt.subplots()
-#     ax.plot(time_sim, A_sim, label='A', marker='o') # Add markers to plot points
-#     ax.plot(time_sim, B_sim, label='B', marker='x')
-#     ax.plot(time_sim, C_sim, label='C', marker='s')
-#     ax.set_xlabel('Time')
-#     ax.set_ylabel('Concentration')
-#     ax.set_title(f'Concentration vs. Time (Predicted Order: {predicted_order})')
-#     ax.legend()
-#     ax.grid(True)
-
-#     st.pyplot(fig)
-
-# st.markdown("---")
-# st.markdown("App created with ❤️ by Mujtaba , Muzammil , Taha and Ali Zain.")
-
 # !streamlit run /content/app.py &>/content/logs.txt &  #this starts the loca server
 
+# get_ipython().run_line_magic('shell', 'curl https://loca.lt/mytunnelpassword') #getting ur home pass 🥶
+
 # !npx localtunnel --port 8501 #the tunnel
 
-# get_ipython().run_line_magic('shell', 'curl https://loca.lt/mytunnelpassword') #getting ur home ip adress  :cold:
 
-# %%writefile requirements.txt
-# gradio
-# pandas
-# numpy
-# matplotlib
-# scipy
-# tensorflow==2.15
-# scikit-learn
+