upgrade repo to pytorch 1.0

TCN/adding_problem/add_test.py

@@ -2,6 +2,8 @@ import torch
 import argparse
 import torch.optim as optim
 import torch.nn.functional as F
+import sys
+sys.path.append("../../")
 from TCN.adding_problem.model import TCN
 from TCN.adding_problem.utils import data_generator
 
@@ -73,8 +75,8 @@ def train(epoch):
     model.train()
     batch_idx = 1
     total_loss = 0
-    for i in range(0, X_train.size()[0], batch_size):
-        if i + batch_size > X_train.size()[0]:
+    for i in range(0, X_train.size(0), batch_size):
+        if i + batch_size > X_train.size(0):
             x, y = X_train[i:], Y_train[i:]
         else:
             x, y = X_train[i:(i+batch_size)], Y_train[i:(i+batch_size)]
@@ -83,16 +85,16 @@ def train(epoch):
         loss = F.mse_loss(output, y)
         loss.backward()
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         optimizer.step()
         batch_idx += 1
-        total_loss += loss.data[0]
+        total_loss += loss.item()
 
         if batch_idx % args.log_interval == 0:
             cur_loss = total_loss / args.log_interval
-            processed = min(i+batch_size, X_train.size()[0])
+            processed = min(i+batch_size, X_train.size(0))
             print('Train Epoch: {:2d} [{:6d}/{:6d} ({:.0f}%)]\tLearning rate: {:.4f}\tLoss: {:.6f}'.format(
-                epoch, processed, X_train.size()[0], 100.*processed/X_train.size()[0], lr, cur_loss))
+                epoch, processed, X_train.size(0), 100.*processed/X_train.size(0), lr, cur_loss))
             total_loss = 0
 
 
@@ -100,8 +102,8 @@ def evaluate():
     model.eval()
     output = model(X_test)
     test_loss = F.mse_loss(output, Y_test)
-    print('\nTest set: Average loss: {:.6f}\n'.format(test_loss.data[0]))
-    return test_loss.data[0]
+    print('\nTest set: Average loss: {:.6f}\n'.format(test_loss.item()))
+    return test_loss.item()
 
 
 for ep in range(1, epochs+1):

TCN/char_cnn/char_cnn_test.py

@@ -88,21 +88,22 @@ def evaluate(source):
     total_loss = 0
     count = 0
     source_len = source.size(1)
-    for batch, i in enumerate(range(0, source_len - 1, args.validseqlen)):
-        if i + args.seq_len - args.validseqlen >= source_len:
-            continue
-        inp, target = get_batch(source, i, args)
-        output = model(inp)
-        eff_history = args.seq_len - args.validseqlen
-        final_output = output[:, eff_history:].contiguous().view(-1, n_characters)
-        final_target = target[:, eff_history:].contiguous().view(-1)
-        loss = criterion(final_output, final_target)
+    with torch.no_grad():
+        for batch, i in enumerate(range(0, source_len - 1, args.validseqlen)):
+            if i + args.seq_len - args.validseqlen >= source_len:
+                continue
+            inp, target = get_batch(source, i, args)
+            output = model(inp)
+            eff_history = args.seq_len - args.validseqlen
+            final_output = output[:, eff_history:].contiguous().view(-1, n_characters)
+            final_target = target[:, eff_history:].contiguous().view(-1)
+            loss = criterion(final_output, final_target)
 
-        total_loss += loss.data * final_output.size(0)
-        count += final_output.size(0)
+            total_loss += loss.data * final_output.size(0)
+            count += final_output.size(0)
 
-    val_loss = total_loss[0] / count * 1.0
-    return val_loss
+        val_loss = total_loss.item() / count * 1.0
+        return val_loss
 
 
 def train(epoch):
@@ -125,12 +126,12 @@ def train(epoch):
         loss.backward()
 
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         optimizer.step()
-        total_loss += loss.data
+        total_loss += loss.item()
 
         if batch_idx % args.log_interval == 0 and batch_idx > 0:
