diff --git a/tutorials/01-basics/feedforward_neural_network/main.py b/tutorials/01-basics/feedforward_neural_network/main.py index 0c766a7e..8943b524 100644 --- a/tutorials/01-basics/feedforward_neural_network/main.py +++ b/tutorials/01-basics/feedforward_neural_network/main.py @@ -5,9 +5,9 @@ # Device configuration -device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") -# Hyper-parameters +# Hyper-parameters input_size = 784 hidden_size = 500 num_classes = 10 @@ -15,80 +15,88 @@ batch_size = 100 learning_rate = 0.001 -# MNIST dataset -train_dataset = torchvision.datasets.MNIST(root='../../data', - train=True, - transform=transforms.ToTensor(), - download=True) +# MNIST dataset +train_dataset = torchvision.datasets.MNIST( + root="../../data", train=True, transform=transforms.ToTensor(), download=True +) -test_dataset = torchvision.datasets.MNIST(root='../../data', - train=False, - transform=transforms.ToTensor()) +test_dataset = torchvision.datasets.MNIST( + root="../../data", train=False, transform=transforms.ToTensor() +) # Data loader -train_loader = torch.utils.data.DataLoader(dataset=train_dataset, - batch_size=batch_size, - shuffle=True) +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 +) -test_loader = torch.utils.data.DataLoader(dataset=test_dataset, - batch_size=batch_size, - shuffle=False) # Fully connected neural network with one hidden layer class NeuralNet(nn.Module): def __init__(self, input_size, hidden_size, num_classes): super(NeuralNet, self).__init__() - self.fc1 = nn.Linear(input_size, hidden_size) + self.fc1 = nn.Linear(input_size, hidden_size) self.relu = nn.ReLU() - self.fc2 = nn.Linear(hidden_size, num_classes) - + self.fc2 = nn.Linear(hidden_size, num_classes) + def forward(self, x): out = self.fc1(x) out = self.relu(out) out = self.fc2(out) return out + model = NeuralNet(input_size, hidden_size, num_classes).to(device) # Loss and optimizer criterion = nn.CrossEntropyLoss() -optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) +optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # Train the model total_step = len(train_loader) for epoch in range(num_epochs): - for i, (images, labels) in enumerate(train_loader): + for i, (images, labels) in enumerate(train_loader): # Move tensors to the configured device - images = images.reshape(-1, 28*28).to(device) + images = images.reshape(-1, 28 * 28).to(device) labels = labels.to(device) - + # Forward pass outputs = model(images) loss = criterion(outputs, labels) - + # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() - - if (i+1) % 100 == 0: - print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' - .format(epoch+1, num_epochs, i+1, total_step, loss.item())) + + if (i + 1) % 100 == 0: + print( + "Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}".format( + epoch + 1, num_epochs, i + 1, total_step, loss.item() + ) + ) # Test the model # In test phase, we don't need to compute gradients (for memory efficiency) -with torch.no_grad(): +with torch.inference_mode(): correct = 0 total = 0 for images, labels in test_loader: - images = images.reshape(-1, 28*28).to(device) + images = images.reshape(-1, 28 * 28).to(device) labels = labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() - print('Accuracy of the network on the 10000 test images: {} %'.format(100 * correct / total)) + print( + "Accuracy of the network on the 10000 test images: {} %".format( + 100 * correct / total + ) + ) # Save the model checkpoint -torch.save(model.state_dict(), 'model.ckpt') \ No newline at end of file +torch.save(model.state_dict(), "model.ckpt") diff --git a/tutorials/01-basics/logistic_regression/main.py b/tutorials/01-basics/logistic_regression/main.py index c7eb378b..6032fc35 100644 --- a/tutorials/01-basics/logistic_regression/main.py +++ b/tutorials/01-basics/logistic_regression/main.py @@ -4,39 +4,38 @@ import torchvision.transforms as transforms -# Hyper-parameters -input_size = 28 * 28 # 784 +# Hyper-parameters +input_size = 28 * 28 # 784 num_classes = 10 num_epochs = 5 batch_size = 100 learning_rate = 0.001 # MNIST dataset (images and labels) -train_dataset = torchvision.datasets.MNIST(root='../../data', - train=True, - transform=transforms.ToTensor(), - download=True) +train_dataset = torchvision.datasets.MNIST( + root="../../data", train=True, transform=transforms.ToTensor(), download=True +) -test_dataset = torchvision.datasets.MNIST(root='../../data', - train=False, - transform=transforms.ToTensor()) +test_dataset = torchvision.datasets.MNIST( + root="../../data", train=False, transform=transforms.ToTensor() +) # Data loader (input pipeline) -train_loader = torch.utils.data.DataLoader(dataset=train_dataset, - batch_size=batch_size, - shuffle=True) +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) +test_loader = torch.utils.data.DataLoader( + dataset=test_dataset, batch_size=batch_size, shuffle=False +) # Logistic regression model model = nn.Linear(input_size, num_classes) # Loss and optimizer # nn.CrossEntropyLoss() computes softmax internally -criterion = nn.CrossEntropyLoss() -optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) +criterion = nn.CrossEntropyLoss() +optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) # Train the model total_step = len(train_loader) @@ -44,23 +43,26 @@ for i, (images, labels) in enumerate(train_loader): # Reshape images to (batch_size, input_size) images = images.reshape(-1, input_size) - + # Forward pass outputs = model(images) loss = criterion(outputs, labels) - + # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() - - if (i+1) % 100 == 0: - print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' - .format(epoch+1, num_epochs, i+1, total_step, loss.item())) + + if (i + 1) % 100 == 0: + print( + "Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}".format( + epoch + 1, num_epochs, i + 1, total_step, loss.item() + ) + ) # Test the model # In test phase, we don't need to compute gradients (for memory efficiency) -with torch.no_grad(): +with torch.inference_mode(): correct = 0 total = 0 for images, labels in test_loader: @@ -70,7 +72,11 @@ total += labels.size(0) correct += (predicted == labels).sum() - print('Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total)) + print( + "Accuracy of the model on the 10000 test images: {} %".format( + 100 * correct / total + ) + ) # Save the model checkpoint -torch.save(model.state_dict(), 'model.ckpt') +torch.save(model.state_dict(), "model.ckpt") diff --git a/tutorials/01-basics/pytorch_basics/main.py b/tutorials/01-basics/pytorch_basics/main.py index 744400c2..c9d4f7ac 100644 --- a/tutorials/01-basics/pytorch_basics/main.py +++ b/tutorials/01-basics/pytorch_basics/main.py @@ -1,4 +1,4 @@ -import torch +import torch import torchvision import torch.nn as nn import numpy as np @@ -15,7 +15,7 @@ # 4. Input pipline (Line 104 to 129) # 5. Input pipline for custom dataset (Line 136 to 156) # 6. Pretrained model (Line 163 to 176) -# 7. Save and load model (Line 183 to 189) +# 7. Save and load model (Line 183 to 189) # ================================================================== # @@ -23,20 +23,20 @@ # ================================================================== # # Create tensors. -x = torch.tensor(1., requires_grad=True) -w = torch.tensor(2., requires_grad=True) -b = torch.tensor(3., requires_grad=True) +x = torch.tensor(1.0, requires_grad=True) +w = torch.tensor(2.0, requires_grad=True) +b = torch.tensor(3.0, requires_grad=True) # Build a computational graph. -y = w * x + b # y = 2 * x + 3 +y = w * x + b # y = 2 * x + 3 # Compute gradients. y.backward() # Print out the gradients. -print(x.grad) # x.grad = 2 -print(w.grad) # w.grad = 1 -print(b.grad) # b.grad = 1 +print(x.grad) # x.grad = 2 +print(w.grad) # w.grad = 1 +print(b.grad) # b.grad = 1 # ================================================================== # @@ -49,8 +49,8 @@ # Build a fully connected layer. linear = nn.Linear(3, 2) -print ('w: ', linear.weight) -print ('b: ', linear.bias) +print("w: ", linear.weight) +print("b: ", linear.bias) # Build loss function and optimizer. criterion = nn.MSELoss() @@ -61,14 +61,14 @@ # Compute loss. loss = criterion(pred, y) -print('loss: ', loss.item()) +print("loss: ", loss.item()) # Backward pass. loss.backward() # Print out the gradients. -print ('dL/dw: ', linear.weight.grad) -print ('dL/db: ', linear.bias.grad) +print("dL/dw: ", linear.weight.grad) +print("dL/db: ", linear.bias.grad) # 1-step gradient descent. optimizer.step() @@ -80,7 +80,7 @@ # Print out the loss after 1-step gradient descent. pred = linear(x) loss = criterion(pred, y) -print('loss after 1 step optimization: ', loss.item()) +print("loss after 1 step optimization: ", loss.item()) # ================================================================== # @@ -102,20 +102,19 @@ # ================================================================== # # Download and construct CIFAR-10 dataset. -train_dataset = torchvision.datasets.CIFAR10(root='../../data/', - train=True, - transform=transforms.ToTensor(), - download=True) +train_dataset = torchvision.datasets.CIFAR10( + root="../../data/", train=True, transform=transforms.ToTensor(), download=True +) # Fetch one data pair (read data from disk). image, label = train_dataset[0] -print (image.size()) -print (label) +print(image.size()) +print(label) # Data loader (this provides queues and threads in a very simple way). -train_loader = torch.utils.data.DataLoader(dataset=train_dataset, - batch_size=64, - shuffle=True) +train_loader = torch.utils.data.DataLoader( + dataset=train_dataset, batch_size=64, shuffle=True +) # When iteration starts, queue and thread start to load data from files. data_iter = iter(train_loader) @@ -133,27 +132,31 @@ # 5. Input pipeline for custom dataset # # ================================================================== # + # You should build your custom dataset as below. class CustomDataset(torch.utils.data.Dataset): def __init__(self): # TODO - # 1. Initialize file paths or a list of file names. + # 1. Initialize file paths or a list of file names. pass + def __getitem__(self, index): # TODO # 1. Read one data from file (e.g. using numpy.fromfile, PIL.Image.open). # 2. Preprocess the data (e.g. torchvision.Transform). # 3. Return a data pair (e.g. image and label). pass + def __len__(self): # You should change 0 to the total size of your dataset. - return 0 + return 0 + -# You can then use the prebuilt data loader. +# You can then use the prebuilt data loader. custom_dataset = CustomDataset() -train_loader = torch.utils.data.DataLoader(dataset=custom_dataset, - batch_size=64, - shuffle=True) +train_loader = torch.utils.data.DataLoader( + dataset=custom_dataset, batch_size=64, shuffle=True +) # ================================================================== # @@ -173,7 +176,7 @@ def __len__(self): # Forward pass. images = torch.randn(64, 3, 224, 224) outputs = resnet(images) -print (outputs.size()) # (64, 100) +print(outputs.size()) # (64, 100) # ================================================================== # @@ -181,9 +184,9 @@ def __len__(self): # ================================================================== # # Save and load the entire model. -torch.save(resnet, 'model.ckpt') -model = torch.load('model.ckpt') +torch.save(resnet, "model.ckpt") +model = torch.load("model.ckpt") # Save and load only the model parameters (recommended). -torch.save(resnet.state_dict(), 'params.ckpt') -resnet.load_state_dict(torch.load('params.ckpt')) +torch.save(resnet.state_dict(), "params.ckpt") +resnet.load_state_dict(torch.load("params.ckpt"))