update to torch 0.4

Author: MorvanZhou

tutorial-contents/301_regression.py

@@ -3,11 +3,10 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 """
 import torch
-from torch.autograd import Variable
 import torch.nn.functional as F
 import matplotlib.pyplot as plt
 
@@ -17,8 +16,9 @@
 y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)
 
 # torch can only train on Variable, so convert them to Variable
-#x, y = Variable(x), Variable(y)
-#The above code is depricated. Now,autograd directly supports tensors
+# The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
+# x, y = Variable(x), Variable(y)
+
 # plt.scatter(x.data.numpy(), y.data.numpy())
 # plt.show()
 
@@ -56,7 +56,7 @@ def forward(self, x):
         plt.cla()
         plt.scatter(x.data.numpy(), y.data.numpy())
         plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5)
-        plt.text(0.5, 0, 'Loss=%.4f' % loss.data[0], fontdict={'size': 20, 'color':  'red'})
+        plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 20, 'color':  'red'})
         plt.pause(0.1)
 
 plt.ioff()

tutorial-contents/302_classification.py

@@ -3,11 +3,10 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 """
 import torch
-from torch.autograd import Variable
 import torch.nn.functional as F
 import matplotlib.pyplot as plt
 
@@ -22,8 +21,8 @@
 x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # shape (200, 2) FloatTensor = 32-bit floating
 y = torch.cat((y0, y1), ).type(torch.LongTensor)    # shape (200,) LongTensor = 64-bit integer
 
-# torch can only train on Variable, so convert them to Variable
-x, y = Variable(x), Variable(y)
+# The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
+# x, y = Variable(x), Variable(y)
 
 # plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=y.data.numpy(), s=100, lw=0, cmap='RdYlGn')
 # plt.show()

tutorial-contents/304_save_reload.py

@@ -3,19 +3,20 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 """
 import torch
-from torch.autograd import Variable
 import matplotlib.pyplot as plt
 
 # torch.manual_seed(1)    # reproducible
 
 # fake data
 x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
 y = x.pow(2) + 0.2*torch.rand(x.size())  # noisy y data (tensor), shape=(100, 1)
-x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
+
+# The code below is deprecated in Pytorch 0.4. Now, autograd directly supports tensors
+# x, y = Variable(x, requires_grad=False), Variable(y, requires_grad=False)
 
 
 def save():

tutorial-contents/306_optimizer.py

@@ -3,13 +3,12 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 """
 import torch
 import torch.utils.data as Data
 import torch.nn.functional as F
-from torch.autograd import Variable
 import matplotlib.pyplot as plt
 
 # torch.manual_seed(1)    # reproducible
@@ -27,7 +26,7 @@
 plt.show()
 
 # put dateset into torch dataset
-torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)
+torch_dataset = Data.TensorDataset(x, y)
 loader = Data.DataLoader(dataset=torch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2,)
 
 
@@ -64,17 +63,14 @@ def forward(self, x):
     # training
     for epoch in range(EPOCH):
         print('Epoch: ', epoch)
-        for step, (batch_x, batch_y) in enumerate(loader):          # for each training step
-            b_x = Variable(batch_x)
-            b_y = Variable(batch_y)
-
+        for step, (b_x, b_y) in enumerate(loader):          # for each training step
             for net, opt, l_his in zip(nets, optimizers, losses_his):
                 output = net(b_x)              # get output for every net
                 loss = loss_func(output, b_y)  # compute loss for every net
                 opt.zero_grad()                # clear gradients for next train
                 loss.backward()                # backpropagation, compute gradients
                 opt.step()                     # apply gradients
-                l_his.append(loss.data[0])     # loss recoder
+                l_his.append(loss.data.numpy())     # loss recoder
 
     labels = ['SGD', 'Momentum', 'RMSprop', 'Adam']
     for i, l_his in enumerate(losses_his):

tutorial-contents/401_CNN.py

