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))