Merge branch 'master' into patch-2

Author: L1aoXingyu

01-Linear Regression/Linear_Regression.py

@@ -1,10 +1,14 @@
-__author__ = 'SherlockLiao'
+# encoding: utf-8
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
 
+import matplotlib.pyplot as plt
+import numpy as np
 import torch
-from torch import nn, optim
+from torch import nn
 from torch.autograd import Variable
-import numpy as np
-import matplotlib.pyplot as plt
 
 x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                     [9.779], [6.182], [7.59], [2.167], [7.042],
@@ -21,26 +25,26 @@
 
 
 # Linear Regression Model
-class LinearRegression(nn.Module):
+class linearRegression(nn.Module):
     def __init__(self):
-        super(LinearRegression, self).__init__()
+        super(linearRegression, self).__init__()
         self.linear = nn.Linear(1, 1)  # input and output is 1 dimension
 
     def forward(self, x):
         out = self.linear(x)
         return out
 
 
-model = LinearRegression()
+model = linearRegression()
 # 定义loss和优化函数
 criterion = nn.MSELoss()
-optimizer = optim.SGD(model.parameters(), lr=1e-4)
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
 
 # 开始训练
 num_epochs = 1000
 for epoch in range(num_epochs):
-    inputs = Variable(x_train)
-    target = Variable(y_train)
+    inputs = x_train
+    target = y_train
 
     # forward
     out = model(inputs)
@@ -51,12 +55,14 @@ def forward(self, x):
     optimizer.step()
 
     if (epoch+1) % 20 == 0:
-        print('Epoch[{}/{}], loss: {:.6f}'
-              .format(epoch+1, num_epochs, loss.data[0]))
+        print(f'Epoch[{epoch+1}/{num_epochs}], loss: {loss.item():.6f}')
 
 model.eval()
-predict = model(Variable(x_train))
+with torch.no_grad():
+    predict = model(x_train)
 predict = predict.data.numpy()
+
+fig = plt.figure(figsize=(10, 5))
 plt.plot(x_train.numpy(), y_train.numpy(), 'ro', label='Original data')
 plt.plot(x_train.numpy(), predict, label='Fitting Line')
 # 显示图例

02-Logistic Regression/Logistic_Regression.py

@@ -1,29 +1,33 @@
-__author__ = 'SherlockLiao'
+# encoding: utf-8
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
+
+
+import time
 
 import torch
-from torch import nn, optim
 import torch.nn.functional as F
-from torch.autograd import Variable
+from torch import nn
 from torch.utils.data import DataLoader
-from torchvision import transforms
-from torchvision import datasets
-import time
+from torchvision import datasets, transforms
+
 # 定义超参数
-batch_size = 32
+batch_size = 64
 learning_rate = 1e-3
-num_epoches = 100
+num_epochs = 100
 
 # 下载训练集 MNIST 手写数字训练集
-train_dataset = datasets.MNIST(
-    root='./data', train=True, transform=transforms.ToTensor(), download=True)
+train_dataset = datasets.FashionMNIST(
+    root='../datasets', train=True, transform=transforms.ToTensor(), download=True)
 
-test_dataset = datasets.MNIST(
-    root='./data', train=False, transform=transforms.ToTensor())
+test_dataset = datasets.FashionMNIST(
+    root='../datasets', train=False, transform=transforms.ToTensor())
 
 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
 
-
 # 定义 Logistic Regression 模型
 class Logistic_Regression(nn.Module):
     def __init__(self, in_dim, n_class):
@@ -41,65 +45,53 @@ def forward(self, x):
     model = model.cuda()
 # 定义loss和optimizer
 criterion = nn.CrossEntropyLoss()
-optimizer = optim.SGD(model.parameters(), lr=learning_rate)
+optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
 
 # 开始训练
-for epoch in range(num_epoches):
+for epoch in range(num_epochs):
     print('*' * 10)
-    print('epoch {}'.format(epoch + 1))
+    print(f'epoch {epoch+1}')
     since = time.time()
     running_loss = 0.0
     running_acc = 0.0
+    model.train()
     for i, data in enumerate(train_loader, 1):
         img, label = data
         img = img.view(img.size(0), -1)  # 将图片展开成 28x28
         if use_gpu:
