Upload 13 files

666cifar_model_resnet101_lr0.0001.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9515f143f4ec8c254fe48d5ea0bc4a5bc7705e3365c41d98bda5a6d2f9e5589
+size 170753573

666cifar_model_resnet18_lr0.00001.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd360f167eb2b17432a47dcc3dd07d0e342b0afbe355a7c2eb41a023c6378c15
+size 44816293

666cifar_model_resnet18_lr0.0001.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91b3891b1ac4ced9ce43c424161b81a10e1c4acea53185e0bab0580b82d2af5e
+size 44816169

666cifar_model_resnet18_lr0.0001_unbalanced_crossentropy.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:709788266979ebb93bbbeb97fca78af1aa297287992f02f7599d27b14c1ae701
+size 44819145

666cifar_model_resnet18_lr0.0001_unbalanced_sampling.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47add05ed4d32ae1d109b0a15b9ef8b2b363e7d4e99b0124bde2e3e1d33fd0f6
+size 44818649

666cifar_model_resnet18_lr0.0001_unbalanced_without_trick.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20f0fe2a58a2c637b84c5cd61dec47410cf09321b2ce935c75b197da0fe5fe75
+size 44819269

cifar_resnet18.py

@@ -0,0 +1,194 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import Image
+import torchvision.datasets as dsets
+
+
+
+#training parameters
+modellr = 1e-5
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+full_dataset =  dsets.CIFAR10(root='./data', train=True, download=True, transform = transform_train)
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(full_dataset))
+val_size = len(full_dataset) - train_size
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(full_dataset, [train_size, val_size])
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+criterion = nn.CrossEntropyLoss()
+model = torchvision.models.resnet18(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+#Training method
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+    sum_loss = 0
+    correct = 0
+    total_num = len(train_loader.dataset)
+    print(total_num, len(train_loader))
+    
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = Variable(data).to(device), Variable(target).to(device)
+        output = model(data)
+        loss = criterion(output, target)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        
+        print_loss = loss.data.item()
+        sum_loss += print_loss
+
+        _, pred = torch.max(output.data, 1)
+        correct += torch.sum(pred == target)
+
+        if (batch_idx + 1) % 50 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
+                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
+
+    accuracy = correct / total_num
+    ave_loss = sum_loss / len(train_loader)
+    print('epoch:{}, loss:{}, Training Accuracy: {:.2%}'.format(epoch, ave_loss, accuracy))
+
+
+
+# Modify the val function to update the best model when a higher accuracy is achieved
+
+        
+
+def val(model, device, test_loader, epoch):
+    global best_accuracy, best_epoch
+    model.eval()
+    test_loss = 0
+    correct = 0
+    total_num = len(test_loader.dataset)
+    print(total_num, len(test_loader))
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = Variable(data).to(device), Variable(target).to(device)
+            output = model(data)
+            loss = criterion(output, target)
+            _, pred = torch.max(output.data, 1)
+            correct += torch.sum(pred == target)
+            print_loss = loss.data.item()
+            test_loss += print_loss
+        correct = correct.data.item()
+        acc = correct / total_num
+        avgloss = test_loss / len(test_loader)
+        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+            avgloss, correct, len(test_loader.dataset), 100 * acc))
+                # Check if this epoch's accuracy is better than the best so far
+        if acc > best_accuracy:
+            best_accuracy, best_epoch = acc, epoch
+            # Save the best model
+            torch.save(model, '666cifar_model_resnet18_lr0.00001.pth')
+            
+            
+# Test the model on the test set
+def test(model, device, test_loader):
+    model.eval()
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            total += target.size(0)
+            correct += (predicted == target).sum().item()
+
+    accuracy = correct / total
+    print('Test Accuracy: {:.2%} ({}/{})'.format(accuracy, correct, total))
+
+
+
+# Train the model and track the best model
+for epoch in range(1, EPOCHS + 1):
+    adjust_learning_rate(optimizer, epoch)
+    train(model, DEVICE, train_loader, optimizer, epoch)
+    val(model, DEVICE, val_loader, epoch)
+    test(model, DEVICE, test_loader)
+
+
+print(f"Best model achieved at epoch {best_epoch} with accuracy: {best_accuracy * 100:.2f}%")
+
+
+

