Create app.py

app.py

@@ -0,0 +1,110 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import tensorflow as tf
+from sklearn.datasets import make_moons, make_circles, make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from tensorflow import keras
+import plotly.graph_objects as go
+import plotly.figure_factory as ff
+
+
+# Sidebar: Neural Network Settings
+st.sidebar.header("Neural Network Settings")
+problem_type = st.sidebar.selectbox("Problem type", ["Classification", "Regression"])
+dataset_choice = st.sidebar.selectbox("Dataset", ["Moons", "Circles", "Linear"])
+train_ratio = st.sidebar.slider("Training Data Ratio", 0.1, 0.9, 0.5, 0.05)
+noise = st.sidebar.slider("Noise Level", 0.0, 0.5, 0.1, 0.01)
+batch_size = st.sidebar.slider("Batch Size", 5, 100, 10, 5)
+hidden_layers = st.sidebar.slider("Hidden Layers", 1, 5, 2)
+neurons_per_layer = st.sidebar.slider("Neurons per Hidden Layer", 2, 10, 4)
+activation_function = st.sidebar.selectbox("Activation Function", ["relu", "sigmoid", "tanh"])
+learning_rate = st.sidebar.slider("Learning Rate", 0.001, 0.1, 0.03, step=0.001)
+regularization = st.sidebar.selectbox("Regularization", ["None", "L1", "L2"])
+reg_rate = st.sidebar.slider("Regularization Rate", 0.0, 0.1, 0.0, step=0.01)
+epochs = st.sidebar.slider("Epochs", 10, 500, 100)
+
+# Generate Dataset
+if dataset_choice == "Moons":
+    X, y = make_moons(n_samples=1000, noise=noise, random_state=42)
+elif dataset_choice == "Circles":
+    X, y = make_circles(n_samples=1000, noise=noise, factor=0.5, random_state=42)
+else:
+    X, y = make_classification(n_samples=1000, n_features=2, n_classes=2, n_redundant=0, random_state=42)
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=1-train_ratio, random_state=42)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# Build Neural Network
+model = keras.Sequential([keras.layers.InputLayer(input_shape=(2,))])
+reg = None
+if regularization == "L1":
+    reg = keras.regularizers.l1(reg_rate)
+elif regularization == "L2":
+    reg = keras.regularizers.l2(reg_rate)
+for _ in range(hidden_layers):
+    model.add(keras.layers.Dense(neurons_per_layer, activation=activation_function, kernel_regularizer=reg))
+model.add(keras.layers.Dense(1, activation="sigmoid"))
+
+optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
+model.compile(optimizer=optimizer, loss="binary_crossentropy", metrics=["accuracy"])
+
+# Train the model
+history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(X_test, y_test))
+
+# Training Progress Visualization
+st.subheader("Training Progress")
+fig, ax = plt.subplots(1, 2, figsize=(12, 4))
+ax[0].plot(history.history['loss'], label="Train Loss")
+ax[0].plot(history.history['val_loss'], label="Validation Loss")
+ax[0].set_title("Loss Curve")
+ax[0].legend()
+ax[1].plot(history.history['accuracy'], label="Train Accuracy")
+ax[1].plot(history.history['val_accuracy'], label="Validation Accuracy")
+ax[1].set_title("Accuracy Curve")
+ax[1].legend()
+st.pyplot(fig)
+
+# Neural Network Visualization
+st.subheader("Neural Network Structure")
+fig = go.Figure()
+layer_x_positions = [0] + [i * 2 for i in range(1, hidden_layers + 1)] + [hidden_layers * 2 + 2]
+layer_names = ["Input Layer"] + [f"Hidden Layer {i+1}" for i in range(hidden_layers)] + ["Output Layer"]
+for i, x in enumerate(layer_x_positions):
+    y_positions = np.linspace(-1, 1, neurons_per_layer if i != 0 and i != len(layer_x_positions) - 1 else 2)
+    fig.add_trace(go.Scatter(
+        x=[x] * len(y_positions), y=y_positions, mode='markers+text',
+        marker=dict(size=20, color='blue'),
+        text=[f"N{j+1}" for j in range(len(y_positions))], textposition="middle right", name=layer_names[i]
+    ))
+for i in range(len(layer_x_positions) - 1):
+    prev_y_positions = np.linspace(-1, 1, neurons_per_layer if i != 0 else 2)
+    next_y_positions = np.linspace(-1, 1, neurons_per_layer if i + 1 != len(layer_x_positions) - 1 else 1)
+    for y1 in prev_y_positions:
+        for y2 in next_y_positions:
+            fig.add_trace(go.Scatter(
+                x=[layer_x_positions[i], layer_x_positions[i + 1]],
+                y=[y1, y2], mode='lines', line=dict(color='gray', width=2), showlegend=False
+            ))
+st.plotly_chart(fig, use_container_width=True)
+
+# Decision Boundary Plot
+def plot_decision_boundary(model, X, y):
+    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
+    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
+    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),
+                         np.linspace(y_min, y_max, 100))
+
+    Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
+    Z = (Z > 0.5).astype(int).reshape(xx.shape)
+
+    plt.contourf(xx, yy, Z, alpha=0.3)
+    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors="k")
+    plt.title("Decision Boundary")
+    st.pyplot(plt)
+
+st.subheader("Decision Boundary")
+plot_decision_boundary(model, X_test, y_test)