v0 trial

NdR_disease.py

@@ -0,0 +1,242 @@
+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.model_selection import train_test_split
+
+# Set random seed for reproducibility
+np.random.seed(42)
+torch.manual_seed(42)
+
+def run_disease_train()
+    # Number of samples per condition
+    N_per_class = 500
+
+    # List of conditions (classes)
+    conditions = ['Common Cold', 'Seasonal Allergies', 'Migraine', 'Gastroenteritis', 'Tension Headache']
+
+    # Total number of classes
+    num_classes = len(conditions)
+
+    # Total number of samples
+    N = N_per_class * num_classes
+
+    # Number of original features
+    D = 10  # Number of symptoms/features
+
+    # Update the total number of features after adding interaction terms
+    total_features = D + 2  # Original features plus two interaction terms
+
+    # Initialize feature matrix X and label vector y
+    X = np.zeros((N, total_features))
+    y = np.zeros(N, dtype=int)
+
+    # Define the mean and standard deviation for each feature per condition
+    # Features: [Fever, Cough, Sneezing, Runny Nose, Nausea, Vomiting, Diarrhea, Headache, Fatigue, Stress Level]
+    condition_stats = {
+        'Common Cold': {
+            'mean': [1, 6, 7, 8, 1, 1, 1, 5, 5, 5],
+            'std':  [1.5, 2, 2, 2, 1.5, 1.5, 1.5, 2, 2, 2]
+        },
+        'Seasonal Allergies': {
+            'mean': [0, 3, 8, 9, 1, 1, 1, 4, 4, 6],
+            'std':  [1.5, 2, 2, 2, 1.5, 1.5, 1.5, 2, 2, 2]
+        },
+        'Migraine': {
+            'mean': [0, 1, 1, 1, 2, 2, 2, 8, 7, 8],
+            'std':  [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 2, 2, 2]
+        },
+        'Gastroenteritis': {
+            'mean': [2, 2, 1, 1, 7, 6, 8, 5, 6, 5],
+            'std':  [1.5, 2, 1.5, 1.5, 2, 2, 2, 2, 2, 2]
+        },
+        'Tension Headache': {
+            'mean': [0, 1, 1, 1, 1, 1, 1, 6, 5, 8],
+            'std':  [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 2, 2, 2]
+        },
+    }
+
+    # Generate synthetic data for each condition
+    for idx, condition in enumerate(conditions):
+        start = idx * N_per_class
+        end = (idx + 1) * N_per_class
+        means = condition_stats[condition]['mean']
+        stds = condition_stats[condition]['std']
+        X_condition = np.random.normal(means, stds, (N_per_class, D))
+        # Ensure feature values are within reasonable ranges
+        X_condition = np.clip(X_condition, 0, 10)
+        # Introduce non-linear feature interactions
+        interaction_term = np.sin(X_condition[:, 7]) * np.log1p(X_condition[:, 9])  # Headache and Stress Level
+        interaction_term2 = X_condition[:, 0] * X_condition[:, 4]  # Fever * Nausea
+        X_condition = np.hstack((X_condition, interaction_term.reshape(-1, 1), interaction_term2.reshape(-1, 1)))
+        X[start:end] = X_condition
+        y[start:end] = idx
+
+    # Shuffle the dataset
+    X, y = shuffle(X, y, random_state=42)
+
+    # Normalize the features
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    # Split data into training and test sets
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X_scaled, y, test_size=0.2, random_state=42
+    )
+
+    # Convert data to torch tensors
+    X_train_tensor = torch.from_numpy(X_train).float()
+    y_train_tensor = torch.from_numpy(y_train).long()
+    X_test_tensor = torch.from_numpy(X_test).float()
+    y_test_tensor = torch.from_numpy(y_test).long()
+
+    # Random prediction function
+    def random_prediction(num_samples):
+        random_preds = np.random.randint(num_classes, size=num_samples)
+        return random_preds
+
+    # Random prediction and evaluation
+    random_preds = random_prediction(len(y_test))
+    random_accuracy = (random_preds == y_test).sum() / y_test.size
+
+    # Define Linear Model
+    class LinearModel(nn.Module):
+        def __init__(self, input_dim, output_dim):
+            super(LinearModel, self).__init__()
+            self.linear = nn.Linear(input_dim, output_dim)
+        
+        def forward(self, x):
+            return self.linear(x)
+
+    # Initialize Linear Model
+    input_dim = total_features
+    output_dim = num_classes
+    linear_model = LinearModel(input_dim, output_dim)
+
+    # Loss and optimizer for Linear Model
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(linear_model.parameters(), lr=0.01, weight_decay=1e-4)
+
+    # Training the Linear Model
+    num_epochs = 50
+    for epoch in range(num_epochs):
+        linear_model.train()
+        outputs = linear_model(X_train_tensor)
+        loss = criterion(outputs, y_train_tensor)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        if (epoch + 1) % 10 == 0:
+            st.write('Linear Model - Epoch [{}/{}], Loss: {:.4f}'.format(
+                epoch + 1, num_epochs, loss.item()))
+
+    # Evaluate Linear Model
+    linear_model.eval()
+    with torch.no_grad():
+        outputs = linear_model(X_test_tensor)
+        _, predicted = torch.max(outputs.data, 1)
+        linear_accuracy = (predicted == y_test_tensor).sum().item() / y_test_tensor.size(0)
+
+    # Define Neural Network Model with regularization
+    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.5))
+                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 = [256, 128, 64]
+    neural_model = NeuralNet(input_dim, hidden_dims, output_dim)
+
+    # 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 = 300
+    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) % 30 == 0:
+            st.write('Neural Network - Epoch [{}/{}], Loss: {:.4f}'.format(
+                epoch + 1, num_epochs, loss.item()))
+
+    # 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)
+
+    # Summary of Accuracies
+    st.write("\nSummary of Accuracies:....")
+    st.write(f'Random Prediction Accuracy: {random_accuracy * 100:.2f}%')
+    st.write(f'Linear Model Accuracy: {linear_accuracy * 100:.2f}%')
+    st.write(f'Neural Network Model Accuracy: {neural_accuracy * 100:.2f}%')
+    
+    return linear_model, neural_model, scaler, conditions, num_classes
+
+# Function to get user input and make predictions
+def get_user_input_and_predict(linear_model, neural_model, scaler, conditions, num_classes):
+    st.write("\nAdjust the sliders for the following symptoms on a scale from 0 (none) to 10 (severe):")
+    
+    # Feature names
+    feature_names = ['Fever', 'Cough', 'Sneezing', 'Runny Nose', 'Nausea', 'Vomiting', 
+                     'Diarrhea', 'Headache', 'Fatigue', 'Stress Level']
+    
+    # Create sliders for user input
+    user_features = []
+    for feature in feature_names:
+        value = st.slider(feature, 0, 10, 5)  # Default value set to 5
+        user_features.append(value)
+    
+    # Calculate interaction terms
+    interaction_term = np.sin(user_features[7]) * np.log1p(user_features[9])  # Headache and Stress Level
+    interaction_term2 = user_features[0] * user_features[4]  # Fever * Nausea
+    user_features.extend([interaction_term, interaction_term2])
+    
+    # Normalize features
+    user_features = scaler.transform([user_features])
+    user_tensor = torch.from_numpy(user_features).float()
+    
+    # Random prediction
+    random_pred = np.random.randint(num_classes)
+    st.write(f"\nRandom Prediction: {conditions[random_pred]}")
+    
+    # Linear Model Prediction
+    linear_model.eval()
+    with torch.no_grad():
+        outputs = linear_model(user_tensor)
+        _, predicted = torch.max(outputs.data, 1)
+        linear_pred = predicted.item()
+    st.write(f"Linear Model Prediction: {conditions[linear_pred]}")
+    
+    # Neural Network Prediction
+    neural_model.eval()
+    with torch.no_grad():
+        outputs = neural_model(user_tensor)
+        _, predicted = torch.max(outputs.data, 1)
+        neural_pred = predicted.item()
+    st.write(f"Neural Network Prediction: {conditions[neural_pred]}")
+
+linear_model, neural_model, scaler, conditions, num_classes = run_disease_train()
+get_user_input_and_predict(linear_model, neural_model, scaler, conditions, num_classes)