-            img = Variable(img).cuda()
-            label = Variable(label).cuda()
-        else:
-            img = Variable(img)
-            label = Variable(label)
+            img = img.cuda()
+            label = label.cuda()
         # 向前传播
         out = model(img)
         loss = criterion(out, label)
-        running_loss += loss.data[0] * label.size(0)
+        running_loss += loss.item()
         _, pred = torch.max(out, 1)
-        num_correct = (pred == label).sum()
-        running_acc += num_correct.data[0]
+        running_acc += (pred==label).float().mean()
         # 向后传播
         optimizer.zero_grad()
         loss.backward()
         optimizer.step()
 
         if i % 300 == 0:
-            print('[{}/{}] Loss: {:.6f}, Acc: {:.6f}'.format(
-                epoch + 1, num_epoches, running_loss / (batch_size * i),
-                running_acc / (batch_size * i)))
-    print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
-        epoch + 1, running_loss / (len(train_dataset)), running_acc / (len(
-            train_dataset))))
+            print(f'[{epoch+1}/{num_epochs}] Loss: {running_loss/i:.6f}, Acc: {running_acc/i:.6f}')
+    print(f'Finish {epoch+1} epoch, Loss: {running_loss/i:.6f}, Acc: {running_acc/i:.6f}')
     model.eval()
     eval_loss = 0.
     eval_acc = 0.
     for data in test_loader:
         img, label = data
         img = img.view(img.size(0), -1)
         if use_gpu:
-            img = Variable(img, volatile=True).cuda()
-            label = Variable(label, volatile=True).cuda()
-        else:
-            img = Variable(img, volatile=True)
-            label = Variable(label, volatile=True)
-        out = model(img)
-        loss = criterion(out, label)
-        eval_loss += loss.data[0] * label.size(0)
+            img = img.cuda()
+            label = label.cuda()
+        with torch.no_grad():
+            out = model(img)
+            loss = criterion(out, label)
+        eval_loss += loss.item()
         _, pred = torch.max(out, 1)
-        num_correct = (pred == label).sum()
-        eval_acc += num_correct.data[0]
-    print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
-        test_dataset)), eval_acc / (len(test_dataset))))
-    print('Time:{:.1f} s'.format(time.time() - since))
-    print()
+        eval_acc += (pred == label).float().mean()
+    print(f'Test Loss: {eval_loss/len(test_loader):.6f}, Acc: {eval_acc/len(test_loader):.6f}')
+    print(f'Time:{(time.time()-since):.1f} s')
 
 # 保存模型
 torch.save(model.state_dict(), './logstic.pth')

03-Neural Network/neural_network.py

@@ -1,104 +1,97 @@
-__author__ = 'SherlockLiao'
+"""
+@author:  liaoxingyu
+@contact: sherlockliao01@gmail.com
+"""
 
 import torch
-from torch import nn, optim
-
-from torch.autograd import Variable
+from torch import nn
 from torch.utils.data import DataLoader
-from torchvision import transforms
-from torchvision import datasets
+from torchvision import datasets, transforms
 
-batch_size = 32
+batch_size = 64
 learning_rate = 1e-2
-num_epoches = 50
+num_epochs = 50
+use_gpu = torch.cuda.is_available()
 
 # 下载训练集 MNIST 手写数字训练集
-train_dataset = datasets.MNIST(
-    root='./data', train=True, transform=transforms.ToTensor(), download=True)
+train_dataset = datasets.FashionMNIST(
+    root='../datasets', train=True, transform=transforms.ToTensor(), download=True)
 
-test_dataset = datasets.MNIST(
-    root='./data', train=False, transform=transforms.ToTensor())
+test_dataset = datasets.FashionMNIST(
+    root='../datasets', train=False, transform=transforms.ToTensor())
 
 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
 
 
 # 定义简单的前馈神经网络
-class Neuralnetwork(nn.Module):
+class neuralNetwork(nn.Module):
     def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
-        super(Neuralnetwork, self).__init__()
-        self.layer1 = nn.Linear(in_dim, n_hidden_1)
-        self.layer2 = nn.Linear(n_hidden_1, n_hidden_2)
-        self.layer3 = nn.Linear(n_hidden_2, out_dim)
+        super(neuralNetwork, self).__init__()
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, n_hidden_1),
+            nn.ReLU(True))
+        self.layer2 = nn.Sequential(
+            nn.Linear(n_hidden_1, n_hidden_2),
+            nn.ReLU(True))
+        self.layer3 = nn.Sequential(
+            nn.Linear(n_hidden_2, out_dim),
+            nn.ReLU(True))
 
     def forward(self, x):
         x = self.layer1(x)
         x = self.layer2(x)
         x = self.layer3(x)
         return x
 
