Upload 12 files

model_epoch10.pth

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

model_epoch10_lr0.0001_best_epoch.pth

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

model_epoch10_lr0.001.pth

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

model_epoch20_lr0.0001_best_epoch2.pth

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

model_epoch20_lr0.001.pth

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

model_epoch20_lr0.01_best_epoch.pth

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

model_epoch5.pth

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

model_resnet101_epoch5_lr0.0001_best_epoch.pth

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

model_resnet50_epoch5_lr0.0001_best_epoch.pth

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

plot.py

@@ -0,0 +1,19 @@
+import matplotlib.pyplot as plt
+
+
+epochs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+train_accuracy = [99, 99, 98, 98, 98, 99, 98, 99, 98, 99]
+val_accuracy = [99, 99, 98, 98, 98, 99, 98, 99, 98, 99]
+
+
+plt.figure(figsize=(10, 6))
+plt.plot(epochs, train_accuracy, label='Train Accuracy', marker='o')
+plt.plot(epochs, val_accuracy, label='Validation Accuracy', marker='o')
+plt.xlabel('Epochs')
+plt.ylabel('Accuracy (%)')
+plt.title('Training and Validation Accuracy')
+plt.legend()
+plt.grid(True)
+plt.show()
+
+plt.savefig('plot.png')

resnet_test.py

@@ -0,0 +1,43 @@
+import torch.utils.data.distributed
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+from torch.autograd import Variable
+import pandas as pd
+from PIL import Image
+
+classes = ('cat', 'dog')
+transform_test = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
+])
+
+DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model = torch.load("model_epoch20_lr0.0001_best_epoch2.pth")
+model.eval()
+model.to(DEVICE)
+
+
+predictions = []
+
+for index in range(1, 501):
+    img_path = f'datasets/datatest/test/{index}.jpg'  # Assuming file names are 1.jpg, 2.jpg, 3.jpg, etc.
+    
+    # Load the image, preprocess it, and make a prediction
+    img = Image.open(img_path)
+    img = transform_test(img)
+    img = img.unsqueeze(0).to(DEVICE)
+    output = model(img)
+    _, pred = torch.max(output.data, 1)
+    predictions.append(pred.data.item())
+    
+    
+# Create a DataFrame from the predictions
+df = pd.DataFrame(predictions, columns=['prediction'])
+
+
+# Save the DataFrame to an Excel file
+df.to_excel('predictions.xlsx', index=False)
+
+
+

resnet_train.py

@@ -0,0 +1,140 @@
+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.datasets as datasets
+import torchvision.models
+#from effnetv2 import effnetv2_s
+from torch.autograd import Variable
+
+#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
+
+
+#data preprocess
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
+
+])
+transform_test = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
+])
+
+
+
+
+
+dataset_train = datasets.ImageFolder('datasets/datasets/train', transform)
+print(dataset_train.imgs)
+
+print(dataset_train.class_to_idx)
+dataset_test = datasets.ImageFolder('datasets/datasets/val', transform_test)
+
+
+
+train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True)
+test_loader = torch.utils.data.DataLoader(dataset_test, 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, 2)
+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
+    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
+        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()))
+    ave_loss = sum_loss / len(train_loader)
+    print('epoch:{},loss:{}'.format(epoch, ave_loss))
+
+
+# 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
+            best_accuracy = acc
+            best_epoch = epoch
+            # Save the best model
+            torch.save(model, 'model_resnet18_epoch20_lr0.0001_best_epoch.pth')
+
+
+
+# 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, test_loader, epoch)
+
+
+print(f"Best model achieved at epoch {best_epoch} with accuracy: {best_accuracy * 100:.2f}%")
+
+
+