Update pages/5_RealDataSetRegression.py

pages/5_RealDataSetRegression.py

@@ -1,107 +1,115 @@
 import streamlit as st
 import numpy as np
 import pandas as pd
-import tensorflow as tf
-from matplotlib import pyplot as plt
-
-# Function to build the model
-def build_model(my_learning_rate):
-    model = tf.keras.models.Sequential()
-    model.add(tf.keras.layers.Dense(units=1, input_shape=(1,)))
-    model.compile(optimizer=tf.keras.optimizers.RMSprop(learning_rate=my_learning_rate),
-                  loss='mean_squared_error',
-                  metrics=[tf.keras.metrics.RootMeanSquaredError()])
-    return model
-
-# Function to train the model
-def train_model(model, df, feature, label, epochs, batch_size):
-    history = model.fit(x=df[feature], y=df[label], batch_size=batch_size, epochs=epochs)
-    trained_weight = model.get_weights()[0][0]
-    trained_bias = model.get_weights()[1]
-    epochs = history.epoch
-    hist = pd.DataFrame(history.history)
-    rmse = hist["root_mean_squared_error"]
-    return trained_weight, trained_bias, epochs, rmse
-
-# Function to plot the model
-def plot_the_model(trained_weight, trained_bias, feature, label, df):
-    plt.figure(figsize=(10, 6))
-    plt.xlabel(feature)
-    plt.ylabel(label)
-
-    random_examples = df.sample(n=200)
-    plt.scatter(random_examples[feature], random_examples[label])
-
-    x0 = 0
-    y0 = trained_bias
-    x1 = random_examples[feature].max()
-    y1 = trained_bias + (trained_weight * x1)
-    plt.plot([x0, x1], [y0, y1], c='r')
-
-    st.pyplot(plt)
-
-# Function to plot the loss curve
-def plot_the_loss_curve(epochs, rmse):
-    plt.figure(figsize=(10, 6))
-    plt.xlabel("Epoch")
-    plt.ylabel("Root Mean Squared Error")
-
-    plt.plot(epochs, rmse, label="Loss")
-    plt.legend()
-    plt.ylim([rmse.min()*0.97, rmse.max()])
-    st.pyplot(plt)
-
-# Load the dataset
-@st.cache_data
-def load_data():
-    url = "https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv"
-    df = pd.read_csv(url)
-    df["median_house_value"] /= 1000.0
-    return df
-
-training_df = load_data()
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import accuracy_score, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.utils import plot_model
+import io
+
+# Load Iris dataset
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+# Only use the first two classes for binary classification
+X = X[y != 2]
+y = y[y != 2]
+
+# Split the dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Standardize the data
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
 
 # Streamlit interface
