File size: 5,504 Bytes
4e159ba |
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 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
import streamlit as st
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.utils import shuffle
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
# Function for disease task
def run_disease_task():
# Number of samples per class
N_per_class = 500
# Number of classes
num_classes = 5
# Total number of samples
N = N_per_class * num_classes
# Number of features
D = 2 # For visualization purposes
# Initialize feature matrix X and label vector y
X = np.zeros((N, D))
y = np.zeros(N, dtype=int)
# Generate a multi-class spiral dataset
def generate_multi_class_spiral(points, classes):
X = np.zeros((points * classes, 2))
y = np.zeros(points * classes, dtype=int)
for class_number in range(classes):
ix = range(points * class_number, points * (class_number + 1))
r = np.linspace(0.0, 1, points)
t = np.linspace(class_number * 4, (class_number + 1) * 4, points) + np.random.randn(points) * 0.2
X[ix] = np.c_[r * np.sin(t), r * np.cos(t)]
y[ix] = class_number
return X, y
X, y = generate_multi_class_spiral(N_per_class, num_classes)
# Shuffle the dataset
X, y = shuffle(X, y, random_state=42)
# Normalize the features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Convert data to torch tensors
X_train_tensor = torch.from_numpy(X_scaled).float()
y_train_tensor = torch.from_numpy(y).long()
# Split data into training and test sets
X_train_tensor, X_test_tensor, y_train_tensor, y_test_tensor = train_test_split(
X_train_tensor, y_train_tensor, test_size=0.2, random_state=42
)
# Logistic Regression Model
linear_model = LogisticRegression(max_iter=200)
linear_model.fit(X_scaled[: int(0.8 * N)], y[: int(0.8 * N)])
# Linear model accuracy
linear_accuracy = linear_model.score(X_scaled[int(0.8 * N) :], y[int(0.8 * N) :])
# Neural Network Model
class NeuralNet(nn.Module):
def __init__(self, input_dim, hidden_dims, output_dim):
super(NeuralNet, self).__init__()
layers = []
in_dim = input_dim
for h_dim in hidden_dims:
layers.append(nn.Linear(in_dim, h_dim))
layers.append(nn.ReLU())
layers.append(nn.BatchNorm1d(h_dim))
layers.append(nn.Dropout(0.3))
in_dim = h_dim
layers.append(nn.Linear(in_dim, output_dim))
self.model = nn.Sequential(*layers)
def forward(self, x):
return self.model(x)
# Initialize Neural Network Model
hidden_dims = [128, 64, 32]
neural_model = NeuralNet(D, hidden_dims, num_classes)
# Loss and optimizer for Neural Network Model
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(neural_model.parameters(), lr=0.001, weight_decay=1e-4)
# Training the Neural Network Model
num_epochs = 200
for epoch in range(num_epochs):
neural_model.train()
outputs = neural_model(X_train_tensor)
loss = criterion(outputs, y_train_tensor)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 20 == 0:
st.write(f'Neural Network - Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')
# Evaluate Neural Network Model
neural_model.eval()
with torch.no_grad():
outputs = neural_model(X_test_tensor)
_, predicted = torch.max(outputs.data, 1)
neural_accuracy = (predicted == y_test_tensor).sum().item() / y_test_tensor.size(0)
st.write(f'Neural Network Model Accuracy: {neural_accuracy * 100:.2f}%')
# Summary of Accuracies
st.write("\nSummary of Accuracies:")
st.write(f'Linear Model Accuracy: {linear_accuracy * 100:.2f}%')
st.write(f'Neural Network Model Accuracy: {neural_accuracy * 100:.2f}%')
# Function for male superhero task
def run_male_superhero_task():
st.write("Training Male Superhero model...")
# Male superhero training logic goes here
# Add dummy print statements as a placeholder
st.write("Male superhero model - Step 1: Data prepared.")
st.write("Male superhero model - Step 2: Model trained.")
st.write("Male superhero model - Step 3: Results evaluated.")
# Function for female superhero task
def run_female_superhero_task():
st.write("Training Female Superhero model...")
# Female superhero training logic goes here
# Add dummy print statements as a placeholder
st.write("Female superhero model - Step 1: Data prepared.")
st.write("Female superhero model - Step 2: Model trained.")
st.write("Female superhero model - Step 3: Results evaluated.")
# Streamlit UI
st.title("AI Training Demo")
# Task selection buttons
task = st.selectbox("Choose a task:", ("Superhero", "Disease"))
if task == "Superhero":
# Sub-options for Male and Female Superhero
gender = st.selectbox("Choose the gender:", ("Male", "Female"))
if gender == "Male":
if st.button("Run Male Superhero Task"):
run_male_superhero_task()
elif gender == "Female":
if st.button("Run Female Superhero Task"):
run_female_superhero_task()
elif task == "Disease":
if st.button("Run Disease Task"):
run_disease_task()
|