Upload app.py

app.py

@@ -7,7 +7,7 @@ Original file is located at
     https://colab.research.google.com/drive/1GgGC-fVnA0fSxU859NjSi_jH8yiWUKOu
 """
 
-!pip install tensorflow==2.15
+# !pip install tensorflow==2.15
 
 """# Chem simulation using scipy"""
 
@@ -383,7 +383,7 @@ classifier = tf.estimator.DNNClassifier(
 
 classifier.train(
     input_fn=lambda: input_fn(train_normalized, train_y_encoded, training=True),
-    steps=600
+    steps=5000
 )
 
 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
@@ -398,30 +398,6 @@ classifier.evaluate(input_fn=lambda: input_fn(test_normalized,test_y_encoded,tra
 - best ml model predicts the order of the differential equation from that
 """
 
-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]
 
@@ -448,9 +424,57 @@ def ode2(A0, B0, C0, temp, Ea, A_factor, is_reversible, order):
 
   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
+# !pip install gradio
 
 import gradio as gr
 import pandas as pd
@@ -458,34 +482,14 @@ 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):
-    #Data Preparation for Predictio
-    # Simullatqae 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)
+    # --- 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')
 
-    # 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 ---
-    predicted_order = predict_order(inputs)
+    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
@@ -542,104 +546,104 @@ with gr.Blocks() as iface:
     )
 
 
-iface.launch()
+iface.launch(debug=True)
 
 !gradio deploy
 
 """## Streamlit Stuff"""
 
-!pip install -q streamlit
+# !pip install -q streamlit
 
-import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
+# 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.
+# # 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.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. 👇")
+# 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)
+# # 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 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)
+# 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
+# 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)
+# 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]
-    }
+#     # 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}**")
+#     # --- 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)
+#     # --- 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)
+#     # --- 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.pyplot(fig)
 
-st.markdown("---")
-st.markdown("App created with ❤️ using Streamlit")
+# st.markdown("---")
+# st.markdown("App created with ❤️ using Streamlit")
 
 
 
-!npm install -g localtunnel
+# !npm install -g localtunnel
 
 """Main code for Steamlit pipeline