Update app.py

app.py

@@ -1,94 +1,189 @@
-import streamlit as st
-import numpy as np 
-import sympy as sp
-import plotly.graph_objs as go
+# import streamlit as st
+# import numpy as np 
+# import sympy as sp
+# import plotly.graph_objs as go
 
 
 
-st.title("Gradient Descent Visualizer")
+# st.title("Gradient Descent Visualizer")
 
-x = sp.Symbol("x")
+# x = sp.Symbol("x")
 
-func_input = st.text_input("Enter Function","x^2")
+# func_input = st.text_input("Enter Function","x^2")
 
-start_point = float(st.text_input("Starting Point", "2"))
+# start_point = float(st.text_input("Starting Point", "2"))
+
+# #setup = st.button("Set Up")
+
+# # if setup:
+# #     try:
+# #         expr = func.replace("^", "**")
+# #         expr_final = sp.sympify(expr)
+# #         func = sp.lambdify(x, expr_final, "numpy")
+# #         grad = sp.diff(expr_final,x)
+# #         gradient_func = sp.lambdify(x,grad,"numpy")
+# #     except Exception as e:
+# #         st.error(f"Error parsing function: {e}")
+# expr = func_input.replace("^", "**")
+# expr_final = sp.sympify(expr)
+# func = sp.lambdify(x, expr_final, "numpy")
+# grad = sp.diff(expr_final,x)
+# gradient_func = sp.lambdify(x,grad,"numpy")
+
+# learning_rate = float(st.text_input("Learning Rate","0.01"))
 
-#setup = st.button("Set Up")
 
-# if setup:
+# # Intializing intial session state
+# if 'points' not in st.session_state:
+#     st.session_state.points = [start_point]
+
+# if 'step' not in st.session_state:
+#     st.session_state.step=0
+
+
+# if st.button("Next Iteration"):
+#     lr = learning_rate
+#     x_old = float(st.session_state.points[-1])
+#     grad_val = gradient_func(x_old)
+#     x_new = x_old - lr * grad_val
+#     st.session_state.points.append(x_new)
+#     st.session_state.step +=1
+
+# # Creating the plot
+# if len(st.session_state.points) > 0:
 #     try:
-#         expr = func.replace("^", "**")
-#         expr_final = sp.sympify(expr)
-#         func = sp.lambdify(x, expr_final, "numpy")
-#         grad = sp.diff(expr_final,x)
-#         gradient_func = sp.lambdify(x,grad,"numpy")
+#         x_val = np.linspace(-6,6,500)
+#         y_val = func(x_val)
+#         iter_points = np.array(st.session_state.points)
+#         iter_y = func(iter_points)
+
+#         trace1 = go.Scatter(x=x_val,y=y_val,mode="lines",name="Function", line=dict(color="blue"))
+#         trace2 = go.Scatter(x=iter_points,y=iter_y,mode="markers+lines",name="Gradient Descent Path",marker=dict(color="red"))
+#         trace3 = go.Scatter(x=[iter_points[-1]], y=[iter_y[-1]], mode='markers+text',marker=dict(color='green', size=15),text=[f"{iter_points[-1]:.6f}"],textposition="top center",name="Current Point")
+#         layout = go.Layout(title=f"Iteration {st.session_state.step}",xaxis=dict(title="x - axis"),yaxis=dict(title="y - axis"))
+#         fig = go.Figure(data=[trace1,trace2,trace3],layout=layout)
+#         st.plotly_chart(fig,use_container_width=True)
+#         st.success(f"Current Point = {iter_points[-1]}")
+
 #     except Exception as e:
-#         st.error(f"Error parsing function: {e}")
-expr = func_input.replace("^", "**")
-expr_final = sp.sympify(expr)
-func = sp.lambdify(x, expr_final, "numpy")
-grad = sp.diff(expr_final,x)
-gradient_func = sp.lambdify(x,grad,"numpy")
+#         st.error(f"Plot error: {e}")
 
-learning_rate = float(st.text_input("Learning Rate","0.01"))
+# # if len(st.session_state.points) > 0:
+# #     try:
+# #         x_vals = np.linspace(-10, 10, 300)
+# #         y_vals = func(x_vals)
+# #         iter_points = np.array(st.session_state.points)
+# #         iter_y = func(iter_points)
+
+# #         trace1 = go.Scatter(x=x_vals, y=y_vals, mode='lines', name='Function', line=dict(color='blue'))
+# #         trace2 = go.Scatter(x=iter_points, y=iter_y, mode='markers+lines', name='Gradient Descent Path', marker=dict(color='red'))
+# #         trace3 = go.Scatter(x=[iter_points[-1]], y=[iter_y[-1]], mode='markers+text',
+# #                             marker=dict(color='green', size=10),
+# #                             text=[f"{iter_points[-1]:.6f}"],
+# #                             textposition="top center",
+# #                             name="Current Point")
+
+# #         layout = go.Layout(title=f"Iteration {st.session_state.step}",
+# #                            xaxis=dict(title="x - axis"),
+# #                            yaxis=dict(title="y - axis"))
+
+# #         fig = go.Figure(data=[trace1, trace2, trace3], layout=layout)
+# #         st.plotly_chart(fig, use_container_width=True)
+# #         st.success(f"Current Point = {iter_points[-1]}")
+# #     except Exception as e:
+# #         st.error(f"Plot error: {e}")
 
+import streamlit as st
+import numpy as np 
+import sympy as sp
+import plotly.graph_objs as go
 
-# Intializing intial session state
-if 'points' not in st.session_state:
-    st.session_state.points = [start_point]
+st.title("Gradient Descent Visualizer")
 
-if 'step' not in st.session_state:
-    st.session_state.step=0
+# Define the symbol 'x' for the function
+x = sp.Symbol("x")
 