-            cur_loss = total_loss[0] / args.log_interval
+            cur_loss = total_loss / args.log_interval
             losses.append(cur_loss)
             elapsed = time.time() - start_time
             print('| epoch {:3d} | {:5d}/{:5d} batches | lr {:02.5f} | ms/batch {:5.2f} | '
@@ -140,13 +141,6 @@ def train(epoch):
             total_loss = 0
             start_time = time.time()
 
-        # if batch % (200 * args.log_interval) == 0 and batch > 0:
-        #     vloss = evaluate(val_data)
-        #     print('-' * 89)
-        #     print('| In epoch {:3d} | valid loss {:5.3f} | '
-        #           'valid bpc {:8.3f}'.format(epoch, vloss, vloss / math.log(2)))
-        #     model.train()
-
     return sum(losses) * 1.0 / len(losses)
 
 

TCN/copy_memory/copymem_test.py

@@ -4,6 +4,8 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.autograd import Variable
 import numpy as np
+import sys
+sys.path.append("../../")
 from TCN.copy_memory.utils import data_generator
 from TCN.copy_memory.model import TCN
 import time
@@ -89,8 +91,8 @@ def evaluate():
     correct = pred.eq(test_y.data.view_as(pred)).cpu().sum()
     counter = out.view(-1, n_classes).size(0)
     print('\nTest set: Average loss: {:.8f}  |  Accuracy: {:.4f}\n'.format(
-        loss.data[0], 100. * correct / counter))
-    return loss.data[0]
+        loss.item(), 100. * correct / counter))
+    return loss.item()
 
 
 def train(ep):
@@ -114,10 +116,10 @@ def train(ep):
         correct += pred.eq(y.data.view_as(pred)).cpu().sum()
         counter += out.view(-1, n_classes).size(0)
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         loss.backward()
         optimizer.step()
-        total_loss += loss
+        total_loss += loss.item()
 
         if batch_idx > 0 and batch_idx % args.log_interval == 0:
             avg_loss = total_loss / args.log_interval
@@ -125,7 +127,7 @@ def train(ep):
             print('| Epoch {:3d} | {:5d}/{:5d} batches | lr {:2.5f} | ms/batch {:5.2f} | '
                   'loss {:5.8f} | accuracy {:5.4f}'.format(
                 ep, batch_idx, n_train // batch_size+1, args.lr, elapsed * 1000 / args.log_interval,
-                avg_loss.data[0], 100. * correct / counter))
+                avg_loss, 100. * correct / counter))
             start_time = time.time()
             total_loss = 0
             correct = 0

TCN/lambada_language/lambada_test.py

@@ -99,7 +99,7 @@ def evaluate(data_source):
         loss = criterion(final_output, final_target)
         total_loss += loss.data
         processed_data_size += 1
-    return total_loss[0] / processed_data_size
+    return total_loss.item() / processed_data_size
 
 
 def train():
@@ -121,12 +121,12 @@ def train():
         loss = criterion(final_output, final_target)
         loss.backward()
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         optimizer.step()
-        total_loss += loss.data
+        total_loss += loss.item()
 
         if batch_idx % args.log_interval == 0 and batch_idx > 0:
-            cur_loss = total_loss[0] / args.log_interval
+            cur_loss = total_loss / args.log_interval
             elapsed = time.time() - start_time
             print('| epoch {:3d} | {:5d}/{:5d} batches | lr {:02.5f} | ms/batch {:5.5f} | '
                   'loss {:5.2f} | ppl {:8.2f}'.format(

TCN/mnist_pixel/data/mnist/processed/README.md

+Your `training.pt` and `test.pt` will be saved here.
\ No newline at end of file

TCN/mnist_pixel/pmnist_test.py

@@ -2,6 +2,8 @@ import torch
 from torch.autograd import Variable
 import torch.optim as optim
 import torch.nn.functional as F
+import sys
+sys.path.append("../../")
 from TCN.mnist_pixel.utils import data_generator
 from TCN.mnist_pixel.model import TCN
 import numpy as np
@@ -80,14 +82,14 @@ def train(ep):
         loss = F.nll_loss(output, target)
         loss.backward()
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         optimizer.step()
         train_loss += loss
         steps += seq_length
         if batch_idx > 0 and batch_idx % args.log_interval == 0:
             print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tSteps: {}'.format(
                 ep, batch_idx * batch_size, len(train_loader.dataset),
-                100. * batch_idx / len(train_loader), train_loss.data[0]/args.log_interval, steps))
+                100. * batch_idx / len(train_loader), train_loss.item()/args.log_interval, steps))
             train_loss = 0
 
 
