Skip to content
The Chat Archive
gemini-2.5-pro-preview-05-06· Google LMArena Human Preference 140K

Code a python program that uses machine learning. The program should actively show the…

  1. User

    Code a python program that uses machine learning. The program should actively show the user the machine's improvements.

  2. Assistant

    Okay, let's create a Python program that uses a simple machine learning model (Linear Regression via Stochastic Gradient Descent) and actively shows its improvement. We'll generate some synthetic data, and then watch the model learn to fit a line to this data, updating a plot at each step.

    What the program will do:

    1. Generate Data: Create a set of (x, y) points that roughly follow a linear relationship y = mx + c + noise.
    2. Initialize Model: Use Scikit-learn's SGDRegressor. We'll configure it to learn iteratively.
    3. Iterative Training & Visualization:
      • In a loop, train the model for one "epoch" (or one pass/step) at a time.
      • After each step, predict the y values using the current state of the model.
      • Calculate the Mean Squared Error (MSE) to quantify the model's performance.
      • Plot the original data points.
      • Plot the line representing the model's current understanding of the data.
      • Display the current epoch number and MSE.
      • Pause briefly so the user can see the plot update.
    4. User Interaction: The user can press Enter to proceed to the next learning step, making it more "active."

    You'll need to install these libraries if you haven't already:

    pip install numpy matplotlib scikit-learn
    

    Here's the Python code:

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.linear_model import SGDRegressor
    from sklearn.metrics import mean_squared_error
    import time
    
    # --- 1. Generate Synthetic Data ---
    print("Generating synthetic data...")
    np.random.seed(42) # for reproducibility
    X = 2 * np.random.rand(100, 1) # 100 samples, 1 feature (e.g., hours studied)
    # True relationship: y = 4 + 3*X + noise
    true_slope = 3
    true_intercept = 4
    y = true_intercept + true_slope * X + np.random.randn(100, 1) # Add some Gaussian noise
    
    # --- 2. Initialize Model ---
    # We use SGDRegressor because it allows for iterative training (partial_fit or fit with warm_start)
    # max_iter=1 and warm_start=True are key for showing step-by-step learning
    model = SGDRegressor(
        max_iter=1,        # Train for only one iteration at a time
        tol=None,          # Don't use tolerance for early stopping in this demo
        warm_start=True,   # Reuse the solution of the previous call to fit as initialization
        penalty=None,      # No regularization for simplicity
        learning_rate='constant', # Use a constant learning rate
        eta0=0.01          # Learning rate (alpha)
    )
    
    # --- 3. Iterative Training & Visualization ---
    num_epochs = 50
    mse_history = []
    
    plt.ion() # Turn on interactive mode for matplotlib
    fig, ax = plt.subplots(figsize=(10, 6))
    
    print("\nStarting interactive training. Press Enter to proceed through epochs.")
    print("Watch the plot update and the MSE decrease.")
    
    for epoch in range(num_epochs):
        # Train for one epoch
        model.fit(X, y.ravel()) # .ravel() to convert y to a 1D array, as scikit-learn expects
    
        # Make predictions with the current model
        y_pred = model.predict(X)
    
        # Calculate Mean Squared Error
        mse = mean_squared_error(y, y_pred)
        mse_history.append(mse)
    
        # --- Visualization ---
        ax.clear() # Clear previous plot
        ax.scatter(X, y, color='blue', label='Actual Data', alpha=0.7)
        ax.plot(X, y_pred, color='red', linewidth=2, label=f'Model Prediction (Epoch {epoch+1})')
    
        # Display current model parameters (slope and intercept)
        current_slope = model.coef_[0] if model.coef_ is not None else "N/A"
        current_intercept = model.intercept_[0] if model.intercept_ is not None else "N/A"
    
        ax.set_title(f"Epoch: {epoch+1}/{num_epochs} | MSE: {mse:.4f}\nModel: y = {current_slope:.2f}x + {current_intercept:.2f}")
        ax.set_xlabel("X (Feature)")
        ax.set_ylabel("Y (Target)")
        ax.legend()
        ax.grid(True)
        plt.draw()
        plt.pause(0.01) # Pause to allow the plot to update
    
        print(f"Epoch {epoch+1:02d}/{num_epochs} - MSE: {mse:.4f} - Learned Slope: {current_slope:.2f}, Intercept: {current_intercept:.2f}")
    
        if epoch < num_epochs - 1:
            try:
                input("Press Enter to continue to the next epoch (or Ctrl+C to stop)...")
            except KeyboardInterrupt:
                print("\nTraining interrupted by user.")
                break
        else:
            print("\nTraining complete!")
            time.sleep(2) # Keep plot open for a bit longer
    
    plt.ioff() # Turn off interactive mode
    
    # --- Final Output ---
    print("\n--- Training Summary ---")
    print(f"True relationship: y = {true_slope}x + {true_intercept}")
    if model.coef_ is not None and model.intercept_ is not None:
        print(f"Learned relationship: y = {model.coef_[0]:.2f}x + {model.intercept_[0]:.2f}")
        print(f"Final Mean Squared Error: {mse_history[-1]:.4f}")
    else:
        print("Model was not sufficiently trained.")
    
    # Plot MSE over epochs
    plt.figure(figsize=(8, 5))
    plt.plot(range(1, len(mse_history) + 1), mse_history, marker='o')
    plt.title("Mean Squared Error (MSE) vs. Epochs")
    plt.xlabel("Epoch")
    plt.ylabel("MSE")
    plt.grid(True)
    plt.show()
    
    print("\nProgram finished.")
    

    How to Run and Observe:

    1. Save the code as a Python file (e.g., interactive_ml.py).
    2. Open your terminal or command prompt.
    3. Navigate to the directory where you saved the file.
    4. Run the script: python interactive_ml.py
    5. A plot window will appear.
    6. In the terminal, you'll be prompted to "Press Enter to continue...".
    7. Each time you press Enter:
      • The model will train for one more step.
      • The red line on the plot will update, hopefully getting closer to the blue data points.
      • The title of the plot will show the current epoch, MSE, and the learned slope/intercept.
      • The terminal will also print this information.
    8. You'll see the MSE generally decrease, indicating the model is learning and improving its fit to the data.
    9. After all epochs, a final plot showing the MSE trend over epochs will be displayed.

    This program provides a clear, visual, and interactive way to see a machine learning model improve its performance over time. The key is the iterative training (max_iter=1, warm_start=True) combined with real-time plotting and user-controlled progression.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.