Merge branch 'master' of https://github.com/aladdinpersson/Machine-Learning-Collection

Author: aladdinpersson

ML/Pytorch/Basics/pytorch_rnn_gru_lstm.py

@@ -8,15 +8,14 @@
 
 # Imports
 import torch
-import torchvision
-import torch.nn as nn # All neural network modules, nn.Linear, nn.Conv2d, BatchNorm, Loss functions
-import torch.optim as optim # For all Optimization algorithms, SGD, Adam, etc.
-import torch.nn.functional as F # All functions that don't have any parameters
-from torch.utils.data import (
- DataLoader,
-) # Gives easier dataset managment and creates mini batches
-import torchvision.datasets as datasets # Has standard datasets we can import in a nice way
-import torchvision.transforms as transforms # Transformations we can perform on our dataset
+import torchvision # torch package for vision related things
+import torch.nn.functional as F # Parameterless functions, like (some) activation functions
+import torchvision.datasets as datasets # Standard datasets
+import torchvision.transforms as transforms # Transformations we can perform on our dataset for augmentation
+from torch import optim # For optimizers like SGD, Adam, etc.
+from torch import nn # All neural network modules
+from torch.utils.data import DataLoader # Gives easier dataset managment by creating mini batches etc.
+from tqdm import tqdm # For a nice progress bar!
 
 # Set device
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
@@ -29,7 +28,7 @@
 sequence_length = 28
 learning_rate = 0.005
 batch_size = 64
-num_epochs = 2
+num_epochs = 3
 
 # Recurrent neural network (many-to-one)
 class RNN(nn.Module):
@@ -101,18 +100,12 @@ def forward(self, x):
 
 
 # Load Data
-train_dataset = datasets.MNIST(
- root="dataset/", train=True, transform=transforms.ToTensor(), download=True
-)
-
-test_dataset = datasets.MNIST(
- root="dataset/", train=False, transform=transforms.ToTensor(), download=True
-)
-
+train_dataset = datasets.MNIST(root="dataset/", train=True, transform=transforms.ToTensor(), download=True)
+test_dataset = datasets.MNIST(root="dataset/", train=False, transform=transforms.ToTensor(), download=True)
 train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
 test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)
 
-# Initialize network
+# Initialize network (try out just using simple RNN, or GRU, and then compare with LSTM)
 model = RNN_LSTM(input_size, hidden_size, num_layers, num_classes).to(device)
 
 # Loss and optimizer
@@ -121,7 +114,7 @@ def forward(self, x):
 
 # Train Network
 for epoch in range(num_epochs):
- for batch_idx, (data, targets) in enumerate(train_loader):
+ for batch_idx, (data, targets) in enumerate(tqdm(train_loader)):
  # Get data to cuda if possible
  data = data.to(device=device).squeeze(1)
  targets = targets.to(device=device)
@@ -134,16 +127,11 @@ def forward(self, x):
  optimizer.zero_grad()
  loss.backward()
 
- # gradient descent or adam step
+ # gradient descent update step/adam step
  optimizer.step()
 
 # Check accuracy on training & test to see how good our model
 def check_accuracy(loader, model):
- if loader.dataset.train:
- print("Checking accuracy on training data")
- else:
- print("Checking accuracy on test data")
-
  num_correct = 0
  num_samples = 0
 
@@ -160,13 +148,10 @@ def check_accuracy(loader, model):
  num_correct += (predictions == y).sum()
  num_samples += predictions.size(0)
 
- print(
- f"Got {num_correct} / {num_samples} with \
- accuracy {float(num_correct)/float(num_samples)*100:.2f}"
- )
- # Set model back to train
+ # Toggle model back to train
  model.train()
+ return num_correct / num_samples
 
 
-check_accuracy(train_loader, model)
-check_accuracy(test_loader, model)
+print(f"Accuracy on training set: {check_accuracy(train_loader, model)*100:2f}")
+print(f"Accuracy on test set: {check_accuracy(test_loader, model)*100:.2f}")

ML/Pytorch/Basics/pytorch_simple_CNN.py

@@ -1,34 +1,33 @@
 """
-Example code of a simple CNN network training on MNIST dataset.
-The code is intended to show how to create a CNN network as well
-as how to initialize loss, optimizer, etc. in a simple way to get
-training to work with function that checks accuracy as well.
+A simple walkthrough of how to code a convolutional neural network (CNN)
+using the PyTorch library. For demonstration we train it on the very
+common MNIST dataset of handwritten digits. In this code we go through
+how to create the network as well as initialize a loss function, optimizer,
+check accuracy and more.
 
-Video explanation: https://youtu.be/wnK3uWv_WkU
-Got any questions leave a comment on youtube :)
-
-Programmed by Aladdin Persson <aladdin.persson at hotmail dot com>
-* 2020-04-08 Initial coding
+Programmed by Aladdin Persson
+* 2020-04-08: Initial coding
+* 2021-03-24: More detailed comments and small revision of the code
 
 """
 
 # Imports
 import torch
