v2 release

NdR_disease.py

@@ -7,7 +7,7 @@ from sklearn.utils import shuffle
 from sklearn.preprocessing import StandardScaler
 from sklearn.model_selection import train_test_split
 
-# Set random seed for reproducibility
+# Imposta il seed casuale per la riproducibilità
 np.random.seed(42)
 torch.manual_seed(42)
 
@@ -16,10 +16,10 @@ def run_disease_train():
     N_per_class = 500
 
     # List of conditions (classes)
-    conditions = ['Common Cold', 'Seasonal Allergies', 'Migraine', 'Gastroenteritis', 'Tension Headache']
+    condizioni = ['Raffreddore Comune', 'Allergie Stagionali', 'Emicrania', 'Gastroenterite', 'Cefalea Tensiva']
 
     # Total number of classes
-    num_classes = len(conditions)
+    num_classes = len(condizioni)
 
     # Total number of samples
     N = N_per_class * num_classes
@@ -35,36 +35,36 @@ def run_disease_train():
     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': {
+    # Features: [Febbre, Tosse, Starnuti, Naso che Cola, Nausea, Vomito, Diarrea, Mal di Testa, Affaticamento, Livello di Stress]
+    statistiche_condizioni = {
+        'Raffreddore Comune': {
             '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': {
+        'Allergie Stagionali': {
             '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': {
+        'Emicrania': {
             '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': {
+        'Gastroenterite': {
             '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': {
+        'Cefalea Tensiva': {
             '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):
+    for idx, condition in enumerate(condizioni):
         start = idx * N_per_class
         end = (idx + 1) * N_per_class
-        means = condition_stats[condition]['mean']
-        stds = condition_stats[condition]['std']
+        means = statistiche_condizioni[condition]['mean']
+        stds = statistiche_condizioni[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)
@@ -130,8 +130,8 @@ def run_disease_train():
         optimizer.zero_grad()
         loss.backward()
         optimizer.step()
-        if (epoch + 1) % 10 == 0:
-            st.write('Linear Model - Epoch [{}/{}], Loss: {:.4f}'.format(
+        if (epoch + 1) % 25 == 0:
+            st.write('Modello Lineare - Epoch [{}/{}], Loss: {:.4f}'.format(
                 epoch + 1, num_epochs, loss.item()))
 
     # Evaluate Linear Model
@@ -177,7 +177,7 @@ def run_disease_train():
         loss.backward()
         optimizer.step()
         if (epoch + 1) % 30 == 0:
-            st.write('Neural Network - Epoch [{}/{}], Loss: {:.4f}'.format(
+            st.write('Rete Neurale - Epoch [{}/{}], Loss: {:.4f}'.format(
                 epoch + 1, num_epochs, loss.item()))
 
     # Evaluate Neural Network Model
@@ -188,61 +188,65 @@ def run_disease_train():
         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}%')
+    st.write("\nRiepilogo delle Accuratezze:....")
+    st.error(f'Accuratezza Previsione Casuale: {random_accuracy * 100:.2f}%')
+    st.warning(f'Accuratezza Modello Lineare: {linear_accuracy * 100:.2f}%')
+    st.success(f'Accuratezza Rete Neurale: {neural_accuracy * 100:.2f}%')
     
-    return linear_model, neural_model, scaler, conditions, num_classes
-
-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):")
+    return linear_model, neural_model, scaler, condizioni, num_classes
 
+def get_user_input_and_predict_disease(modello_lineare, modello_neurale, scaler, condizioni, num_classes):
+    st.write("Regola i cursori per i seguenti sintomi su una scala da 0 (nessuno) a 10 (grave):")
+    
     # Feature names
-    feature_names = ['Fever', 'Cough', 'Sneezing', 'Runny Nose', 'Nausea', 'Vomiting', 
-                     'Diarrhea', 'Headache', 'Fatigue', 'Stress Level']
+    nomi_caratteristiche = ['Febbre', 'Tosse', 'Starnuti', 'Naso che Cola', 'Nausea', 'Vomito', 
+                            'Diarrea', 'Mal di Testa', 'Affaticamento', 'Livello di Stress']
     
-    # Create sliders for user input
-    user_features = []
-    for feature in feature_names:
-        # Use session state to retain slider values
-        default_value = 5
-        user_input = st.slider(feature, 0, 10, st.session_state.get(feature, default_value))
-        st.session_state[feature] = user_input
-        user_features.append(user_input)
-
-    # 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])
-
-    # Add a button to trigger the predictions
-    if st.button('Calculate Predictions'):
-        # Set session state to indicate the button was clicked
-        st.session_state.button_clicked = True
-
-    # Only show predictions if the button has been clicked
-    if st.session_state.button_clicked:
+    # Initialize or retrieve user features from session state
+    if 'user_features' not in st.session_state:
+        st.session_state.user_features = [5] * len(nomi_caratteristiche)  # Valore predefinito impostato a 5
+
+    # Create a form to group sliders and button
+    with st.form(key='symptom_form'):
+        for i, caratteristica in enumerate(nomi_caratteristiche):
+            st.session_state.user_features[i] = st.slider(
+                caratteristica, 0, 10, st.session_state.user_features[i], key=f'slider_{i}'
+            )
+        
+        # Form submission button
+        submit_button = st.form_submit_button(label='Calcola Previsioni')
+        if submit_button:
+            st.session_state.form_submitted = True  # Store form submission state
+
+    # Check if the form has been submitted
+    if st.session_state.get('form_submitted', False):
+        user_features = st.session_state.user_features.copy()
+
+        # Calculate interaction terms
+        termine_interazione = np.sin(user_features[7]) * np.log1p(user_features[9])  # Mal di testa e Livello di Stress
+        termine_interazione2 = user_features[0] * user_features[4]  # Febbre * Nausea
+        user_features.extend([termine_interazione, termine_interazione2])
+        
         # 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]}")
-
+        previsione_casuale = np.random.randint(num_classes)
+        st.error(f"\nPrevisione Casuale: {condizioni[previsione_casuale]}")
+        
         # Linear Model Prediction
-        linear_model.eval()
+        modello_lineare.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]}")
-
+            output = modello_lineare(user_tensor)
+            _, predetto = torch.max(output.data, 1)
+            previsione_lineare = predetto.item()
+        st.warning(f"Previsione Modello Lineare: {condizioni[previsione_lineare]}")
+        
         # Neural Network Prediction
-        neural_model.eval()
+        modello_neurale.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]}")
+            output = modello_neurale(user_tensor)
+            _, predetto = torch.max(output.data, 1)
+            previsione_neurale = predetto.item()
+        st.success(f"Previsione Rete Neurale: {condizioni[previsione_neurale]}")

NdR_female_superheros.py

@@ -1,3 +1,4 @@
+import streamlit as st
 import numpy as np
 import torch
 import torch.nn as nn
@@ -10,187 +11,247 @@ from sklearn.preprocessing import StandardScaler
 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))
+def run_female_superhero_train():
+    # Number of samples per superhero
+    N_per_class = 200
+
+    # List of female superheroes
+    superheroes = ['Wonder Woman', 'Captain Marvel', 'Vedova Nera', 'Tempesta', '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]
+        },
+        'Vedova Nera': {
+            'mean': [5, 7, 8, 6, 2],
+            'std':  [0.5, 0.5, 0.5, 0.5, 0.5]
+        },
+        'Tempesta': {
+            '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
+
+    # 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 = 1#00
+    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) % 25 == 0:
+            st.write('Modello Lineare - 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.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:
+            st.write('Rete Neurale - 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("\nRiepilogo delle Accuratezze:....")
+    st.error('Accuratezza Previsione Casuale: {:.2f}%'.format(100 * random_accuracy))
+    st.warning('Accuratezza Modello Lineare: {:.2f}%'.format(100 * linear_accuracy))
+    st.success('Accuratezza Rete Neurale: {:.2f}%'.format(100 * neural_accuracy))
+    
+    return linear_model, neural_model, scaler, superheroes, num_classes
+
+def get_user_input_and_predict_female_superhero(linear_model, neural_model, scaler, superheroes, num_classes):
+    st.write("Adjust the sliders for the following superhero attributes on a scale from 1 to 10:")
+
+    # Feature names corresponding to superhero attributes
+    feature_names = ['Forza', 'Velocità', 'Intelligenza', 'Resistenza', 'Proiezione di Energia']
+    
+    # Initialize or retrieve user input from session state to preserve the values across reruns
+    if 'user_features' not in st.session_state:
+        st.session_state.user_features = [5] * len(feature_names)  # Default slider values set to 5
+
+    # Create a form to group sliders and button
+    with st.form(key='superhero_form'):
+        for i, feature in enumerate(feature_names):
+            st.session_state.user_features[i] = st.slider(
+                feature, 1, 10, st.session_state.user_features[i], key=f'slider_{i}'
+            )
+        
+        # Form submission button
+        submit_button = st.form_submit_button(label='Calcola Previsioni')
+
+    # Proceed with prediction if the form is submitted
+    if submit_button:
+        # Copy user input values (superhero attributes)
+        user_features = st.session_state.user_features.copy()
+
+        # Calculate interaction term (interaction between Speed and Energy Projection)
+        interaction_term = np.sin(user_features[1]) * np.log(user_features[4])
+        
+        # Append the interaction term to the original features
+        user_features.append(interaction_term)
+        
+        # Convert to numpy array and reshape to match the expected input shape
+        user_features = np.array(user_features).reshape(1, -1)
+        
+        # Normalize user inputs using the scaler that was fit during training
+        user_features_scaled = scaler.transform(user_features)
+        
+        # Convert the scaled input into a torch tensor
+        user_tensor = torch.from_numpy(user_features_scaled).float()
+
+        # Make a random prediction for comparison
+        random_pred = np.random.randint(num_classes)
+        st.error(f"Previsione Casuale: {superheroes[random_pred]}")
+
+        # **Linear Model Prediction**
+        linear_model.eval()  # Set model to evaluation mode
+        with torch.no_grad():
+            outputs = linear_model(user_tensor)
+            _, predicted = torch.max(outputs.data, 1)
+            linear_pred = predicted.item()
+        st.warning(f"Previsione Modello Lineare: {superheroes[linear_pred]}")
+
+        # **Neural Network Prediction**
+        neural_model.eval()  # Set model to evaluation mode
+        with torch.no_grad():
+            outputs = neural_model(user_tensor)
+            _, predicted = torch.max(outputs.data, 1)
+            neural_pred = predicted.item()
+        st.success(f"Previsione Rete Neurale: {superheroes[neural_pred]}")

app.py

@@ -8,51 +8,107 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.linear_model import LogisticRegression
 from sklearn.model_selection import train_test_split
 
-from NdR_disease import run_disease_train, get_user_input_and_predict
+from NdR_disease import run_disease_train, get_user_input_and_predict_disease
+from NdR_female_superheros import run_female_superhero_train,  get_user_input_and_predict_female_superhero
+from NdR_male_superheros import run_male_superhero_train,  get_user_input_and_predict_male_superhero
 
-if 'button_clicked' not in st.session_state:
-    st.session_state.button_clicked = False
 
+# Interfaccia utente Streamlit
+st.title("Demo: Intelligenza Artificiale")
 
-# 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.")
+# Pulsanti di selezione del attività
+task = st.selectbox("Scegli una attività:", ("Supereroe", "Malattie"))
 
+if task == "Supereroe":
+    # Sotto-opzioni per Supereroe Maschile e Femminile
+    gender = st.selectbox("Scegli il genere:", ("Maschile", "Femminile"))
 
-# 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.")
+    if gender == "Maschile":
+        if 'malesuper_models' not in st.session_state:
+            if st.button("Avvia attività Supereroe Maschile"):
+                # Carica i modelli e salvali nello stato di sessione
+                linear_model, neural_model, scaler, superheros, num_classes = run_male_superhero_train()
+                st.session_state.malesuper_models = {
+                    'linear_model': linear_model,
+                    'neural_model': neural_model,
+                    'scaler': scaler,
+                    'superheros': superheros,
+                    'num_classes': num_classes
+                }
+        else:
+            st.write("I modelli di Supereroe Maschile sono già caricati.")
 
+        # Se i modelli sono caricati, ottieni input dall'utente e fai una previsione
+        if 'malesuper_models' in st.session_state:
+            models = st.session_state.malesuper_models
+            get_user_input_and_predict_male_superhero(
+                models['linear_model'],
+                models['neural_model'],
+                models['scaler'],
+                models['superheros'],
+                models['num_classes']
+            )
+        else:
+            st.write("Clicca 'Avvia attività Supereroe Maschile' per caricare i modelli.")
 
-# Streamlit UI
-st.title("AI Training Demo")
+    elif gender == "Femminile":
+        if 'femalesuper_models' not in st.session_state:
+            if st.button("Avvia attività Supereroe Femminile"):
+                # Carica i modelli e salvali nello stato di sessione
+                linear_model, neural_model, scaler, superheros, num_classes = run_female_superhero_train()
+                st.session_state.femalesuper_models = {
+                    'linear_model': linear_model,
+                    'neural_model': neural_model,
+                    'scaler': scaler,
+                    'superheros': superheros,
+                    'num_classes': num_classes
+                }
+        else:
+            st.write("I modelli di Supereroe Femminile sono già caricati.")
 
-# Task selection buttons
-task = st.selectbox("Choose a task:", ("Superhero", "Disease"))
+        # Se i modelli sono caricati, ottieni input dall'utente e fai una previsione
+        if 'femalesuper_models' in st.session_state:
+            models = st.session_state.femalesuper_models
+            get_user_input_and_predict_female_superhero(
+                models['linear_model'],
+                models['neural_model'],
+                models['scaler'],
+                models['superheros'],
+                models['num_classes']
+            )
+        else:
+            st.write("Clicca 'Avvia attività Supereroe Femminile' per caricare i modelli.")
 
-if task == "Superhero":
-    # Sub-options for Male and Female Superhero
-    gender = st.selectbox("Choose the gender:", ("Male", "Female"))
+elif task == "Malattie":
+    if 'disease_models' not in st.session_state:
+        if st.button("Avvia attività Malattie"):
+            # Carica i modelli e salvali nello stato di sessione
+            linear_model, neural_model, scaler, conditions, num_classes = run_disease_train()
+            st.session_state.disease_models = {
+                'linear_model': linear_model,
+                'neural_model': neural_model,
+                'scaler': scaler,
+                'conditions': conditions,
+                'num_classes': num_classes
+            }
+    else:
+        st.write("I modelli di malattie sono già caricati.")
 
-    if gender == "Male":
-        if st.button("Run Male Superhero Task"):
-            run_male_superhero_task()
+    # Se i modelli sono caricati, ottieni input dall'utente e fai una previsione
+    if 'disease_models' in st.session_state:
+        models = st.session_state.disease_models
+        get_user_input_and_predict_disease(
+            models['linear_model'],
+            models['neural_model'],
+            models['scaler'],
+            models['conditions'],
+            models['num_classes']
+        )
+    else:
+        st.write("Clicca 'Avvia attività Malattie' per caricare i modelli.")
 
-    elif gender == "Female":
-        if st.button("Run Female Superhero Task"):
-            run_female_superhero_task()
-
-elif task == "Disease":
-    if st.button("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)
+if st.button('Ripristina'):
+    # Cancella solo lo stato di invio del modulo e gli input dell'utente
+    for key in list(st.session_state.keys()):
+        del st.session_state[key]
+    st.rerun()