Update app.py

app.py

@@ -1,293 +1,170 @@
-# Import necessary libraries
-import streamlit as st
-import numpy as np
-import plotly.graph_objects as go
-import math
-
-# Full-page layout
-st.set_page_config(layout="wide", page_title="Gradient Descent Visualizer")
-
-# Main Title
-st.title("")
-st.title("Gradient Descent Visualizer")
-
-# CSS for full-page layout and styling (no scrollbars)
-st.markdown("""
-    <style>
-        body {
-            font-family: 'serif';  /* Serif font for a mathematical feel */
-            background-color: #161748;  /* Dark background */
-            color: white;
-            width:100%:
-            height:100%;
-            overflow: hidden;  /* Hide scrollbars */
-        }
-        .block-container {
-            padding: 1rem; /* Padding for page container */
-            margin: 0; /* Remove margin */
-            max-width: 100%; /* Full page width */
-        }
-        .stButton>button {
-            background-color: #000000;
-            color: #ff5e6c;
-            border-radius: 8px;
-            border: 2px solid #dbb6ee;
-        }
-        .stTextInput>div>div>input {
-            color: white;
-            background-color: #161748;
-            # border: 2px solid #dbb6ee;
-            border-radius: 8px;
-        }
-        .stNumberInput>div>div>input {
-            color: white;
-            background-color: #161748;
-            border: 2px solid #dbb6ee;
-            border-radius: 8px;
-        }
-        .stPlotlyChart {
-            border: 2px solid #dbb6ee;
-            border-radius: 15px;
-            margin: 0;
-            padding: 0;
-        }
-        .iteration-info {
-            color: black;
-            font-size: 18px;
-            font-weight: bold;
-            background-color: #39a0ca;
-            padding: 6px;
-            border-radius: 8px;
-            display: inline-block;
-        }
-    </style>
-""", unsafe_allow_html=True)
-
-# Divide the layout into two columns
-left_col, right_col = st.columns(2)
-
-# Left column for inputs and buttons
-with left_col:
-    st.markdown("<div class='component-container'></div>", unsafe_allow_html=True)  # Border for input section
-    st.markdown("## Function")
-    
-    if 'text_input_value' not in st.session_state:
-        st.session_state.text_input_value = "x**2 + 3*x + 5"
-
-    # Function buttons
-    st.write("Functions you should try (click to auto format):")
-    col1, col2, col3, col4, col5 = st.columns(5)
-    with col1:
-        if st.button("x^2", key="x2"):
-            st.session_state.text_input_value = "x**2"
-    with col2:
-        if st.button("x^3", key="x3"):
-            st.session_state.text_input_value = "x**3"
-    with col3:
-        if st.button("sin(x)", key="sinx"):
-            st.session_state.text_input_value = "math.sin(x)"
-    with col4:
-        if st.button("sin(1/x)", key="sin1x"):
-            st.session_state.text_input_value = "math.sin(1/x)"
-    with col5:
-        if st.button("log(x)", key="logx"):
-            st.session_state.text_input_value = "math.log(x)"
-
-    # Custom function input
-    st.text_input("## Enter a function of your choice :", value=st.session_state.text_input_value, key="text_input")
-
-    # Starting point input
-    start_point = st.number_input("## Start point :", value=2)
-
-    # Learning rate input
-    learn_rate = st.number_input("## Learning Rate (η) :", value=0.25)
-
-    # Setup button
-    if st.button("Set Up"):
-        st.session_state.iteration = 0
-        st.session_state.theta_history = [start_point]
-        st.session_state.current_fn = st.session_state.text_input_value
-        st.write("Setup complete! Click 'Next Iteration' to start.")
-
-# Gradient descent function with error handling
-def gradient_descent(fn, start_point, learning_rate, num_iterations):
-    theta = start_point
-    theta_history = [theta]
-
-    # Define function gradients manually
-    def get_gradient(fn, x):
-        epsilon = 1e-6
-        try:
-            if "x**2" in fn:
-                return 2 * x  # derivative of x^2
-            elif "x**3" in fn:
-                return 3 * x**2  # derivative of x^3
-            elif "sin(x)" in fn:
-                return math.cos(x)  # derivative of sin(x)
-            elif "sin(1/x)" in fn:
-                return -math.cos(1/x) / (x**2)  # derivative of sin(1/x)
-            elif "log(x)" in fn:
-                return 1 / x  # derivative of log(x)
-            else:
-                return 0  # default to 0 if function is unsupported
-        except:
-            return 0  # Handle undefined behavior
-
-    for _ in range(num_iterations):
-        gradient = get_gradient(fn, theta)
-        theta = theta - learning_rate * gradient
-        if abs(theta) > 1e10:
-            theta = np.sign(theta) * 1e10
-        theta_history.append(theta)
-
-    return theta_history
-
-def plot(fn, theta_history, iteration):
-    # Convert history to float values
-    theta_history = [float(theta) for theta in theta_history]
-    if not theta_history:
-        st.write("No iterations yet. Please click 'Next Iteration'.")
-        return
-
-    x = np.linspace(-10, 10, 100)
-    y = []
-
-    # Handle edge cases for invalid function evaluations
-    for i in x:
-        try:
-            if "x**2" in fn:
-                y.append(i**2)
-            elif "x**3" in fn:
-                y.append(i**3)
-            elif "sin(x)" in fn:
-                y.append(math.sin(i))
-            elif "sin(1/x)" in fn:
-                if i != 0:
-                    y.append(math.sin(1/i))
-                else:
-                    y.append(np.nan)
-            elif "log(x)" in fn:
-                if i > 0:
-                    y.append(math.log(i))
-                else:
-                    y.append(np.nan)
-            else:
-                y.append(np.nan)
-        except:
-            y.append(np.nan)
-
-    # Remove NaN values from x and y
-    x_valid = x[~np.isnan(y)]
-    y_valid = np.array(y)[~np.isnan(y)]
-
-    last_theta = theta_history[-1]
-    meeting_y = None
-    try:
-        meeting_y = eval(fn.replace('x', str(last_theta))) if 'x' in fn else 0
-    except:
-        pass
-
-    # Numerical derivative using central difference
-    epsilon = 1e-6
-    try:
-        derivative = (eval(fn.replace('x', str(last_theta + epsilon))) - eval(fn.replace('x', str(last_theta - epsilon)))) / (2 * epsilon)
-    except:
-        derivative = 0
-    slope = derivative
-    intercept = meeting_y - slope * last_theta if meeting_y is not None else 0
-    tangent_y = slope * x_valid + intercept
-
-    fig = go.Figure(data=[ 
-        # Function Line
-        go.Scatter(x=x_valid, y=y_valid, mode='lines', name='Function', 
-                   line=dict(color='blue')),
-        # Gradient Descent Points
-        go.Scatter(x=theta_history, 
-                   y=[eval(fn.replace('x', str(theta))) for theta in theta_history], 
-                   mode='markers', name='Gradient Descent',
-                   marker=dict(color='red', size=10)),  # All points are red
-        # Tangent Line
-        go.Scatter(x=x_valid, y=tangent_y, mode='lines', name='Tangent', 
-                   line=dict(color='orange')),
-        # Tangent Point (Red)
-        go.Scatter(x=[last_theta], y=[meeting_y], mode='markers', name='Tangent Point',
-                   marker=dict(color='red', size=12))
-    ])
-
-    # Update layout for styling
-    fig.update_layout(
-        annotations=[
-            dict(
-                xref='paper', yref='paper', x=0.05, y=0.1,
-                xanchor='left', yanchor='bottom',
-                text=f"<b>Next Iteration: {iteration}</b>",
-                showarrow=False,
-                font=dict(size=20, color='black'),
-                bgcolor="#f95d9b", borderpad=5, bordercolor="black", borderwidth=2
-            ),
-            dict(
-                xref='paper', yref='paper', x=1, y=0,
-                xanchor='right', yanchor='bottom',
-                text=f"Current Point: ({last_theta:.6f}, {meeting_y if meeting_y is not None else 'N/A'})",
-                showarrow=False,
-                font=dict(size=14, color='black'),
-                bgcolor="#39a0ca", borderpad=5, bordercolor="black", borderwidth=2
-            )
-        ],
-        xaxis_title='x-axis',
-        yaxis_title='y-axis',
-        hovermode='x unified',
-        xaxis=dict(
-            range=[-10, 10], 
-            showgrid=True, gridcolor='black', 
-            titlefont=dict(color='black'),
-            tickfont=dict(color='black')  # Make x-axis numbers black
-        ),
-        yaxis=dict(
-            range=[-10, 10], 
-            showgrid=True, gridcolor='black', 
-            titlefont=dict(color='black'),
-            tickfont=dict(color='black')  # Make y-axis numbers black
-        ),
-        paper_bgcolor='white',  # White background
-        plot_bgcolor='white',   # White plot background
-        legend=dict(
-            yanchor='top', xanchor='right', x=1, y=0.99, 
-            font=dict(color='black')
-        ),
-        title="Gradient Descent Visualization", titlefont=dict(color='black')
-    )
-
-    # Display the plot
-    st.plotly_chart(fig, use_container_width=True, config={'displayModeBar': False})
-
-    return last_theta, meeting_y
-
-def main():
-    with right_col:
-        if 'iteration' not in st.session_state:
-            st.session_state.iteration = 0
-            st.session_state.theta_history = [start_point]
-            st.session_state.current_fn = st.session_state.text_input_value
-
-        theta_history = st.session_state.theta_history
-        iteration = st.session_state.iteration
-        current_fn = st.session_state.current_fn
-
-        if st.button("Next Iteration", key="next_iter"):
-            iteration += 1
-            theta_history = gradient_descent(current_fn, start_point, learn_rate, iteration)
-            st.session_state.iteration = iteration
-            st.session_state.theta_history = theta_history
-
-        # Plot the function and gradient descent
-        last_theta, meeting_y = plot(current_fn, theta_history, iteration)
-        
-        # Display iteration and point details
-        st.markdown(f"## Iteration: {int(iteration)}")
-        st.markdown(f"The tangent is meeting the plot at point **({last_theta}, {meeting_y if meeting_y is not None else 'N/A'})**")
-
-# Run the app
-if __name__ == "__main__":
-    main()
-
+Rohith Ramdass
+rohith.r18
+Idle
+
+Kande Chandrika_IN1241221 — Today at 14:47
+hi
+Rohith Ramdass — Today at 14:48
+hi
+Kande Chandrika_IN1241221 — Today at 14:48
+wr r u
+Rohith Ramdass — Today at 14:48
+i can se u
+Kande Chandrika_IN1241221 — Today at 14:48
+can u send ur space with code also
+Rohith Ramdass — Today at 14:48
+there u have place?
+Kande Chandrika_IN1241221 — Today at 14:48
+haa
+Rohith Ramdass — Today at 14:49
+cmg
+Kande Chandrika_IN1241221 — Today at 14:49
+ok
+Rohith Ramdass — Today at 15:18
+import cv2
+import numpy as np
+
+# Create a window and set its callback function
+cv2.namedWindow('Painting')
+cv2.setMouseCallback('Painting', lambda event, x, y, flags, param: mouse_event(event, x, y, flags, param))
+Expand
+message.txt
+4 KB
+Rohith Ramdass — Today at 15:33
+import streamlit as st
+
+# Title
+st.title("Machine Learning Project")
+
+# header
+Expand
+app1.py
+4 KB
+Kande Chandrika_IN1241221 — Today at 20:29
+import streamlit as st
+import numpy as np
+import plotly.graph_objects as go
+
+# Title of the app
+st.title("Gradient Descent Visualizer with Tangent Lines")
+Expand
+message.txt
+5 KB
+Rohith Ramdass — Today at 20:43
+Thanks
+
+Kande Chandrika_IN1241221
+k.chandrika.
+import streamlit as st
+import numpy as np
+import plotly.graph_objects as go
+
+# Title of the app
+st.title("Gradient Descent Visualizer with Tangent Lines")
+
+# Safe function evaluation
+def safe_eval(func_str, x_val):
+    """ Safely evaluates the function at a given x value. """
+    allowed_names = {"x": x_val, "np": np}  # Only allow x and numpy
+    return eval(func_str, {"__builtins__": None}, allowed_names)
+
+# Function derivative using finite difference method
+def derivative(func_str, x_val, h=1e-5):
+    """ Numerically compute the derivative of the function at x using finite differences. """
+    return (safe_eval(func_str, x_val + h) - safe_eval(func_str, x_val - h)) / (2 * h)
+
+# Tangent Line Equation
+def tangent_line(func_str, x_val, x_range):
+    """ Compute the tangent line at a given x value. """
+    y_val = safe_eval(func_str, x_val)
+    slope = derivative(func_str, x_val)
+    return slope * (x_range - x_val) + y_val
+
+# Callback to reset session state
+def reset_state():
+    st.session_state.x = st.session_state.starting_point
+    st.session_state.iteration = 0
+    st.session_state.x_vals = [st.session_state.starting_point]
+    st.session_state.y_vals = [safe_eval(st.session_state.func_input, st.session_state.starting_point)]
+
+# Function input
+st.header("Define Your Function")
+func_input = st.text_input("Enter a function of 'x' (e.g., x**2 + x, sin(x), x**3 - 3*x + 2):", "x**2 + x", key="func_input", on_change=reset_state)
+
+# Starting Point and Learning Rate
+st.header("Gradient Descent Parameters")
+starting_point = st.number_input("Starting Point", value=4.0, step=0.1, format="%.2f", key="starting_point", on_change=reset_state)
+learning_rate = st.number_input("Learning Rate", value=0.1, step=0.01, format="%.2f", key="learning_rate", on_change=reset_state)
+
+# Initialize session state variables if they don't exist
+if "x" not in st.session_state:
+    st.session_state.x = starting_point
+    st.session_state.iteration = 0
+    st.session_state.x_vals = [starting_point]
+    st.session_state.y_vals = [safe_eval(func_input, starting_point)]
+
+# "Next Iteration" button logic
+if st.button("Next Iteration"):
+    try:
+        # Perform one iteration of gradient descent
+        grad = derivative(func_input, st.session_state.x)
+        st.session_state.x = st.session_state.x - learning_rate * grad
+        st.session_state.iteration += 1
+
+        # Save the new x and y values
+        st.session_state.x_vals.append(st.session_state.x)
+        st.session_state.y_vals.append(safe_eval(func_input, st.session_state.x))
+    except Exception as e:
+        st.error(f"Error: {str(e)}")
+
+# Display iteration results
+st.subheader("Gradient Descent Progress")
+st.write(f"Iteration: {st.session_state.iteration}")
+st.write(f"Current x: {st.session_state.x:.4f}")
+st.write(f"Current f(x): {st.session_state.y_vals[-1]:.4f}")
+
+# Plot the function, gradient descent points, and tangent line
+x_plot = np.linspace(-10, 10, 400)
+y_plot = [safe_eval(func_input, x) for x in x_plot]
+
+fig = go.Figure()
+
+# Add the function curve
+fig.add_trace(go.Scatter(x=x_plot, y=y_plot, mode="lines", name="Function"))
+
+# Add gradient descent points in red
+fig.add_trace(go.Scatter(
+    x=st.session_state.x_vals,
+    y=st.session_state.y_vals,
+    mode="markers",
+    marker=dict(color="red", size=8),
+    name="Gradient Descent Points"
+))
+
+# Add the tangent line at the current point
+current_x = st.session_state.x
+current_y = safe_eval(func_input, current_x)
+slope = derivative(func_input, current_x)
+
+# Generate tangent line range
+tangent_x = np.linspace(current_x - 2, current_x + 2, 100)
+tangent_y = tangent_line(func_input, current_x, tangent_x)
+
+# Plot the tangent line as a straight solid line
+fig.add_trace(go.Scatter(
+    x=tangent_x,
+    y=tangent_y,
+    mode="lines",
+    line=dict(color="orange", width=3),
+    name="Tangent Line"
+))
+
+# Update layout
+fig.update_layout(
+    xaxis_title="x",
+    yaxis_title="f(x)",
+    title="Gradient Descent Visualization with Tangent Line"
+)
+
+# Display the plot
+st.plotly_chart(fig)