-import torch.nn as nn # All neural network modules, nn.Linear, nn.Conv2d, BatchNorm, Loss functions
-import torch.optim as optim # For all Optimization algorithms, SGD, Adam, etc.
-import torch.nn.functional as F # All functions that don't have any parameters
-from torch.utils.data import (
- DataLoader,
-) # Gives easier dataset managment and creates mini batches
-import torchvision.datasets as datasets # Has standard datasets we can import in a nice way
-import torchvision.transforms as transforms # Transformations we can perform on our dataset
+import torchvision # torch package for vision related things
+import torch.nn.functional as F # Parameterless functions, like (some) activation functions
+import torchvision.datasets as datasets # Standard datasets
+import torchvision.transforms as transforms # Transformations we can perform on our dataset for augmentation
+from torch import optim # For optimizers like SGD, Adam, etc.
+from torch import nn # All neural network modules
+from torch.utils.data import DataLoader # Gives easier dataset managment by creating mini batches etc.
+from tqdm import tqdm # For nice progress bar!
 
 # Simple CNN
 class CNN(nn.Module):
  def __init__(self, in_channels=1, num_classes=10):
  super(CNN, self).__init__()
  self.conv1 = nn.Conv2d(
- in_channels=1,
+ in_channels=in_channels,
  out_channels=8,
  kernel_size=(3, 3),
  stride=(1, 1),
@@ -51,40 +50,35 @@ def forward(self, x):
  x = self.pool(x)
  x = x.reshape(x.shape[0], -1)
  x = self.fc1(x)
-
  return x
 
 
 # Set device
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 # Hyperparameters
-in_channel = 1
+in_channels = 1
 num_classes = 10
 learning_rate = 0.001
 batch_size = 64
-num_epochs = 5
+num_epochs = 3
 
 # Load Data
-train_dataset = datasets.MNIST(
- root="dataset/", train=True, transform=transforms.ToTensor(), download=True
-)
+train_dataset = datasets.MNIST(root="dataset/", train=True, transform=transforms.ToTensor(), download=True)
+test_dataset = datasets.MNIST(root="dataset/", train=False, transform=transforms.ToTensor(), download=True)
 train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
-test_dataset = datasets.MNIST(
- root="dataset/", train=False, transform=transforms.ToTensor(), download=True
-)
 test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)
 
 # Initialize network
-model = CNN().to(device)
+model = CNN(in_channels=in_channels, num_classes=num_classes).to(device)
 
 # Loss and optimizer
 criterion = nn.CrossEntropyLoss()
 optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
 # Train Network
 for epoch in range(num_epochs):
- for batch_idx, (data, targets) in enumerate(train_loader):
+ for batch_idx, (data, targets) in enumerate(tqdm(train_loader)):
  # Get data to cuda if possible
  data = data.to(device=device)
  targets = targets.to(device=device)
@@ -101,14 +95,7 @@ def forward(self, x):
  optimizer.step()
 
 # Check accuracy on training & test to see how good our model
-
-
 def check_accuracy(loader, model):
- if loader.dataset.train:
- print("Checking accuracy on training data")
- else:
- print("Checking accuracy on test data")
-
  num_correct = 0
  num_samples = 0
  model.eval()
@@ -123,12 +110,10 @@ def check_accuracy(loader, model):
  num_correct += (predictions == y).sum()
  num_samples += predictions.size(0)
 
- print(
- f"Got {num_correct} / {num_samples} with accuracy {float(num_correct)/float(num_samples)*100:.2f}"
- )
 
  model.train()
+ return num_correct/num_samples
 
 
-check_accuracy(train_loader, model)
-check_accuracy(test_loader, model)
+print(f"Accuracy on training set: {check_accuracy(train_loader, model)*100:.2f}")
+print(f"Accuracy on test set: {check_accuracy(test_loader, model)*100:.2f}")

ML/Pytorch/Basics/pytorch_simple_fullynet.py

@@ -1,60 +1,69 @@
 """
-Working code of a simple Fully Connected (FC) network training on MNIST dataset.
-The code is intended to show how to create a FC network as well
-as how to initialize loss, optimizer, etc. in a simple way to get
-training to work with function that checks accuracy as well.
+A simple walkthrough of how to code a fully connected neural network
+using the PyTorch library. For demonstration we train it on the very
+common MNIST dataset of handwritten digits. In this code we go through
+how to create the network as well as initialize a loss function, optimizer,
+check accuracy and more.
 
-Video explanation: https://youtu.be/Jy4wM2X21u0
-Got any questions leave a comment on youtube :)
-
-Programmed by Aladdin Persson <aladdin.persson at hotmail dot com>
-* 2020-04-08 Initial coding
+Programmed by Aladdin Persson
+* 2020-04-08: Initial coding
+* 2021-03-24: Added more detailed comments also removed part of
+ check_accuracy which would only work specifically on MNIST.
 
 """
 
 # Imports
 import torch
