Bugfix for the gating mechanism + update imports

iamondb.py

@@ -1,9 +1,11 @@
+import warnings
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
 import scipy.signal
 import theano.tensor as T
 
+from numpy.lib.stride_tricks import as_strided
 from iamondb_utils import fetch_iamondb
 
 def tolist(arg):
@@ -502,7 +504,7 @@ def load(self, data_path):
 
         if self.prep == 'normalize':
             X = new_x
-            print X[0].shape
+            print(X[0].shape)
         elif self.prep == 'standardize':
             X, self.X_max, self.X_min = self.standardize(raw_X)
 
@@ -567,7 +569,7 @@ def generate_index(self, X):
         min_x = np.min(item[:,1])
         min_y = np.min(item[:,2])
 
-    print np.max(max_x)
-    print np.max(max_y)
-    print np.min(min_x)
-    print np.min(min_y)
+    print((np.max(max_x)))
+    print((np.max(max_y)))
+    print((np.min(min_x)))
+    print((np.min(min_y)))

load.py

@@ -1,6 +1,6 @@
 import numpy as np
 import numpy.random as npr
-from scipy.io import loadmat
+# from scipy.io import loadmat
 import os
 import json
 from collections import defaultdict, OrderedDict
@@ -162,7 +162,6 @@ def __iter__(self):
             #print(x_batch.shape);
             mask_batch = mask_batch[1:];
             yield x_batch, y_batch, mask_batch
-from motion_utils import read_bvh
 
 class DanceIterator(object):
     def __init__(self, dance_folder, fnames, seq_len, is_test = False, X_mean = None, X_std = None, ab = False):
@@ -191,6 +190,7 @@ def load_dances(self, dance_folder):
         return dances    
 
     def batchify_(self, dances, is_test=False, mean = None, std = None):
+        from motion_utils import read_bvh
         seq_len = self.seq_len;
         dance_batch=[];
         mask_batch = []

main_iamondb.py

@@ -7,7 +7,7 @@
 import os
 import random
 import load
-from models import swavenet_hw
+from models import swavenet_hw, swavenet
 import math;
 from iamondb import IAMOnDB
 
@@ -31,21 +31,22 @@ def evaluate(dataset, model, args, split='valid'):
     loss_sum = 0
     cnt = 0;
     for x, y, x_mask in dataset:
-        try:
-            x = Variable(torch.from_numpy(x), volatile=True).float().cuda()
-            y = Variable(torch.from_numpy(y), volatile=True).float().cuda()
-            x_mask = Variable(torch.from_numpy(x_mask), volatile=True).float().cuda()
+        # try:
+        with torch.no_grad():
+            x = Variable(torch.from_numpy(x)).float().cuda()
+            y = Variable(torch.from_numpy(y)).float().cuda()
+            x_mask = Variable(torch.from_numpy(x_mask)).float().cuda()
             if (args.kld == 'True'):
                 loss, kld_loss = model([x,y,x_mask]);
                 total_loss = loss - kld_loss;
-                total_loss = total_loss.data[0];
+                total_loss = total_loss.item()
             else:
                 all_loss = model([x,y,x_mask]);
-                total_loss = all_loss.data[0]
+                total_loss = all_loss.item()
             loss_sum += total_loss;
             cnt += 1;
-        except:
-            print('exception');
+            # except:
+            #     print('exception')
     return -loss_sum/cnt;
 
 
@@ -59,7 +60,7 @@ def evaluate(dataset, model, args, split='valid'):
 parser.add_argument('--kld', type=str, default='True')
 parser.add_argument('--model_name', type=str, default='swavenet_hw')
 parser.add_argument('--batch_size', type=int, default=32)
-parser.add_argument('--gpu', type=int, default=None)
+parser.add_argument('--gpu', type=int, default=0)
 parser.add_argument('--embed_size', type=int, default=200)
 parser.add_argument('--z_size', type=int, default=200)
 
@@ -110,7 +111,8 @@ def evaluate(dataset, model, args, split='valid'):
 if args.model_name[:10] == 'wavenetvae':
     model = eval(args.model_name).Model(input_dim=3, embed_dim=args.embed_size, z_dim=args.z_size, data=None)
 else:
-    model = eval(args.model_name).Model(input_dim=3, embed_dim=256, output_dim=256, data=None)
+    # model = eval(args.model_name).Model(input_dim=3, embed_dim=256, output_size=256, data=None)
+    model = eval(args.model_name).Model(input_dim=3, embed_dim=args.embed_size, z_dim=args.z_size, data=None)
 model.cuda()
 
 opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5, eps=1e-5)
@@ -133,35 +135,35 @@ def evaluate(dataset, model, args, split='valid'):
     model.train()
     print('Epoch {}: ({})'.format(epoch, model_id.upper()))
     for x, y, x_mask in train_data:
