Spaces:
Sleeping
Sleeping
File size: 3,443 Bytes
1fbfe32 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 |
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)
|