-import torchvision
-import torch.nn as nn # All neural network modules, nn.Linear, nn.Conv2d, BatchNorm, Loss functions
-import torch.optim as optim # For all Optimization algorithms, SGD, Adam, etc.
-import torch.nn.functional as F # All functions that don't have any parameters
-from torch.utils.data import (
- DataLoader,
-) # Gives easier dataset managment and creates mini batches
-import torchvision.datasets as datasets # Has standard datasets we can import in a nice way
-import torchvision.transforms as transforms # Transformations we can perform on our dataset
-
-# Create Fully Connected Network
+import torchvision # torch package for vision related things
+import torch.nn.functional as F # Parameterless functions, like (some) activation functions
+import torchvision.datasets as datasets # Standard datasets
+import torchvision.transforms as transforms # Transformations we can perform on our dataset for augmentation
+from torch import optim # For optimizers like SGD, Adam, etc.
+from torch import nn # All neural network modules
+from torch.utils.data import DataLoader # Gives easier dataset managment by creating mini batches etc.
+from tqdm import tqdm # For nice progress bar!
+
+# Here we create our simple neural network. For more details here we are subclassing and
+# inheriting from nn.Module, this is the most general way to create your networks and
+# allows for more flexibility. I encourage you to also check out nn.Sequential which
+# would be easier to use in this scenario but I wanted to show you something that
+# "always" works.
 class NN(nn.Module):
  def __init__(self, input_size, num_classes):
  super(NN, self).__init__()
+ # Our first linear layer take input_size, in this case 784 nodes to 50
+ # and our second linear layer takes 50 to the num_classes we have, in
+ # this case 10.
  self.fc1 = nn.Linear(input_size, 50)
  self.fc2 = nn.Linear(50, num_classes)
 
  def forward(self, x):
+ """
+ x here is the mnist images and we run it through fc1, fc2 that we created above.
+ we also add a ReLU activation function in between and for that (since it has no parameters)
+ I recommend using nn.functional (F)
+ """
+
  x = F.relu(self.fc1(x))
  x = self.fc2(x)
  return x
 
 
-# Set device
+# Set device cuda for GPU if it's available otherwise run on the CPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-# Hyperparameters
+# Hyperparameters of our neural network which depends on the dataset, and
+# also just experimenting to see what works well (learning rate for example).
 input_size = 784
 num_classes = 10
 learning_rate = 0.001
 batch_size = 64
-num_epochs = 1
+num_epochs = 3
 
-# Load Data
-train_dataset = datasets.MNIST(
- root="dataset/", train=True, transform=transforms.ToTensor(), download=True
-)
+# Load Training and Test data
+train_dataset = datasets.MNIST(root="dataset/", train=True, transform=transforms.ToTensor(), download=True)
+test_dataset = datasets.MNIST(root="dataset/", train=False, transform=transforms.ToTensor(), download=True)
 train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
-test_dataset = datasets.MNIST(
- root="dataset/", train=False, transform=transforms.ToTensor(), download=True
-)
 test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)
 
 # Initialize network
@@ -66,7 +75,7 @@ def forward(self, x):
 
 # Train Network
 for epoch in range(num_epochs):
- for batch_idx, (data, targets) in enumerate(train_loader):
+ for batch_idx, (data, targets) in enumerate(tqdm(train_loader)):
  # Get data to cuda if possible
  data = data.to(device=device)
  targets = targets.to(device=device)
@@ -85,15 +94,9 @@ def forward(self, x):
  # gradient descent or adam step
  optimizer.step()
 
-# Check accuracy on training & test to see how good our model
-
 
+# Check accuracy on training & test to see how good our model
 def check_accuracy(loader, model):
- if loader.dataset.train:
- print("Checking accuracy on training data")
- else:
- print("Checking accuracy on test data")
-
  num_correct = 0
  num_samples = 0
  model.eval()
@@ -109,12 +112,9 @@ def check_accuracy(loader, model):
  num_correct += (predictions == y).sum()
  num_samples += predictions.size(0)
 
- print(
- f"Got {num_correct} / {num_samples} with accuracy {float(num_correct)/float(num_samples)*100:.2f}"
- )
-
  model.train()
+ return num_correct/num_samples
 
 
-check_accuracy(train_loader, model)
-check_accuracy(test_loader, model)
+print(f"Accuracy on training set: {check_accuracy(train_loader, model)*100:.2f}")
+print(f"Accuracy on test set: {check_accuracy(test_loader, model)*100:.2f}")

ML/Pytorch/Basics/pytorch_tensorbasics.py

@@ -11,6 +11,9 @@
 between different types (int, float etc) and how to convert a tensor to an
 numpy array and vice-versa.
 
+Programmed by Aladdin Persson
+* 2020-06-27: Initial coding
+
 """
 
 import torch

ML/Pytorch/CNN_architectures/pytorch_inceptionet.py

@@ -11,7 +11,7 @@
 
 # Imports
 import torch
-import torch.nn as nn # All neural network modules, nn.Linear, nn.Conv2d, BatchNorm, Loss functions
+from torch import nn
 
 
 class GoogLeNet(nn.Module):