cifar_unbalanced.py

@@ -0,0 +1,232 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import Image
+import torchvision.datasets as dsets
+
+
+
+class ModifiedCIFAR10(Dataset):
+    def __init__(self, root, train=True, transform=None, target_classes=[0, 1, 2, 3,4,5,6,7,8,9], num_samples=[500, 500, 2500, 2500,5000,5000,5000,5000,5000,5000]):
+        self.original_dataset = dsets.CIFAR10(root=root, train=train, download=True, transform=transform)
+        self.target_classes = target_classes
+        self.num_samples = num_samples
+
+        self.sample_indices = []
+        for target_class, num_sample in zip(target_classes, num_samples):
+            class_indices = [i for i, label in enumerate(self.original_dataset.targets) if label == target_class]
+            self.sample_indices += class_indices[:num_sample]
+
+    def __len__(self):
+        return len(self.sample_indices)
+
+    def __getitem__(self, idx):
+        original_idx = self.sample_indices[idx]
+        return self.original_dataset[original_idx]
+
+
+
+
+
+#training parameters
+modellr = 1e-4
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Modify the number of samples for class 0 from 5000 to 500
+modified_train_dataset = ModifiedCIFAR10(
+    root='./data',
+    train=True,
+    transform=transform_train,
+    target_classes=[0, 1, 2, 3,4,5,6,7,8,9],
+    num_samples=[500, 500, 2500, 2500,5000,5000,5000,5000,5000,5000]
+)
+
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(modified_train_dataset))
+val_size = len(modified_train_dataset) - train_size
+
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(modified_train_dataset, [train_size, val_size])
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+
+
+criterion = nn.CrossEntropyLoss()
+
+#num_samples = [500, 500, 2500, 2500, 5000, 5000, 5000, 5000, 5000, 5000]
+
+#First balance method
+
+# Calculate class weights
+#class_weights = torch.FloatTensor([num_samples[i] / len(modified_train_dataset) for i in range(10)])
+# Instantiate CrossEntropyLoss with class weights
+#criterion = nn.CrossEntropyLoss(weight=class_weights.to(DEVICE))
+
+
+model = torchvision.models.resnet18(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+#Training method
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+    sum_loss = 0
+    correct = 0
+    total_num = len(train_loader.dataset)
+    print(total_num, len(train_loader))
+    
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = Variable(data).to(device), Variable(target).to(device)
+        output = model(data)
+        loss = criterion(output, target)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        print_loss = loss.data.item()
+        sum_loss += print_loss
+
+        _, pred = torch.max(output.data, 1)
+        correct += torch.sum(pred == target)
+
+        if (batch_idx + 1) % 50 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
+                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
+
+    accuracy = correct / total_num
+    ave_loss = sum_loss / len(train_loader)
+    print('epoch:{}, loss:{}, Training Accuracy: {:.2%}'.format(epoch, ave_loss, accuracy))
+
+
+def val(model, device, test_loader, epoch):
+    global best_accuracy, best_epoch
+    model.eval()
+    test_loss = 0
+    correct = 0
+    total_num = len(test_loader.dataset)
+    print(total_num, len(test_loader))
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = Variable(data).to(device), Variable(target).to(device)
+            output = model(data)
+            loss = criterion(output, target)
+            _, pred = torch.max(output.data, 1)
+            correct += torch.sum(pred == target)
+            print_loss = loss.data.item()
+            test_loss += print_loss
+        correct = correct.data.item()
+        acc = correct / total_num
+        avgloss = test_loss / len(test_loader)
+        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+            avgloss, correct, len(test_loader.dataset), 100 * acc))
+                
+        if acc > best_accuracy:
+            best_accuracy, best_epoch = acc, epoch
+            torch.save(model, '666cifar_model_resnet18_lr0.0001_unbalanced_crossentropy.pth')
+            
+            
+# Test the model on the test set
+def test(model, device, test_loader):
+    model.eval()
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            total += target.size(0)
+            correct += (predicted == target).sum().item()
+
+    accuracy = correct / total
+    print('Test Accuracy: {:.2%} ({}/{})'.format(accuracy, correct, total))
+
+
+
+# Train the model and track the best model
+for epoch in range(1, EPOCHS + 1):
+    adjust_learning_rate(optimizer, epoch)
+    train(model, DEVICE, train_loader, optimizer, epoch)
+    val(model, DEVICE, val_loader, epoch)
+    test(model, DEVICE, test_loader)
+
+
+print(f"Best model achieved at epoch {best_epoch} with accuracy: {best_accuracy * 100:.2f}%")