-st.title("Simple Linear Regression with Real Data")
+st.title('Logistic Regression with Keras on Iris Dataset')
+st.write("""
+## Introduction
+Logistic Regression is a statistical model used for binary classification tasks. 
+In this tutorial, we will use the Iris dataset to classify whether a flower is 
+**Setosa** or **Versicolor** based on its features.
+""")
+
+# Display Iris dataset information
+st.write("### Iris Dataset")
+st.write("""
+The Iris dataset contains 150 samples of iris flowers, each described by four features: 
+sepal length, sepal width, petal length, and petal width. There are three classes: Setosa, Versicolor, and Virginica.
+For this example, we'll only use the Setosa and Versicolor classes.
+""")
+st.write(pd.DataFrame(X, columns=iris.feature_names).head())
+
+# Plotting sample data
+st.write("### Sample Data Distribution")
+fig, ax = plt.subplots()
+for i, color in zip([0, 1], ['blue', 'orange']):
+    idx = np.where(y == i)
+    ax.scatter(X[idx, 0], X[idx, 1], c=color, label=iris.target_names[i], edgecolor='k')
+ax.set_xlabel(iris.feature_names[0])
+ax.set_ylabel(iris.feature_names[1])
+ax.legend()
+st.pyplot(fig)
+
+# User input for number of epochs
+epochs = st.slider('Select number of epochs for training:', min_value=10, max_value=200, value=100, step=10)
+
+# Build the logistic regression model using Keras
+model = Sequential()
+model.add(Dense(1, input_dim=4, activation='sigmoid'))
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# Display the model architecture
+st.write("### Model Architecture")
+st.write(model.summary())
+fig, ax = plt.subplots()
+buf = io.BytesIO()
+plot_model(model, to_file=buf, show_shapes=True, show_layer_names=True)
+buf.seek(0)
+st.image(buf, caption='Logistic Regression Model Architecture', use_column_width=True)
+
+# Train the model
+model.fit(X_train, y_train, epochs=epochs, verbose=0)
+
+# Predict and evaluate the model
+y_pred_train = (model.predict(X_train) > 0.5).astype("int32")
+y_pred_test = (model.predict(X_test) > 0.5).astype("int32")
+
+train_accuracy = accuracy_score(y_train, y_pred_train)
+test_accuracy = accuracy_score(y_test, y_pred_test)
+
+conf_matrix = confusion_matrix(y_test, y_pred_test)
+
+st.write('## Model Performance')
+st.write(f'Training Accuracy: {train_accuracy:.2f}')
+st.write(f'Testing Accuracy: {test_accuracy:.2f}')
+
+st.write('## Confusion Matrix')
+fig, ax = plt.subplots()
+ax.matshow(conf_matrix, cmap=plt.cm.Blues, alpha=0.3)
+for i in range(conf_matrix.shape[0]):
+    for j in range(conf_matrix.shape[1]):
+        ax.text(x=j, y=i, s=conf_matrix[i, j], va='center', ha='center')
+
+plt.xlabel('Predicted Label')
+plt.ylabel('True Label')
+st.pyplot(fig)
+
+st.write('## Make a Prediction')
+sepal_length = st.number_input('Sepal Length (cm)', min_value=0.0, max_value=10.0, value=5.0)
+sepal_width = st.number_input('Sepal Width (cm)', min_value=0.0, max_value=10.0, value=3.5)
+petal_length = st.number_input('Petal Length (cm)', min_value=0.0, max_value=10.0, value=1.4)
+petal_width = st.number_input('Petal Width (cm)', min_value=0.0, max_value=10.0, value=0.2)
+
+if st.button('Predict'):
+    input_data = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
+    input_data_scaled = scaler.transform(input_data)
+    prediction = (model.predict(input_data_scaled) > 0.5).astype("int32")
+    st.write(f'Prediction: {"Setosa" if prediction[0][0] == 0 else "Versicolor"}')
 
-st.write("https://colab.research.google.com/github/google/eng-edu/blob/main/ml/cc/exercises/linear_regression_with_a_real_dataset.ipynb?utm_source=mlcc&utm_campaign=colab-external&utm_medium=referral&utm_content=linear_regression_real_tf2-colab&hl=en")
-
-if st.checkbox('Show raw data'):
-    st.write(training_df.head())
-
-learning_rate = st.sidebar.slider('Learning Rate', min_value=0.001, max_value=1.0, value=0.01, step=0.01)
-epochs = st.sidebar.slider('Epochs', min_value=1, max_value=1000, value=30, step=1)
-batch_size = st.sidebar.slider('Batch Size', min_value=1, max_value=len(training_df), value=30, step=1)
-feature = st.sidebar.selectbox('Select Feature', training_df.columns)
-label = 'median_house_value'
-
-my_model = None  # Initialize the model variable
-
-if st.sidebar.button('Run'):
-    my_model = build_model(learning_rate)
-    weight, bias, epochs, rmse = train_model(my_model, training_df, feature, label, epochs, batch_size)
-
-    st.subheader('Model Plot')
-    plot_the_model(weight, bias, feature, label, training_df)
-
-    st.subheader('Loss Curve')
-    plot_the_loss_curve(epochs, rmse)
-
-# Function to make predictions
-def predict_house_values(n, feature, label):
-    batch = training_df[feature][10000:10000 + n]
-    predicted_values = my_model.predict_on_batch(x=batch)
-
-    st.write("feature   label          predicted")
-    st.write("  value   value          value")
-    st.write("          in thousand$   in thousand$")
-    st.write("--------------------------------------")
-    for i in range(n):
-        st.write("%5.0f %6.0f %15.0f" % (training_df[feature][10000 + i],
-                                        training_df[label][10000 + i],
-                                        predicted_values[i][0] ))
-
-n_predictions = st.sidebar.slider('Number of Predictions', min_value=1, max_value=100, value=10)
-if my_model is not None and st.sidebar.button('Predict'):
-    st.subheader('Predictions')
-    predict_house_values(n_predictions, feature, label)