Upload 3 files

README.md

@@ -1,13 +1,16 @@
----
-title: Supervised Learning
-emoji: 📚
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 5.44.0
-app_file: app.py
-pinned: false
-license: mit
----
+# Live Supervised Learning (Linear Regression) — with Loss Curve
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Gradio-app die in real-time laat zien hoe een lineaire regressie leert op een 2D-dataset.
+Deze versie toont **twee live plots**: (1) data + regressielijn en (2) **loss curve (MSE per epoch)**.
+De app start automatisch met trainen bij het openen (geen uploads nodig).
+
+## Lokaal draaien
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Deploy naar Hugging Face Spaces
+1. Maak een nieuwe Space aan → **Gradio** template.
+2. Upload `app.py`, `requirements.txt` en `README.md` (of upload het zip-bestand en pak het uit).
+3. Start de Space. De app begint automatisch met trainen met de standaardwaarden.

app.py

@@ -0,0 +1,153 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn import datasets
+from sklearn.utils import shuffle
+
+# ------------------------------
+# Data helpers
+# ------------------------------
+def load_dataset(name: str, n_samples: int = 200, noise: float = 10.0):
+    """Return (x, y, label) with x,y as 1D numpy arrays for easy plotting."""
+    if name == "Synthetisch":
+        rng = np.random.RandomState(42)
+        X = np.linspace(-3, 3, n_samples)
+        true_w, true_b = 4.0, -2.0
+        y = true_w * X + true_b + rng.normal(0, noise, size=n_samples)
+        return X, y, "Synthetische data (y = 4x - 2 + noise)"
+    elif name == "Diabetes (BMI vs target)":
+        d = datasets.load_diabetes()
+        X = d.data[:, 2]  # BMI feature
+        y = d.target
+        return X, y, "Diabetes: BMI vs. disease progression"
+    elif name == "California Housing (MedInc vs value)":
+        try:
+            ch = datasets.fetch_california_housing()
+            X = ch.data[:, 0]  # MedInc
+            y = ch.target      # MedHouseValue
+            return X, y, "California Housing: MedInc vs. house value"
+        except Exception:
+            X, y, _ = load_dataset("Synthetisch", n_samples=n_samples, noise=noise)
+            return X, y, "(Fallback) Synthetische data"
+    else:
+        raise ValueError("Onbekende dataset")
+
+# ------------------------------
+# Training (SGD) voor y = w*x + b met real-time visualisatie
+# ------------------------------
+def sgd_train_generator(dataset_name, lr, epochs, batch_size, n_samples, noise, seed):
+    rng = np.random.RandomState(int(seed))
+    x, y, label = load_dataset(dataset_name, n_samples=n_samples, noise=noise)
+
+    n = x.shape[0]
+    x = x.astype(np.float64)
+    y = y.astype(np.float64)
+
+    w = 0.0
+    b = 0.0
+
+    x_min, x_max = float(np.min(x)), float(np.max(x))
+    losses = []
+
+    for epoch in range(1, int(epochs) + 1):
+        x, y = shuffle(x, y, random_state=rng)
+
+        for start in range(0, n, int(batch_size)):
+            end = min(start + int(batch_size), n)
+            xb = x[start:end]
+            yb = y[start:end]
+
+            yhat = w * xb + b
+            err = yb - yhat
+            dw = -(2.0 / xb.size) * np.sum(xb * err)
+            db = -(2.0 / xb.size) * np.sum(err)
+
+            w -= lr * dw
+            b -= lr * db
+
+        # Volledige-set MSE
+        y_pred = w * x + b
+        mse = float(np.mean((y - y_pred) ** 2))
+        losses.append(mse)
+
+        # Plot 1: data + regressielijn
+        fig_main = plt.figure(figsize=(6, 4))
+        ax1 = fig_main.add_subplot(111)
+        ax1.scatter(x, y, alpha=0.6, s=18)
+        xs = np.linspace(x_min, x_max, 200)
+        ax1.plot(xs, w * xs + b, linewidth=2)
+        ax1.set_title(f"{label}\nEpoch {epoch}/{epochs} — MSE: {mse:.4f}")
+        ax1.set_xlabel("x")
+        ax1.set_ylabel("y")
+        ax1.grid(True, linestyle=":", linewidth=0.6)
+        plt.tight_layout()
+
+        # Plot 2: loss-curve
+        fig_loss = plt.figure(figsize=(6, 3))
+        ax2 = fig_loss.add_subplot(111)
+        ax2.plot(range(1, len(losses)+1), losses, marker="o", linewidth=1.5)
+        ax2.set_title("Loss (MSE) per epoch")
+        ax2.set_xlabel("Epoch")
+        ax2.set_ylabel("MSE")
+        ax2.grid(True, linestyle=":", linewidth=0.6)
+        plt.tight_layout()
+
+        yield fig_main, fig_loss, f"w = {w:.4f}, b = {b:.4f}, MSE = {mse:.4f}"
+
+# ------------------------------
+# Uitlegtekst
+# ------------------------------
+THEORY_MD = r"""
+### Wat is supervised learning?
+Bij **supervised learning** leer je een model aan de hand van voorbeeldparen (input -> gewenste output). Het doel is een functie te vinden die de relatie tussen input en output goed benadert.
+
+### Lineaire regressie in 1D
+We passen een lijn \( y = w x + b \) aan op data. We minimaliseren de **Mean Squared Error (MSE)**:
+\[ \operatorname{MSE} = \frac{1}{N} \sum_{i=1}^N (y_i - (w x_i + b))^2 \]
+We gebruiken **stochastic gradient descent (SGD)** om \(w\) en \(b\) stapje voor stapje te verbeteren.
+"""
+
+# ------------------------------
+# Gradio UI
+# ------------------------------
+with gr.Blocks(title="Live Supervised Learning: Linear Regression") as demo:
+    gr.Markdown("# Live Supervised Learning — Lineaire Regressie")
+    with gr.Tabs():
+        with gr.TabItem("Uitleg"):
+            gr.Markdown(THEORY_MD)
+        with gr.TabItem("Playground"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    dataset = gr.Dropdown(
+                        ["Synthetisch", "Diabetes (BMI vs target)", "California Housing (MedInc vs value)"],
+                        value="Synthetisch",
+                        label="Dataset"
+                    )
+                    lr = gr.Slider(1e-4, 1e-0, value=1e-2, step=1e-4, label="Learning Rate")
+                    epochs = gr.Slider(1, 200, value=50, step=1, label="Epochs")
+                    batch = gr.Slider(1, 512, value=64, step=1, label="Batchgrootte")
+                    n_samples = gr.Slider(50, 2000, value=300, step=10, label="Aantal samples (synthetisch)")
+                    noise = gr.Slider(0.0, 30.0, value=10.0, step=0.5, label="Noise (synthetisch)")
+                    seed = gr.Slider(0, 9999, value=42, step=1, label="Random seed")
+                    train_btn = gr.Button("Train live")
+                with gr.Column(scale=2):
+                    plot_main = gr.Plot(label="Data & regressielijn (live)")
+                    plot_loss = gr.Plot(label="Loss-curve (MSE per epoch)")
+                    metrics = gr.Markdown()
+
+            # Knoop de generator aan de UI
+            train_btn.click(
+                fn=sgd_train_generator,
+                inputs=[dataset, lr, epochs, batch, n_samples, noise, seed],
+                outputs=[plot_main, plot_loss, metrics]
+            )
+
+            # Auto-train bij het openen
+            demo.load(
+                fn=sgd_train_generator,
+                inputs=[dataset, lr, epochs, batch, n_samples, noise, seed],
+                outputs=[plot_main, plot_loss, metrics]
+            )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.36.0
+matplotlib>=3.7.0
+numpy>=1.23.0
+scikit-learn>=1.2.0