cifar_unbalanced_sampling.py

@@ -0,0 +1,297 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import Image
+import torchvision.datasets as dsets
+from imblearn.over_sampling import RandomOverSampler
+
+
+
+class ModifiedCIFAR10(Dataset):
+    def __init__(self, root, train=True, transform=None, target_classes=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], num_samples=[500, 500, 2500, 2500, 5000, 5000, 5000, 5000, 5000, 5000], oversample=True, undersample=True):
+        self.original_dataset = dsets.CIFAR10(root=root, train=train, download=True, transform=transform)
+        self.target_classes = target_classes
+        self.num_samples = num_samples
+        self.oversample = oversample
+        self.undersample = undersample
+
+        self.sample_indices = []
+        for target_class, num_sample in zip(target_classes, num_samples):
+            class_indices = [i for i, label in enumerate(self.original_dataset.targets) if label == target_class]
+            self.sample_indices += class_indices[:num_sample]
+
+        if self.oversample or self.undersample:
+            X = [self.original_dataset[i][0].numpy() for i in self.sample_indices]
+            y = [self.original_dataset[i][1] for i in self.sample_indices]
+
+            if self.oversample:
+                smote = SMOTE(sampling_strategy='auto', random_state=42, n_jobs=-1)
+                X_resampled, y_resampled = smote.fit_resample(np.array(X).reshape(-1, 32 * 32 * 3), y)
+            else:
+                X_resampled, y_resampled = np.array(X).reshape(-1, 32 * 32 * 3), y
+
+            if self.undersample:
+                enn = EditedNearestNeighbours(sampling_strategy='auto', n_neighbors=3, n_jobs=-1)
+                X_resampled, y_resampled = enn.fit_resample(X_resampled, y_resampled)
+
+            self.resampled_indices = [idx for i, idx in enumerate(self.sample_indices) if i in range(len(X_resampled))]
+            self.sample_indices = self.resampled_indices
+
+    def __len__(self):
+        return len(self.sample_indices)
+
+    def __getitem__(self, idx):
+        original_idx = self.sample_indices[idx]
+        return self.original_dataset[original_idx]
+
+
+
+
+
+#training parameters
+modellr = 1e-4
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Modify the number of samples for class 0 from 5000 to 500
+modified_train_dataset = ModifiedCIFAR10(
+    root='./data',
+    train=True,
+    transform=transform_train,
+    target_classes=[0, 1, 2, 3,4,5,6,7,8,9],
+    num_samples=[500, 500, 2500, 2500,5000,5000,5000,5000,5000,5000]
+)
+
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(modified_train_dataset))
+val_size = len(modified_train_dataset) - train_size
+
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(modified_train_dataset, [train_size, val_size])
+
+###
+from imblearn.over_sampling import RandomOverSampler
+from sklearn.utils import shuffle
+
+# Extract class labels for oversampling
+oversample_classes = [0, 1, 2, 3]
+
+
+# Extract features and labels from the training dataset
+X, y = zip(*[(x, y) for x, y in modified_train_dataset])
+X = np.array([tensor.view(tensor.size(0), -1).numpy() for tensor in X])
+y = np.array(y)
+
+# Flatten each tensor in X
+X_flattened = np.array([tensor.view(tensor.size(0), -1).numpy() for tensor in X])
+
+
+
+# Oversample the flattened training dataset using RandomOverSampler
+oversampler = RandomOverSampler(sampling_strategy='auto', random_state=42)
+X_resampled, y_resampled = oversampler.fit_resample(X_flattened, y)
+
+
+
+
+# Convert back to PyTorch dataset
+oversampled_dataset = list(zip(X_resampled, y_resampled))
+oversampled_dataset = torch.utils.data.TensorDataset(torch.from_numpy(X_resampled), torch.from_numpy(y_resampled))
+
+# Split the oversampled dataset into training and validation sets
+oversampled_train_size = int(0.9 * len(oversampled_dataset))
+oversampled_val_size = len(oversampled_dataset) - oversampled_train_size
+torch.manual_seed(42)
+oversampled_train_dataset, oversampled_validation_dataset = random_split(oversampled_dataset,
+                                                                        [oversampled_train_size, oversampled_val_size])
+
+# DataLoader for oversampled training set
+oversampled_train_loader = torch.utils.data.DataLoader(dataset=oversampled_train_dataset,
+                                                       batch_size=BATCH_SIZE, shuffle=True)
+
+# DataLoader for oversampled validation set
+oversampled_val_loader = torch.utils.data.DataLoader(dataset=oversampled_validation_dataset,
+                                                     batch_size=BATCH_SIZE, shuffle=False)
+###
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+
+
+criterion = nn.CrossEntropyLoss()
+
+num_samples = [500, 500, 2500, 2500, 5000, 5000, 5000, 5000, 5000, 5000]
+
+#First balance method
+num_samples = [500, 500, 2500, 2500, 5000, 5000, 5000, 5000, 5000, 5000]
+# Calculate class weights
+class_weights = torch.FloatTensor([num_samples[i] / len(modified_train_dataset) for i in range(10)])
+# Instantiate CrossEntropyLoss with class weights
+criterion = nn.CrossEntropyLoss(weight=class_weights.to(DEVICE))
+
+
+model = torchvision.models.resnet18(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+#Training method
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+    sum_loss = 0
+    correct = 0
+    total_num = len(train_loader.dataset)
+    print(total_num, len(train_loader))
+    
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = Variable(data).to(device), Variable(target).to(device)
+        output = model(data)
+        loss = criterion(output, target)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        print_loss = loss.data.item()
+        sum_loss += print_loss
+
+        _, pred = torch.max(output.data, 1)
+        correct += torch.sum(pred == target)
+
+        if (batch_idx + 1) % 50 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
+                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
+
+    accuracy = correct / total_num
+    ave_loss = sum_loss / len(train_loader)
+    print('epoch:{}, loss:{}, Training Accuracy: {:.2%}'.format(epoch, ave_loss, accuracy))
+
+
+def val(model, device, test_loader, epoch):
+    global best_accuracy, best_epoch
+    model.eval()
+    test_loss = 0
+    correct = 0
+    total_num = len(test_loader.dataset)
+    print(total_num, len(test_loader))
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = Variable(data).to(device), Variable(target).to(device)
+            output = model(data)
+            loss = criterion(output, target)
+            _, pred = torch.max(output.data, 1)
+            correct += torch.sum(pred == target)
+            print_loss = loss.data.item()
+            test_loss += print_loss
+        correct = correct.data.item()
+        acc = correct / total_num
+        avgloss = test_loss / len(test_loader)
+        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+            avgloss, correct, len(test_loader.dataset), 100 * acc))
+                
+        if acc > best_accuracy:
+            best_accuracy, best_epoch = acc, epoch
+            torch.save(model, '666cifar_model_resnet18_lr0.0001_unbalanced_crossentropy.pth')
+            
+            
+# Test the model on the test set
+def test(model, device, test_loader):
+    model.eval()
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            total += target.size(0)
+            correct += (predicted == target).sum().item()
+
+    accuracy = correct / total
+    print('Test Accuracy: {:.2%} ({}/{})'.format(accuracy, correct, total))
+
+
+
+# Train the model and track the best model
+for epoch in range(1, EPOCHS + 1):
+    adjust_learning_rate(optimizer, epoch)
+    train(model, DEVICE, oversampled_train_loader, optimizer, epoch)
+    val(model, DEVICE, oversampled_val_loader, epoch)
+    test(model, DEVICE, test_loader)
+
+
+print(f"Best model achieved at epoch {best_epoch} with accuracy: {best_accuracy * 100:.2f}%")