@@ -103,7 +105,7 @@ def test():
             data = data[:, :, permute]
         data, target = Variable(data, volatile=True), Variable(target)
         output = model(data)
-        test_loss += F.nll_loss(output, target, size_average=False).data[0]
+        test_loss += F.nll_loss(output, target, size_average=False).item()
         pred = output.data.max(1, keepdim=True)[1]
         correct += pred.eq(target.data.view_as(pred)).cpu().sum()
 

TCN/poly_music/music_test.py

@@ -3,6 +3,8 @@ import torch
 import torch.nn as nn
 from torch.autograd import Variable
 import torch.optim as optim
+import sys
+sys.path.append("../../")
 from TCN.poly_music.model import TCN
 from TCN.poly_music.utils import data_generator
 import numpy as np
@@ -61,7 +63,7 @@ lr = args.lr
 optimizer = getattr(optim, args.optim)(model.parameters(), lr=lr)
 
 
-def evaluate(X_data):
+def evaluate(X_data, name='Eval'):
     model.eval()
     eval_idx_list = np.arange(len(X_data), dtype="int32")
     total_loss = 0.0
@@ -74,10 +76,10 @@ def evaluate(X_data):
         output = model(x.unsqueeze(0)).squeeze(0)
         loss = -torch.trace(torch.matmul(y, torch.log(output).float().t()) +
                             torch.matmul((1-y), torch.log(1-output).float().t()))
-        total_loss += loss.data[0]
+        total_loss += loss.item()
         count += output.size(0)
     eval_loss = total_loss / count
-    print("Validation/Test loss: {:.5f}".format(eval_loss))
+    print(name + " loss: {:.5f}".format(eval_loss))
     return eval_loss
 
 
@@ -97,11 +99,11 @@ def train(ep):
         output = model(x.unsqueeze(0)).squeeze(0)
         loss = -torch.trace(torch.matmul(y, torch.log(output).float().t()) +
                             torch.matmul((1 - y), torch.log(1 - output).float().t()))
-        total_loss += loss.data[0]
+        total_loss += loss.item()
         count += output.size(0)
 
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         loss.backward()
         optimizer.step()
         if idx > 0 and idx % args.log_interval == 0:
@@ -117,8 +119,8 @@ if __name__ == "__main__":
     model_name = "poly_music_{0}.pt".format(args.data)
     for ep in range(1, args.epochs+1):
         train(ep)
-        vloss = evaluate(X_valid)
-        tloss = evaluate(X_test)
+        vloss = evaluate(X_valid, name='Validation')
+        tloss = evaluate(X_test, name='Test')
         if vloss < best_vloss:
             with open(model_name, "wb") as f:
                 torch.save(model, f)

TCN/word_cnn/word_cnn_test.py

@@ -106,9 +106,9 @@ def evaluate(data_source):
         loss = criterion(final_output, final_target)
 
         # Note that we don't add TAR loss here
-        total_loss += (data.size(1) - eff_history) * loss.data
+        total_loss += (data.size(1) - eff_history) * loss.item()
         processed_data_size += data.size(1) - eff_history
-    return total_loss[0] / processed_data_size
+    return total_loss / processed_data_size
 
 
 def train():
@@ -134,13 +134,13 @@ def train():
 
         loss.backward()
         if args.clip > 0:
-            torch.nn.utils.clip_grad_norm(model.parameters(), args.clip)
+            torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
         optimizer.step()
 
-        total_loss += loss.data
+        total_loss += loss.item()
 
         if batch_idx % args.log_interval == 0 and batch_idx > 0:
-            cur_loss = total_loss[0] / args.log_interval
+            cur_loss = total_loss / args.log_interval
             elapsed = time.time() - start_time
             print('| epoch {:3d} | {:5d}/{:5d} batches | lr {:02.5f} | ms/batch {:5.5f} | '
                   'loss {:5.2f} | ppl {:8.2f}'.format(