-        try:
-            opt.zero_grad()
-            x = Variable(torch.from_numpy(x)).float().cuda()
-            y = Variable(torch.from_numpy(y)).float().cuda()
-            x_mask = Variable(torch.from_numpy(x_mask)).float().cuda()
-            if (args.kld == 'True'):
-                loss, kld_loss = model([x,y,x_mask]);
-                total_loss = loss - kld_loss * kld_weight;
-                if np.isnan(total_loss.data[0]) or np.isinf(total_loss.data[0]):
-                    print("NaN")  # Useful to see if training is stuck.
-                    continue
-                total_loss.backward();
-                total_loss = total_loss.data[0];
-                kld_loss_sum += kld_loss.data[0];
-                logp_loss_sum += loss.data[0];
-            else:
-                all_loss = model([x,y,x_mask]);
-                if np.isnan(all_loss.data[0]) or np.isinf(all_loss.data[0]):
-                    print('NaN');
-                    continue
-                all_loss.backward()
-                total_loss = all_loss.data[0]
-
-            torch.nn.utils.clip_grad_norm(model.parameters(), 0.1, 'inf')
-            opt.step()
-            loss_sum += total_loss;
-            step += 1;
-        except:
-            print('exception')
+        # try:
+        opt.zero_grad()
+        x = Variable(torch.from_numpy(x)).float().cuda()
+        y = Variable(torch.from_numpy(y)).float().cuda()
+        x_mask = Variable(torch.from_numpy(x_mask)).float().cuda()
+        if (args.kld == 'True'):
+            loss, kld_loss = model([x,y,x_mask]);
+            total_loss = loss - kld_loss * kld_weight;
+            if np.isnan(total_loss.item()) or np.isinf(total_loss.item()):
+                print("NaN")  # Useful to see if training is stuck.
+                continue
+            total_loss.backward();
+            total_loss = total_loss.item()
+            kld_loss_sum += kld_loss.item()
+            logp_loss_sum += loss.item()
+        else:
+            all_loss = model([x,y,x_mask]);
+            if np.isnan(all_loss.item()) or np.isinf(all_loss.item()):
+                print('NaN');
+                continue
+            all_loss.backward()
+            total_loss = all_loss.item()
+
+        torch.nn.utils.clip_grad_norm(model.parameters(), 0.1, 'inf')
+        opt.step()
+        loss_sum += total_loss;
+        step += 1;
+        # except:
+        #     print('exception')
 
     s = timeit.default_timer()
     log_line = 'total time: [%f], epoch: [%d/%d], step: [%d/%d], loss: %f, logp_loss:%f, kld_loss: %f, actual_loss:%f' % (

models/rnn.py

@@ -1,8 +1,10 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from Regressor import Regressor
-from utils import *;
+
+from models.Regressor import Regressor
+from models.utils import LogLikelihood
+
 
 class Model(nn.Module):
     def __init__(self, input_dim, embed_dim, output_dim, data=None):

models/swavenet.py

@@ -1,8 +1,10 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from Regressor import Regressor
-from utils import *;
+from torch.autograd import Variable
+
+from models.Regressor import Regressor
+from models.utils import gaussian_kld, LogLikelihood
 
 
 class WaveNetGate(nn.Module):
@@ -37,7 +39,7 @@ def forward(self, inputs):
             tanh_x = self.filter_conv_bn(tanh_x); 
             if self.residual_link:
                 residual_x = self.residual_bn(residual_x);
-        sigomid_x = F.sigmoid(sigmoid_x);
+        sigmoid_x = F.sigmoid(sigmoid_x);
         tanh_x = F.tanh(tanh_x);
         x = tanh_x * sigmoid_x;
         #print(x.size(), residual_x.size());
@@ -205,7 +207,9 @@ def forward(self, inputs):
 
             #compute KL(q||p)
             tmp = gaussian_kld([mu, theta], [z_mu, z_theta]);
+            # print (tmp.shape, mask.shape)
             tmp = tmp.permute(2,0,1);
+            # print (tmp.shape)
             tmp = (tmp.sum(-1) * mask).sum(0);
             tmp = tmp.mean();
             kld_loss += tmp;

models/swavenet_hw.py

@@ -56,7 +56,7 @@ def forward(self, inputs):
             tanh_x = self.filter_conv_bn(tanh_x); 
             if self.residual_link:
                 residual_x = self.residual_bn(residual_x);
-        sigomid_x = F.sigmoid(sigmoid_x);
+        sigmoid_x = F.sigmoid(sigmoid_x);
         tanh_x = F.tanh(tanh_x);
         x = tanh_x * sigmoid_x;
         if (self.residual_link):

models/wavenet.py

@@ -1,8 +1,9 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from Regressor import Regressor
-from utils import *;
+
+from models.Regressor import Regressor
+from models.utils import LogLikelihood
 
 
 class Model(nn.Module):
@@ -77,7 +78,7 @@ def forward(self, inputs):
                 tanh_x = self.filter_conv_bns[i](tanh_x); 
                 residual_x = self.residual_bns[i](residual_x);
 
-            sigomid_x = F.sigmoid(sigmoid_x);
+            sigmoid_x = F.sigmoid(sigmoid_x);
             tanh_x = F.tanh(tanh_x);
 
             x = tanh_x * sigmoid_x;