plot_accuracy.py

@@ -0,0 +1,33 @@
+import matplotlib.pyplot as plt
+
+
+epochs = list(range(1, 21))  
+train_losses = [1.3119755745442077, 0.9600333069366488, 0.8390481574460864, 0.7701934007504447, 0.717232290782373, 0.6732362943955443, 0.640223667872223, 0.6034004604443908, 0.5805023299868811, 0.5493806966749782, 0.5178858606483449, 0.500999446132813, 0.4832796, 0.460667, 0.47479944, 0.42715, 0.41295, 0.39818,0.387744, 0.383766]
+
+train_accuracies = [53.27, 66.35, 71.0, 73.23, 74.88, 76.48, 77.46, 79.1, 79.7, 80.81, 81.81, 82.51, 83.02, 83.99, 83.45, 85.1, 85.44, 86.01, 86.52, 86.57]  
+
+val_losses = [1.0182, 0.8836, 0.8109, 0.775, 0.7249, 0.7244, 0.7125, 0.6808, 0.6616, 0.6461, 0.6628, 0.622, 0.6296, 0.6310, 0.6382, 0.6436, 0.6271, 0.7244, 0.7164, 0.6104]  
+val_accuracies = [63, 68, 71, 73, 75, 74, 75, 76, 77, 77, 76, 79, 78,77,  79, 78, 79, 78,77, 79]  
+
+
+plt.figure(figsize=(10, 5))
+plt.subplot(1, 2, 1)
+plt.plot(epochs, train_losses, label='Training Loss')
+plt.plot(epochs, val_losses, label='Validation Loss')
+plt.title('Training and Validation Loss')
+plt.xlabel('Epoch')
+plt.ylabel('Loss')
+plt.legend()
+
+
+plt.subplot(1, 2, 2)
+plt.plot(epochs, train_accuracies, label='Training Accuracy')
+plt.plot(epochs, val_accuracies, label='Validation Accuracy')
+plt.title('Training and Validation Accuracy')
+plt.xlabel('Epoch')
+plt.ylabel('Accuracy')
+plt.legend()
+
+
+plt.tight_layout()
+plt.show()