NdR_female_superheros.py

@@ -0,0 +1,196 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.utils import shuffle
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+# Set random seed for reproducibility
+np.random.seed(42)
+torch.manual_seed(42)
+
+# Number of samples per superhero
+N_per_class = 200
+
+# List of female superheroes
+superheroes = ['Wonder Woman', 'Captain Marvel', 'Black Widow', 'Storm', 'Supergirl']
+
+# Total number of classes
+num_classes = len(superheroes)
+
+# Total number of samples
+N = N_per_class * num_classes
+
+# Number of original features
+D = 5  # Strength, Speed, Intelligence, Durability, Energy Projection
+
+# Update the total number of features after adding the interaction term
+total_features = D + 1  # Original features plus the interaction term
+
+# Initialize feature matrix X and label vector y
+X = np.zeros((N, total_features))
+y = np.zeros(N, dtype=int)
+
+# Define the mean and standard deviation for each feature per superhero
+# Features: [Strength, Speed, Intelligence, Durability, Energy Projection]
+superhero_stats = {
+    'Wonder Woman': {
+        'mean': [9, 9, 8, 9, 8],
+        'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+    },
+    'Captain Marvel': {
+        'mean': [10, 9, 7, 10, 10],
+        'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+    },
+    'Black Widow': {
+        'mean': [5, 7, 8, 6, 2],
+        'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+    },
+    'Storm': {
+        'mean': [6, 7, 8, 6, 9],
+        'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+    },
+    'Supergirl': {
+        'mean': [10, 10, 8, 10, 9],
+        'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+    },
+}
+
+# Generate synthetic data for each superhero with non-linear relationships
+for idx, hero in enumerate(superheroes):
+    start = idx * N_per_class
+    end = (idx + 1) * N_per_class
+    means = superhero_stats[hero]['mean']
+    stds = superhero_stats[hero]['std']
+    X_hero = np.random.normal(means, stds, (N_per_class, D))
+    # Ensure feature values are within reasonable ranges before computing interaction
+    X_hero = np.clip(X_hero, 1, 10)
+    # Introduce non-linear feature interactions
+    interaction_term = np.sin(X_hero[:, 1]) * np.log(X_hero[:, 4])  # Interaction between Speed and Energy Projection
+    X_hero = np.hstack((X_hero, interaction_term.reshape(-1, 1)))
+    X[start:end] = X_hero
+    y[start:end] = idx
+
+# Ensure all feature values are within reasonable ranges
+X[:, :D] = np.clip(X[:, :D], 1, 10)
+
+# Shuffle the dataset
+X, y = shuffle(X, y, random_state=42)
+
+# Normalize the features
+scaler = StandardScaler()
+X = scaler.fit_transform(X)
+
+# Split data into training and test sets
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42)
+
+# Convert data to torch tensors
+X_train_tensor = torch.from_numpy(X_train).float()
+y_train_tensor = torch.from_numpy(y_train).long()
+X_test_tensor = torch.from_numpy(X_test).float()
+y_test_tensor = torch.from_numpy(y_test).long()
+
+# Random prediction function
+def random_prediction(X):
+    num_samples = X.shape[0]
+    random_preds = np.random.randint(num_classes, size=num_samples)
+    return random_preds
+
+# Random prediction and evaluation
+random_preds = random_prediction(X_test)
+random_accuracy = (random_preds == y_test).sum() / y_test.size
+print('Random Prediction Accuracy: {:.2f}%'.format(100 * random_accuracy))
+
+# Define Linear Model
+class LinearModel(nn.Module):
+    def __init__(self, input_dim, output_dim):
+        super(LinearModel, self).__init__()
+        self.linear = nn.Linear(input_dim, output_dim)
+
+    def forward(self, x):
+        return self.linear(x)
+
+# Initialize Linear Model
+input_dim = total_features
+output_dim = num_classes
+linear_model = LinearModel(input_dim, output_dim)
+
+# Loss and optimizer for Linear Model
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(linear_model.parameters(), lr=0.01, weight_decay=1e-4)
+
+# Training the Linear Model
+num_epochs = 100
+for epoch in range(num_epochs):
+    linear_model.train()
+    outputs = linear_model(X_train_tensor)
+    loss = criterion(outputs, y_train_tensor)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    if (epoch + 1) % 20 == 0:
+        print('Linear Model - Epoch [{}/{}], Loss: {:.4f}'.format(
+            epoch + 1, num_epochs, loss.item()))
+
+# Evaluate Linear Model
+linear_model.eval()
+with torch.no_grad():
+    outputs = linear_model(X_test_tensor)
+    _, predicted = torch.max(outputs.data, 1)
+    linear_accuracy = (predicted == y_test_tensor).sum().item() / y_test_tensor.size(0)
+    print('Linear Model Accuracy: {:.2f}%'.format(100 * linear_accuracy))
+
+# Define Neural Network Model with regularization
+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(input_dim, hidden_dims, output_dim)
+
+# 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:
+        print('Neural Network - Epoch [{}/{}], Loss: {:.4f}'.format(
+            epoch + 1, num_epochs, loss.item()))
+
+# 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)
+    print('Neural Network Model Accuracy: {:.2f}%'.format(100 * neural_accuracy))
+
+# Summary of Accuracies
+print("\nSummary of Accuracies:")
+print('Random Prediction Accuracy: {:.2f}%'.format(100 * random_accuracy))
+print('Linear Model Accuracy: {:.2f}%'.format(100 * linear_accuracy))
+print('Neural Network Model Accuracy: {:.2f}%'.format(100 * neural_accuracy))

NdR_male_superheros.py

@@ -0,0 +1,196 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.utils import shuffle
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+# Set random seed for reproducibility
+np.random.seed(42)
+torch.manual_seed(42)
+
+# Number of samples per superhero
+N_per_class = 200
+
+# List of superheroes
+superheroes = ['Iron Man', 'Hulk', 'Flash', 'Batman', 'Thor']
+
+# Total number of classes
+num_classes = len(superheroes)
+
+# Total number of samples
+N = N_per_class * num_classes
+
+# Number of original features
+D = 5  # Strength, Speed, Intelligence, Durability, Energy Projection
+
+# Update the total number of features after adding the interaction term
+total_features = D + 1  # Original features plus the interaction term
+
+# Initialize feature matrix X and label vector y
+X = np.zeros((N, total_features))
+y = np.zeros(N, dtype=int)
+
+# Define the mean and standard deviation for each feature per superhero
+# Features: [Strength, Speed, Intelligence, Durability, Energy Projection]
+superhero_stats = {
+    'Iron Man': {
+        'mean': [7, 7, 9, 8, 8],
+        'std':  [0.5, 0.5, 0.2, 0.5, 0.5]
+    },
+    'Hulk': {
+        'mean': [10, 5, 3, 10, 2],
+        'std':  [0.5, 0.5, 0.2, 0.5, 0.5]
+    },
+    'Flash': {
+        'mean': [4, 10, 6, 5, 3],
+        'std':  [0.5, 0.5, 0.2, 0.5, 0.5]
+    },
+    'Batman': {
+        'mean': [5, 6, 9, 6, 2],
+        'std':  [0.5, 0.5, 0.2, 0.5, 0.5]
+    },
+    'Thor': {
+        'mean': [10, 8, 7, 10, 9],
+        'std':  [0.5, 0.5, 0.2, 0.5, 0.5]
+    },
+}
+
+# Generate synthetic data for each superhero with non-linear relationships
+for idx, hero in enumerate(superheroes):
+    start = idx * N_per_class
+    end = (idx + 1) * N_per_class
+    means = superhero_stats[hero]['mean']
+    stds = superhero_stats[hero]['std']
+    X_hero = np.random.normal(means, stds, (N_per_class, D))
+    # Ensure feature values are within reasonable ranges before computing interaction
+    X_hero = np.clip(X_hero, 1, 10)
+    # Introduce non-linear feature interactions
+    interaction_term = np.sin(X_hero[:, 0]) * np.log(X_hero[:, 2])
+    X_hero = np.hstack((X_hero, interaction_term.reshape(-1, 1)))
+    X[start:end] = X_hero
+    y[start:end] = idx
+
+# Ensure all feature values are within reasonable ranges
+X[:, :D] = np.clip(X[:, :D], 1, 10)
+
+# Shuffle the dataset
+X, y = shuffle(X, y, random_state=42)
+
+# Normalize the features
+scaler = StandardScaler()
+X = scaler.fit_transform(X)
+
+# Split data into training and test sets
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42)
+
+# Convert data to torch tensors
+X_train_tensor = torch.from_numpy(X_train).float()
+y_train_tensor = torch.from_numpy(y_train).long()
+X_test_tensor = torch.from_numpy(X_test).float()
+y_test_tensor = torch.from_numpy(y_test).long()
+
+# Random prediction function
+def random_prediction(X):
+    num_samples = X.shape[0]
+    random_preds = np.random.randint(num_classes, size=num_samples)
+    return random_preds
+
+# Random prediction and evaluation
+random_preds = random_prediction(X_test)
+random_accuracy = (random_preds == y_test).sum() / y_test.size
+print('Random Prediction Accuracy: {:.2f}%'.format(100 * random_accuracy))
+
+# Define Linear Model
+class LinearModel(nn.Module):
+    def __init__(self, input_dim, output_dim):
+        super(LinearModel, self).__init__()
+        self.linear = nn.Linear(input_dim, output_dim)
+
+    def forward(self, x):
+        return self.linear(x)
+
+# Initialize Linear Model
+input_dim = total_features
+output_dim = num_classes
+linear_model = LinearModel(input_dim, output_dim)
+
+# Loss and optimizer for Linear Model
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(linear_model.parameters(), lr=0.01, weight_decay=1e-4)
+
+# Training the Linear Model
+num_epochs = 100
+for epoch in range(num_epochs):
+    linear_model.train()
+    outputs = linear_model(X_train_tensor)
+    loss = criterion(outputs, y_train_tensor)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    if (epoch + 1) % 20 == 0:
+        print('Linear Model - Epoch [{}/{}], Loss: {:.4f}'.format(
+            epoch + 1, num_epochs, loss.item()))
+
+# Evaluate Linear Model
+linear_model.eval()
+with torch.no_grad():
+    outputs = linear_model(X_test_tensor)
+    _, predicted = torch.max(outputs.data, 1)
+    linear_accuracy = (predicted == y_test_tensor).sum().item() / y_test_tensor.size(0)
+    print('Linear Model Accuracy: {:.2f}%'.format(100 * linear_accuracy))
+
+# Define Neural Network Model with regularization
+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(input_dim, hidden_dims, output_dim)
+
+# 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:
+        print('Neural Network - Epoch [{}/{}], Loss: {:.4f}'.format(
+            epoch + 1, num_epochs, loss.item()))
+
+# 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)
+    print('Neural Network Model Accuracy: {:.2f}%'.format(100 * neural_accuracy))
+
+# Summary of Accuracies
+print("\nSummary of Accuracies:")
+print('Random Prediction Accuracy: {:.2f}%'.format(100 * random_accuracy))
+print('Linear Model Accuracy: {:.2f}%'.format(100 * linear_accuracy))
+print('Neural Network Model Accuracy: {:.2f}%'.format(100 * neural_accuracy))

app.py

@@ -8,112 +8,7 @@ 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}%')
+from NdR_disease import run_disease_train, get_user_input_and_predict
 
 
 # Function for male superhero task
@@ -156,4 +51,5 @@ if task == "Superhero":
 
 elif task == "Disease":
     if st.button("Run Disease Task"):
-        run_disease_task()
+        linear_model, neural_model, scaler, conditions, num_classes = run_disease_train()
+        get_user_input_and_predict(linear_model, neural_model, scaler, conditions, num_classes)