@@ -3,7 +3,7 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 torchvision
 matplotlib
 """
@@ -14,7 +14,6 @@
 # third-party library
 import torch
 import torch.nn as nn
-from torch.autograd import Variable
 import torch.utils.data as Data
 import torchvision
 import matplotlib.pyplot as plt
@@ -51,9 +50,9 @@
 # Data Loader for easy mini-batch return in training, the image batch shape will be (50, 1, 28, 28)
 train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
 
-# convert test data into Variable, pick 2000 samples to speed up testing
+# pick 2000 samples to speed up testing
 test_data = torchvision.datasets.MNIST(root='./mnist/', train=False)
-test_x = Variable(torch.unsqueeze(test_data.test_data, dim=1), volatile=True).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
+test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255.   # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
 test_y = test_data.test_labels[:2000]
 
 
@@ -106,9 +105,7 @@ def plot_with_labels(lowDWeights, labels):
 plt.ion()
 # training and testing
 for epoch in range(EPOCH):
-    for step, (x, y) in enumerate(train_loader):   # gives batch data, normalize x when iterate train_loader
-        b_x = Variable(x)   # batch x
-        b_y = Variable(y)   # batch y
+    for step, (b_x, b_y) in enumerate(train_loader):   # gives batch data, normalize x when iterate train_loader
 
         output = cnn(b_x)[0]               # cnn output
         loss = loss_func(output, b_y)   # cross entropy loss
@@ -119,8 +116,8 @@ def plot_with_labels(lowDWeights, labels):
         if step % 50 == 0:
             test_output, last_layer = cnn(test_x)
             pred_y = torch.max(test_output, 1)[1].data.squeeze()
-            accuracy = sum(pred_y == test_y) / float(test_y.size(0))
-            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data[0], '| test accuracy: %.2f' % accuracy)
+            accuracy = float(sum(pred_y == test_y)) / float(test_y.size(0))
+            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
             if HAS_SK:
                 # Visualization of trained flatten layer (T-SNE)
                 tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000)

tutorial-contents/402_RNN_classifier.py

@@ -3,13 +3,12 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 torchvision
 """
 import torch
 from torch import nn
-from torch.autograd import Variable
 import torchvision.datasets as dsets
 import torchvision.transforms as transforms
 import matplotlib.pyplot as plt
@@ -47,7 +46,7 @@
 
 # convert test data into Variable, pick 2000 samples to speed up testing
 test_data = dsets.MNIST(root='./mnist/', train=False, transform=transforms.ToTensor())
-test_x = Variable(test_data.test_data, volatile=True).type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
+test_x = test_data.test_data.type(torch.FloatTensor)[:2000]/255.   # shape (2000, 28, 28) value in range(0,1)
 test_y = test_data.test_labels.numpy().squeeze()[:2000]    # covert to numpy array
 
 
@@ -84,9 +83,8 @@ def forward(self, x):
 
 # training and testing
 for epoch in range(EPOCH):
-    for step, (x, y) in enumerate(train_loader):        # gives batch data
-        b_x = Variable(x.view(-1, 28, 28))              # reshape x to (batch, time_step, input_size)
-        b_y = Variable(y)                               # batch y
+    for step, (b_x, b_y) in enumerate(train_loader):        # gives batch data
+        b_x = b_x.view(-1, 28, 28)              # reshape x to (batch, time_step, input_size)
 
         output = rnn(b_x)                               # rnn output
         loss = loss_func(output, b_y)                   # cross entropy loss
@@ -97,8 +95,8 @@ def forward(self, x):
         if step % 50 == 0:
             test_output = rnn(test_x)                   # (samples, time_step, input_size)
             pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
-            accuracy = sum(pred_y == test_y) / float(test_y.size)
-            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data[0], '| test accuracy: %.2f' % accuracy)
+            accuracy = float(sum(pred_y == test_y)) / float(test_y.size)
+            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
 
 # print 10 predictions from test data
 test_output = rnn(test_x[:10].view(-1, 28, 28))

tutorial-contents/403_RNN_regressor.py

@@ -3,13 +3,12 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 numpy
 """
 import torch
 from torch import nn
-from torch.autograd import Variable
 import numpy as np
 import matplotlib.pyplot as plt
 
@@ -69,19 +68,19 @@ def forward(self, x, h_state):
 plt.figure(1, figsize=(12, 5))
 plt.ion()           # continuously plot
 
-for step in range(60):
+for step in range(100):
     start, end = step * np.pi, (step+1)*np.pi   # time range
     # use sin predicts cos
     steps = np.linspace(start, end, TIME_STEP, dtype=np.float32)
     x_np = np.sin(steps)    # float32 for converting torch FloatTensor
     y_np = np.cos(steps)
 
-    x = Variable(torch.from_numpy(x_np[np.newaxis, :, np.newaxis]))    # shape (batch, time_step, input_size)
-    y = Variable(torch.from_numpy(y_np[np.newaxis, :, np.newaxis]))
+    x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis])    # shape (batch, time_step, input_size)
+    y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis])
 
     prediction, h_state = rnn(x, h_state)   # rnn output
     # !! next step is important !!
-    h_state = Variable(h_state.data)        # repack the hidden state, break the connection from last iteration
+    h_state = h_state.data        # repack the hidden state, break the connection from last iteration
 
     loss = loss_func(prediction, y)         # cross entropy loss
     optimizer.zero_grad()                   # clear gradients for this training step

tutorial-contents/404_autoencoder.py

@@ -3,13 +3,12 @@
 My Youtube Channel: https://www.youtube.com/user/MorvanZhou
 
 Dependencies:
-torch: 0.1.11
+torch: 0.4
 matplotlib
 numpy
 """
 import torch
 import torch.nn as nn