plot_normal.py

@@ -0,0 +1,142 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import Image
+import torchvision.datasets as dsets
+import seaborn as sn
+
+
+
+
+#training parameters
+modellr = 1e-4
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+full_dataset =  dsets.CIFAR10(root='./data', train=True, download=True, transform = transform_train)
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(full_dataset))
+val_size = len(full_dataset) - train_size
+
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(full_dataset, [train_size, val_size])
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+criterion = nn.CrossEntropyLoss()
+model = torchvision.models.resnet18(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+model = torch.load("666cifar_model_resnet18_lr0.0001.pth")
+
+
+
+
+
+
+from sklearn.metrics import confusion_matrix
+import seaborn as sn
+import matplotlib.pyplot as plt
+
+def get_predictions(model, device, data_loader):
+    model.eval()
+    model.to(device)
+    all_predictions = []
+    all_targets = []
+
+    with torch.no_grad():
+        for data, target in data_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            all_predictions.extend(predicted.cpu().numpy())
+            all_targets.extend(target.cpu().numpy())
+
+    return np.array(all_predictions), np.array(all_targets)
+
+# Get predictions and targets
+predictions, targets = get_predictions(model, DEVICE, test_loader)
+
+# Create confusion matrix
+conf_matrix = confusion_matrix(targets, predictions)
+
+# Plot heatmap
+plt.figure(figsize=(10, 8))
+sn.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=range(10), yticklabels=range(10))
+plt.xlabel('Predicted Label')
+plt.ylabel('True Label')
+plt.title('Confusion Matrix')
+plt.show()

plot_unbalanced.py

