|
Download README.md from fish-Monger/ResNet: direct link, hf CLI and curl.
- Browser
- Download file 4.52 kB
-
https://huggingface.co/fish-Monger/ResNet/resolve/main/README.md
- Command line
-
hf download hf://fish-Monger/ResNet/README.md
-
curl -L -o README.md https://huggingface.co/fish-Monger/ResNet/resolve/main/README.md
4.52 kB
| license: mit | |
| Libraries needed: | |
| ``` | |
| import torch | |
| import torchvision | |
| import torchvision.transforms as transforms | |
| from tqdm import tqdm | |
| from torch import nn | |
| import matplotlib.pyplot as plt | |
| ``` | |
| to define a data loader | |
| ``` | |
| transformRes = transforms.Compose([ | |
| transforms.ToTensor(), | |
| transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), | |
| # transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) | |
| ]) | |
| trainsetRes = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transformRes) | |
| trainloaderRes64 = torch.utils.data.DataLoader(trainsetRes, batch_size=64, shuffle=True, num_workers=10) | |
| testsetRes = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transformRes) | |
| testloaderRes64 = torch.utils.data.DataLoader(testsetRes, batch_size=64, shuffle=False, num_workers=10) | |
| ``` | |
| The model itself and training | |
| ``` | |
| import torchvision.models as models | |
| # Load the pretrained model from pytorch | |
| resnet50v2 = models.resnet50(pretrained=True) | |
| # Freeze the parameters of the model | |
| for param in resnet50v2.parameters(): | |
| param.requires_grad = True | |
| # Change the final layer to match the number of classes in the CIFAR-10 dataset | |
| num_ftrs = resnet50v2.fc.in_features | |
| resnet50v2.fc = nn.Sequential( | |
| nn.Linear(num_ftrs, 500), | |
| nn.ReLU(), | |
| nn.Linear(500, 200), | |
| nn.Dropout(0.5), | |
| nn.Linear(200,40), | |
| nn.ReLU(), | |
| nn.Dropout(0.3), | |
| nn.Linear(40,10), | |
| nn.ReLU() | |
| ) | |
| print("Model Info:") | |
| print("ResNet50,Pretrained,weight adj. LR=0.01,Mom=0.3,WD=0.0001") | |
| print("Schedule step=1,gamma=0.7, 20 epoches") | |
| # Move the model to the GPU | |
| resnet50v2 = resnet50v2.to(device, dtype=torch.float32) | |
| optimizer = torch.optim.SGD(resnet50v2.parameters(), lr=0.01,momentum=0.3,weight_decay=0.0001) | |
| criterion = nn.CrossEntropyLoss() | |
| scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5) | |
| train_losses = [] | |
| test_losses = [] | |
| accuracies = [] | |
| train_acc = [] | |
| for epoch in range(20): # loop over the dataset multiple times | |
| running_loss = 0.0 | |
| correctTrain = 0 | |
| totalTrain = 0 | |
| pbar = tqdm(enumerate(trainloaderRes16, 0), total=len(trainloaderRes16), desc="Epoch {}".format(epoch+1)) | |
| for i, data in pbar: | |
| # get the inputs; data is a list of [inputs, labels] | |
| inputs, labels = data[0].to(device,dtype=torch.float32), data[1].to(device) | |
| # zero the parameter gradients | |
| optimizer.zero_grad() | |
| # forward + backward + optimize | |
| outputs = resnet50v2(inputs) | |
| loss = criterion(outputs, labels) | |
| loss.backward() | |
| optimizer.step() | |
| # print statistics | |
| running_loss += loss.item() | |
| _, predicted_train = torch.max(outputs.data, 1) | |
| totalTrain += labels.size(0) | |
| correctTrain += (predicted_train == labels).sum().item() | |
| pbar.set_postfix({'loss': running_loss/(i+1)}) | |
| train_accuracy = 100 * correctTrain / totalTrain | |
| train_acc.append(train_accuracy) | |
| print(f'Epoch {epoch + 1} loss: {running_loss / len(trainloaderRes16):.3f}') | |
| # Start of testing phase | |
| resnet50v2.eval() # Set the model to evaluation mode | |
| test_loss = 0.0 | |
| correct = 0 | |
| total = 0 | |
| with torch.no_grad(): | |
| for data in testloaderRes16: | |
| images, labels = data[0].to(device,dtype=torch.float32), data[1].to(device) | |
| outputs = resnet50v2(images) | |
| loss = criterion(outputs, labels) | |
| test_loss += loss.item() | |
| _, predicted = torch.max(outputs.data, 1) | |
| total += labels.size(0) | |
| correct += (predicted == labels).sum().item() | |
| print(f'Epoch {epoch + 1} Test loss: {test_loss / len(testloaderRes16):.3f}, Accuracy: {100 * correct / total:.2f}%') | |
| #print the learning rate | |
| print(f'Epoch {epoch + 1} Learning rate: {optimizer.param_groups[0]["lr"]}') | |
| train_losses.append(running_loss / len(trainloaderRes16)) | |
| test_losses.append(test_loss / len(testloaderRes16)) | |
| accuracies.append(100 * correct / total) | |
| resnet50v2.train() # Set the model back to training model | |
| scheduler.step() | |
| print('Finished Training') | |
| plt.figure(figsize=(10, 5)) | |
| plt.plot(train_losses, label='Training Loss') | |
| plt.plot(test_losses, label='Test Loss') | |
| plt.xlabel('Epochs') | |
| plt.ylabel('Loss') | |
| plt.legend() | |
| plt.show() | |
| plt.figure(figsize=(10, 5)) | |
| plt.plot(accuracies, label='Accuracy') | |
| plt.plot(train_acc, label='Training Accuracy') | |
| plt.xlabel('Epochs') | |
| plt.ylabel('Accuracy (%)') | |
| plt.legend() | |
| plt.show() | |
| ``` | |