-from torch.autograd import Variable
 import torch.utils.data as Data
 import torchvision
 import matplotlib.pyplot as plt
@@ -87,15 +86,14 @@ def forward(self, x):
 plt.ion()   # continuously plot
 
 # original data (first row) for viewing
-view_data = Variable(train_data.train_data[:N_TEST_IMG].view(-1, 28*28).type(torch.FloatTensor)/255.)
+view_data = train_data.train_data[:N_TEST_IMG].view(-1, 28*28).type(torch.FloatTensor)/255.
 for i in range(N_TEST_IMG):
     a[0][i].imshow(np.reshape(view_data.data.numpy()[i], (28, 28)), cmap='gray'); a[0][i].set_xticks(()); a[0][i].set_yticks(())
 
 for epoch in range(EPOCH):
-    for step, (x, y) in enumerate(train_loader):
-        b_x = Variable(x.view(-1, 28*28))   # batch x, shape (batch, 28*28)
-        b_y = Variable(x.view(-1, 28*28))   # batch y, shape (batch, 28*28)
-        b_label = Variable(y)               # batch label
+    for step, (x, b_label) in enumerate(train_loader):
+        b_x = x.view(-1, 28*28)   # batch x, shape (batch, 28*28)
+        b_y = x.view(-1, 28*28)   # batch y, shape (batch, 28*28)
 
         encoded, decoded = autoencoder(b_x)
 
@@ -105,7 +103,7 @@ def forward(self, x):
         optimizer.step()                    # apply gradients
 
         if step % 100 == 0:
-            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data[0])
+            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy())
 
             # plotting decoded image (second row)
             _, decoded_data = autoencoder(view_data)
@@ -119,7 +117,7 @@ def forward(self, x):
 plt.show()
 
 # visualize in 3D plot
-view_data = Variable(train_data.train_data[:200].view(-1, 28*28).type(torch.FloatTensor)/255.)
+view_data = train_data.train_data[:200].view(-1, 28*28).type(torch.FloatTensor)/255.
 encoded_data, _ = autoencoder(view_data)
 fig = plt.figure(2); ax = Axes3D(fig)
 X, Y, Z = encoded_data.data[:, 0].numpy(), encoded_data.data[:, 1].numpy(), encoded_data.data[:, 2].numpy()

tutorial-contents/405_DQN_Reinforcement_learning.py

@@ -4,13 +4,12 @@
 More about Reinforcement learning: https://morvanzhou.github.io/tutorials/machine-learning/reinforcement-learning/
 
 Dependencies:
-torch: 0.3
+torch: 0.4
 gym: 0.8.1
 numpy
 """
 import torch
 import torch.nn as nn
-from torch.autograd import Variable
 import torch.nn.functional as F
 import numpy as np
 import gym
@@ -55,7 +54,7 @@ def __init__(self):
         self.loss_func = nn.MSELoss()
 
     def choose_action(self, x):
-        x = Variable(torch.unsqueeze(torch.FloatTensor(x), 0))
+        x = torch.unsqueeze(torch.FloatTensor(x), 0)
         # input only one sample
         if np.random.uniform() < EPSILON:   # greedy
             actions_value = self.eval_net.forward(x)
@@ -82,10 +81,10 @@ def learn(self):
         # sample batch transitions
         sample_index = np.random.choice(MEMORY_CAPACITY, BATCH_SIZE)
         b_memory = self.memory[sample_index, :]
-        b_s = Variable(torch.FloatTensor(b_memory[:, :N_STATES]))
-        b_a = Variable(torch.LongTensor(b_memory[:, N_STATES:N_STATES+1].astype(int)))
-        b_r = Variable(torch.FloatTensor(b_memory[:, N_STATES+1:N_STATES+2]))
-        b_s_ = Variable(torch.FloatTensor(b_memory[:, -N_STATES:]))
+        b_s = torch.FloatTensor(b_memory[:, :N_STATES])
+        b_a = torch.LongTensor(b_memory[:, N_STATES:N_STATES+1].astype(int))
+        b_r = torch.FloatTensor(b_memory[:, N_STATES+1:N_STATES+2])
+        b_s_ = torch.FloatTensor(b_memory[:, -N_STATES:])
 
         # q_eval w.r.t the action in experience
         q_eval = self.eval_net(b_s).gather(1, b_a)  # shape (batch, 1)