@@ -0,0 +1,183 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import ImageS
+import torchvision.datasets as dsets
+
+
+
+class ModifiedCIFAR10(Dataset):
+    def __init__(self, root, train=True, transform=None, target_classes=[0, 1, 2, 3,4,5,6,7,8,9], num_samples=[500, 500, 2500, 2500,5000,5000,5000,5000,5000,5000]):
+        self.original_dataset = dsets.CIFAR10(root=root, train=train, download=True, transform=transform)
+        self.target_classes = target_classes
+        self.num_samples = num_samples
+
+        self.sample_indices = []
+        for target_class, num_sample in zip(target_classes, num_samples):
+            class_indices = [i for i, label in enumerate(self.original_dataset.targets) if label == target_class]
+            self.sample_indices += class_indices[:num_sample]
+
+    def __len__(self):
+        return len(self.sample_indices)
+
+    def __getitem__(self, idx):
+        original_idx = self.sample_indices[idx]
+        return self.original_dataset[original_idx]
+
+
+
+
+
+#training parameters
+modellr = 1e-4
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Modify the number of samples for class 0 from 5000 to 500
+modified_train_dataset = ModifiedCIFAR10(
+    root='./data',
+    train=True,
+    transform=transform_train,
+    target_classes=[0, 1, 2, 3,4,5,6,7,8,9],
+    num_samples=[500, 500, 2500, 2500,5000,5000,5000,5000,5000,5000]
+)
+
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(modified_train_dataset))
+val_size = len(modified_train_dataset) - train_size
+
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(modified_train_dataset, [train_size, val_size])
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+
+
+criterion = nn.CrossEntropyLoss()
+#First balance method
+
+# Calculate class weights
+#class_weights = torch.FloatTensor([num_samples[i] / len(modified_train_dataset) for i in range(10)])
+# Instantiate CrossEntropyLoss with class weights
+#criterion = nn.CrossEntropyLoss(weight=class_weights.to(DEVICE))
+
+
+model = torchvision.models.resnet18(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+
+model = torch.load("666cifar_model_resnet18_lr0.0001_unbalanced_crossentropy.pth")
+
+
+
+
+
+
+from sklearn.metrics import confusion_matrix
+import seaborn as sn
+import matplotlib.pyplot as plt
+
+def get_predictions(model, device, data_loader):
+    model.eval()
+    model.to(device)
+    all_predictions = []
+    all_targets = []
+
+    with torch.no_grad():
+        for data, target in data_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            all_predictions.extend(predicted.cpu().numpy())
+            all_targets.extend(target.cpu().numpy())
+
+    return np.array(all_predictions), np.array(all_targets)
+
+# Get predictions and targets
+predictions, targets = get_predictions(model, DEVICE, test_loader)
+
+# Create confusion matrix
+conf_matrix = confusion_matrix(targets, predictions)
+
+# Plot heatmap
+plt.figure(figsize=(10, 8))
+sn.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=range(10), yticklabels=range(10))
+plt.xlabel('Predicted Label')
+plt.ylabel('True Label')
+plt.title('Confusion Matrix')
+plt.show()

resnet.py

