Create app.py

app.py

@@ -0,0 +1,91 @@
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import tensorflow as tf
+from tensorflow import keras
+from sklearn.datasets import make_circles
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+import seaborn as sns
+import networkx as nx
+
+def generate_data():
+    X, y = make_circles(n_samples=500, factor=0.5, noise=0.05, random_state=42)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=42)
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_test = scaler.transform(X_test)
+    return X_train, X_test, y_train, y_test
+
+def build_model(layers=[4, 2], activation='tanh', learning_rate=0.03):
+    model = keras.Sequential()
+    model.add(keras.layers.InputLayer(input_shape=(2,)))
+    
+    for units in layers:
+        model.add(keras.layers.Dense(units, activation=activation))
+    
+    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'])
+    return model
+
+def plot_decision_boundary(model, X, y):
+    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
+    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
+    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
+    grid = np.c_[xx.ravel(), yy.ravel()]
+    preds = model.predict(grid).reshape(xx.shape)
+    
+    plt.figure(figsize=(8, 6))
+    plt.contourf(xx, yy, preds, alpha=0.3)
+    plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', edgecolor='k')
+    plt.xlabel('X1')
+    plt.ylabel('X2')
+    plt.title('Decision Boundary')
+    st.pyplot(plt)
+
+def plot_network(layers):
+    G = nx.DiGraph()
+    layer_sizes = [2] + layers + [1]
+    
+    pos = {}
+    node_idx = 0
+    for i, size in enumerate(layer_sizes):
+        for j in range(size):
+            pos[node_idx] = (i, -j)
+            node_idx += 1
+    
+    node_idx = 0
+    for i in range(len(layer_sizes) - 1):
+        for j in range(layer_sizes[i]):
+            for k in range(layer_sizes[i+1]):
+                G.add_edge(node_idx + j, node_idx + layer_sizes[i] + k)
+        node_idx += layer_sizes[i]
+    
+    plt.figure(figsize=(8, 6))
+    nx.draw(G, pos, with_labels=False, node_size=500, edge_color='gray')
+    st.pyplot(plt)
+
+st.title("TensorFlow Playground Replica with Streamlit")
+
+layers = st.sidebar.text_input("Network Shape (comma-separated)", "4,2")
+layers = list(map(int, layers.split(',')))
+activation = st.sidebar.selectbox("Activation Function", ['tanh', 'relu', 'sigmoid'])
+learning_rate = st.sidebar.slider("Learning Rate", 0.001, 0.1, 0.03, step=0.001)
+batch_size = st.sidebar.slider("Batch Size", 5, 50, 10, step=5)
+epochs = st.sidebar.slider("Epochs", 10, 100, 50, step=10)
+
+X_train, X_test, y_train, y_test = generate_data()
+
+model = build_model(layers, activation, learning_rate)
+model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0)
+
+plot_decision_boundary(model, X_test, y_test)
+
+st.write("## Model Performance")
+loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
+st.write(f"Test Accuracy: {accuracy:.4f}")
+
+st.write("## Neural Network Structure")
+plot_network(layers)