+# User input for function, starting point, and learning rate
+func_input = st.text_input("Enter Function", "x^2")
+start_point = float(st.text_input("Starting Point", "2"))
+learning_rate = float(st.text_input("Learning Rate", "0.01"))
 
-if st.button("Next Iteration"):
-    lr = learning_rate
-    x_old = float(st.session_state.points[-1])
-    grad_val = gradient_func(x_old)
-    x_new = x_old - lr * grad_val
-    st.session_state.points.append(x_new)
-    st.session_state.step +=1
+# Set up button to initialize the function and gradient
+if st.button("Set Up"):
+    try:
+        # Replace ^ with ** for exponentiation
+        expr = func_input.replace("^", "**")
+        
+        # Parse the function
+        expr_final = sp.sympify(expr)
+        
+        # Lambdify to create callable functions
+        func = sp.lambdify(x, expr_final, "numpy")
+        
+        # Calculate the gradient
+        grad = sp.diff(expr_final, x)
+        gradient_func = sp.lambdify(x, grad, "numpy")
+        
+        # Initialize session state for points and steps
+        if 'points' not in st.session_state:
+            st.session_state.points = [start_point]
+        if 'step' not in st.session_state:
+            st.session_state.step = 0
+            
+        st.success("Function and Gradient Set Up Successfully!")
+    
+    except Exception as e:
+        st.error(f"Error setting up function: {e}")
+
+# Gradient Descent Iteration button
+if 'points' in st.session_state and 'step' in st.session_state:
+    if st.button("Next Iteration"):
+        try:
+            # Get the current point and gradient value
+            x_old = float(st.session_state.points[-1])
+            grad_val = gradient_func(x_old)
+            x_new = x_old - learning_rate * grad_val
+            
+            # Append the new point to the list of points
+            st.session_state.points.append(x_new)
+            st.session_state.step += 1
+
+            st.success(f"Iteration {st.session_state.step} Complete!")
+
+        except Exception as e:
+            st.error(f"Error in iteration: {e}")
 
 # Creating the plot
-if len(st.session_state.points) > 0:
+if 'points' in st.session_state and len(st.session_state.points) > 0:
     try:
-        x_val = np.linspace(-6,6,500)
+        # Create x-values for plotting the function
+        x_val = np.linspace(-6, 6, 500)
         y_val = func(x_val)
+        
+        # Get the points visited by gradient descent
         iter_points = np.array(st.session_state.points)
         iter_y = func(iter_points)
 
-        trace1 = go.Scatter(x=x_val,y=y_val,mode="lines",name="Function", line=dict(color="blue"))
-        trace2 = go.Scatter(x=iter_points,y=iter_y,mode="markers+lines",name="Gradient Descent Path",marker=dict(color="red"))
-        trace3 = go.Scatter(x=[iter_points[-1]], y=[iter_y[-1]], mode='markers+text',marker=dict(color='green', size=15),text=[f"{iter_points[-1]:.6f}"],textposition="top center",name="Current Point")
-        layout = go.Layout(title=f"Iteration {st.session_state.step}",xaxis=dict(title="x - axis"),yaxis=dict(title="y - axis"))
-        fig = go.Figure(data=[trace1,trace2,trace3],layout=layout)
-        st.plotly_chart(fig,use_container_width=True)
+        # Plot the function and the gradient descent path
+        trace1 = go.Scatter(x=x_val, y=y_val, mode="lines", name="Function", line=dict(color="blue"))
+        trace2 = go.Scatter(x=iter_points, y=iter_y, mode="markers+lines", name="Gradient Descent Path", marker=dict(color="red"))
+        trace3 = go.Scatter(x=[iter_points[-1]], y=[iter_y[-1]], mode='markers+text', 
+                            marker=dict(color='green', size=15), 
+                            text=[f"{iter_points[-1]:.6f}"], textposition="top center", 
+                            name="Current Point")
+        
+        # Layout for the plot
+        layout = go.Layout(
+            title=f"Iteration {st.session_state.step}",
+            xaxis=dict(title="x - axis"),
+            yaxis=dict(title="y - axis")
+        )
+        
+        # Create the figure and display it
+        fig = go.Figure(data=[trace1, trace2, trace3], layout=layout)
+        st.plotly_chart(fig, use_container_width=True)
         st.success(f"Current Point = {iter_points[-1]}")
 
     except Exception as e:
         st.error(f"Plot error: {e}")
 
-# if len(st.session_state.points) > 0:
-#     try:
-#         x_vals = np.linspace(-10, 10, 300)
-#         y_vals = func(x_vals)
-#         iter_points = np.array(st.session_state.points)
-#         iter_y = func(iter_points)
-
-#         trace1 = go.Scatter(x=x_vals, y=y_vals, mode='lines', name='Function', line=dict(color='blue'))
-#         trace2 = go.Scatter(x=iter_points, y=iter_y, mode='markers+lines', name='Gradient Descent Path', marker=dict(color='red'))
-#         trace3 = go.Scatter(x=[iter_points[-1]], y=[iter_y[-1]], mode='markers+text',
-#                             marker=dict(color='green', size=10),
-#                             text=[f"{iter_points[-1]:.6f}"],
-#                             textposition="top center",
-#                             name="Current Point")
-
-#         layout = go.Layout(title=f"Iteration {st.session_state.step}",
-#                            xaxis=dict(title="x - axis"),
-#                            yaxis=dict(title="y - axis"))
-
-#         fig = go.Figure(data=[trace1, trace2, trace3], layout=layout)
-#         st.plotly_chart(fig, use_container_width=True)
-#         st.success(f"Current Point = {iter_points[-1]}")
-#     except Exception as e:
-#         st.error(f"Plot error: {e}")