Create app.py

app.py

@@ -0,0 +1,78 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+import streamlit as st
+
+# Function to generate synthetic data
+def generate_data(dataset_type, noise, n_samples=500):
+    np.random.seed(0)
+    if dataset_type == 'moons':
+        from sklearn.datasets import make_moons
+        X, y = make_moons(n_samples=n_samples, noise=noise)
+    elif dataset_type == 'circles':
+        from sklearn.datasets import make_circles
+        X, y = make_circles(n_samples=n_samples, noise=noise, factor=0.5)
+    elif dataset_type == 'linear':
+        X = np.random.randn(n_samples, 2)
+        y = (X[:, 0] > X[:, 1]).astype(int)
+    else:
+        X = np.random.randn(n_samples, 2)
+        y = np.random.randint(0, 2, n_samples)
+    return X, y
+
+# Function to create model
+def create_model(input_shape, hidden_layers, activation, learning_rate, regularization_rate):
+    model = Sequential()
+    model.add(Dense(hidden_layers[0], input_shape=input_shape, activation=activation,
+                    kernel_regularizer=tf.keras.regularizers.l2(regularization_rate)))
+    for units in hidden_layers[1:]:
+        model.add(Dense(units, activation=activation,
+                        kernel_regularizer=tf.keras.regularizers.l2(regularization_rate)))
+    model.add(Dense(1, activation='sigmoid'))
+    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),
+                  loss='binary_crossentropy',
+                  metrics=['accuracy'])
+    return model
+
+# Streamlit UI
+st.title('Interactive Neural Network Visualization')
+st.sidebar.header('Model Parameters')
+
+# Dataset selection
+dataset_type = st.sidebar.selectbox('Select dataset', ['moons', 'circles', 'linear'])
+noise = st.sidebar.slider('Noise level', 0.0, 1.0, 0.2)
+X, y = generate_data(dataset_type, noise)
+split = st.sidebar.slider('Train/Test split ratio', 0.1, 0.9, 0.5)
+split_idx = int(split * len(X))
+X_train, X_test = X[:split_idx], X[split_idx:]
+y_train, y_test = y[:split_idx], y[split_idx:]
+
+# Model parameters
+learning_rate = st.sidebar.slider('Learning rate', 0.001, 0.1, 0.01)
+activation = st.sidebar.selectbox('Activation function', ['relu', 'tanh', 'sigmoid'])
+regularization_rate = st.sidebar.slider('Regularization rate', 0.0, 0.1, 0.01)
+hidden_layers = [st.sidebar.slider('Layer 1 units', 1, 10, 4),
+                 st.sidebar.slider('Layer 2 units', 1, 10, 2)]
+
+# Create and train model
+model = create_model((2,), hidden_layers, activation, learning_rate, regularization_rate)
+history = model.fit(X_train, y_train, epochs=100, verbose=0, validation_split=0.1)
+
+# Evaluation
+train_loss, train_acc = model.evaluate(X_train, y_train, verbose=0)
+test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
+st.write(f'Training loss: {train_loss:.4f}, Training accuracy: {train_acc:.4f}')
+st.write(f'Test loss: {test_loss:.4f}, Test accuracy: {test_acc:.4f}')
+
+# Plot data and decision boundary
+fig, ax = plt.subplots()
+ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap='viridis', marker='o', edgecolor='k', s=50)
+xx, yy = np.meshgrid(np.linspace(X_test[:, 0].min(), X_test[:, 0].max(), 100),
+                     np.linspace(X_test[:, 1].min(), X_test[:, 1].max(), 100))
+Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
+Z = Z.reshape(xx.shape)
+ax.contourf(xx, yy, Z, alpha=0.5, cmap='viridis')
+ax.set_title('Data and Model Decision Boundary')
+st.pyplot(fig)