-
-model = Neuralnetwork(28 * 28, 300, 100, 10)
-if torch.cuda.is_available():
+model = neuralNetwork(28 * 28, 300, 100, 10)
+if use_gpu:
     model = model.cuda()
 
 criterion = nn.CrossEntropyLoss()
-optimizer = optim.SGD(model.parameters(), lr=learning_rate)
+optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
 
-for epoch in range(num_epoches):
-    print('epoch {}'.format(epoch + 1))
+for epoch in range(num_epochs):
     print('*' * 10)
+    print(f'epoch {epoch+1}')
     running_loss = 0.0
     running_acc = 0.0
     for i, data in enumerate(train_loader, 1):
         img, label = data
         img = img.view(img.size(0), -1)
-        if torch.cuda.is_available():
-            img = Variable(img).cuda()
-            label = Variable(label).cuda()
-        else:
-            img = Variable(img)
-            label = Variable(label)
+        if use_gpu:
+            img = img.cuda()
+            label = label.cuda()
         # 向前传播
         out = model(img)
         loss = criterion(out, label)
-        running_loss += loss.data[0] * label.size(0)
+        running_loss += loss.item()
         _, pred = torch.max(out, 1)
-        num_correct = (pred == label).sum()
-        running_acc += num_correct.data[0]
+        running_acc += (pred == label).float().mean()
         # 向后传播
         optimizer.zero_grad()
         loss.backward()
         optimizer.step()
 
         if i % 300 == 0:
-            print('[{}/{}] Loss: {:.6f}, Acc: {:.6f}'.format(
-                epoch + 1, num_epoches, running_loss / (batch_size * i),
-                running_acc / (batch_size * i)))
-    print('Finish {} epoch, Loss: {:.6f}, Acc: {:.6f}'.format(
-        epoch + 1, running_loss / (len(train_dataset)), running_acc / (len(
-            train_dataset))))
+            print(f'[{epoch+1}/{num_epochs}] Loss: {running_loss/i:.6f}, Acc: {running_acc/i:.6f}')
+    print(f'Finish {epoch+1} epoch, Loss: {running_loss/i:.6f}, Acc: {running_acc/i:.6f}')
     model.eval()
     eval_loss = 0.
     eval_acc = 0.
     for data in test_loader:
         img, label = data
         img = img.view(img.size(0), -1)
-        if torch.cuda.is_available():
-            img = Variable(img, volatile=True).cuda()
-            label = Variable(label, volatile=True).cuda()
-        else:
-            img = Variable(img, volatile=True)
-            label = Variable(label, volatile=True)
-        out = model(img)
-        loss = criterion(out, label)
-        eval_loss += loss.data[0] * label.size(0)
+        if use_gpu:
+            img = img.cuda()
+            label = label.cuda()
+        with torch.no_grad():
+            out = model(img)
+            loss = criterion(out, label)
+        eval_loss += loss.item()
         _, pred = torch.max(out, 1)
-        num_correct = (pred == label).sum()
-        eval_acc += num_correct.data[0]
-    print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
-        test_dataset)), eval_acc / (len(test_dataset))))
-    print()
+        eval_acc += (pred == label).float().mean()
+    print(f'Test Loss: {eval_loss/len(test_loader):.6f}, Acc: {eval_acc/len(test_loader):.6f}\n')
 
 # 保存模型
 torch.save(model.state_dict(), './neural_network.pth')

08-AutoEncoder/simple_autoencoder.py

@@ -28,7 +28,7 @@ def to_img(x):
 
 img_transform = transforms.Compose([
     transforms.ToTensor(),
-    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+    transforms.Normalize([0.5], [0.5])
 ])
 
 dataset = MNIST('./data', transform=img_transform)

README.md

@@ -1,4 +1,6 @@
 # pytorch-beginner
-toy code for pytorch beginner
+Toy project for pytorch beginner with simplest code. 
 
-**Welcome to visit this [site](https://github.com/SherlockLiao/code-of-learn-deep-learning-with-pytorch) to get more detailed chinese pytorch tutorial.**
+## Requirements
+python 3.7
+pytorch 1.0.0+