@@ -0,0 +1,193 @@
+import torch.optim as optim
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.optim
+import torch.utils.data
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.models
+from torch.autograd import Variable
+from torch.utils.data import random_split
+import os
+import time
+import numpy as np
+import pandas as pd
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+from PIL import Image
+import torchvision.datasets as dsets
+
+
+
+#training parameters
+modellr = 1e-4
+BATCH_SIZE = 64
+EPOCHS = 20
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+# Add these variables to keep track of the best accuracy and epoch number
+best_accuracy = 0
+best_epoch = 0
+
+np.random.seed(42)
+torch.manual_seed(42)
+
+
+#data preprocess
+mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]
+# These values are mostly used by researchers as found to very useful in fast convergence
+
+transform_train = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.RandomHorizontalFlip(),
+    transforms.RandomRotation(30), 
+    #newly added
+    transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images
+                           contrast = 0.1, 
+                           saturation = 0.1), 
+    transforms.RandomAdjustSharpness(sharpness_factor = 2, p = 0.1), # Randomly adjust sharpness
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+    transforms.RandomErasing()
+])
+transform_test = transforms.Compose([
+    transforms.Resize((32, 32)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean, std),
+])
+
+full_dataset =  dsets.CIFAR10(root='./data', train=True, download=True, transform = transform_train)
+test_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = transform_test)
+
+# Split the dataset into training and validation sets
+train_size = int(0.9 * len(full_dataset))
+val_size = len(full_dataset) - train_size
+
+torch.manual_seed(42)
+train_dataset, validation_dataset = random_split(full_dataset, [train_size, val_size])
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE,  shuffle=False)
+
+val_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=BATCH_SIZE, shuffle=False)
+
+
+
+
+
+#model & training settings
+criterion = nn.CrossEntropyLoss()
+model = torchvision.models.resnet101(pretrained=True)
+num_ftrs = model.fc.in_features
+model.fc = nn.Linear(num_ftrs, 10)
+model.to(DEVICE)
+
+optimizer = optim.Adam(model.parameters(), lr=modellr)
+
+
+#Learning rate adjust (no need)
+def adjust_learning_rate(optimizer, epoch):
+    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
+    modellrnew = modellr * (0.1 ** (epoch // 50))
+    print("lr:", modellrnew)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = modellrnew
+
+
+#Training method
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+    sum_loss = 0
+    correct = 0
+    total_num = len(train_loader.dataset)
+    print(total_num, len(train_loader))
+    
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = Variable(data).to(device), Variable(target).to(device)
+        output = model(data)
+        loss = criterion(output, target)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        
+        print_loss = loss.data.item()
+        sum_loss += print_loss
+
+        _, pred = torch.max(output.data, 1)
+        correct += torch.sum(pred == target)
+
+        if (batch_idx + 1) % 50 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
+                       100. * (batch_idx + 1) / len(train_loader), loss.item()))
+
+    accuracy = correct / total_num
+    ave_loss = sum_loss / len(train_loader)
+    print('epoch:{}, loss:{}, Training Accuracy: {:.2%}'.format(epoch, ave_loss, accuracy))
+
+
+
+# Modify the val function to update the best model when a higher accuracy is achieved
+
+        
+
+def val(model, device, test_loader, epoch):
+    global best_accuracy, best_epoch
+    model.eval()
+    test_loss = 0
+    correct = 0
+    total_num = len(test_loader.dataset)
+    print(total_num, len(test_loader))
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = Variable(data).to(device), Variable(target).to(device)
+            output = model(data)
+            loss = criterion(output, target)
+            _, pred = torch.max(output.data, 1)
+            correct += torch.sum(pred == target)
+            print_loss = loss.data.item()
+            test_loss += print_loss
+        correct = correct.data.item()
+        acc = correct / total_num
+        avgloss = test_loss / len(test_loader)
+        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+            avgloss, correct, len(test_loader.dataset), 100 * acc))
+                # Check if this epoch's accuracy is better than the best so far
+        if acc > best_accuracy:
+            best_accuracy, best_epoch = acc, epoch
+            # Save the best model
+            torch.save(model, '666cifar_model_resnet101_lr0.0001.pth')
+            
+            
+# Test the model on the test set
+def test(model, device, test_loader):
+    model.eval()
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            outputs = model(data)
+            _, predicted = torch.max(outputs.data, 1)
+            total += target.size(0)
+            correct += (predicted == target).sum().item()
+
+    accuracy = correct / total
+    print('Test Accuracy: {:.2%} ({}/{})'.format(accuracy, correct, total))
+
+
+
+# Train the model and track the best model
+for epoch in range(1, EPOCHS + 1):
+    adjust_learning_rate(optimizer, epoch)
+    train(model, DEVICE, train_loader, optimizer, epoch)
+    val(model, DEVICE, val_loader, epoch)
+    test(model, DEVICE, test_loader)
+
+
+print(f"Best model achieved at epoch {best_epoch} with accuracy: {best_accuracy * 100:.2f}%")