similarize

code/models/cnn_encoder.py

@@ -37,6 +37,7 @@ def __init__(self, params):
         self.fin_layer = nn.Linear(fin_l_out_size, params.hidden_dims)
         self.out_layer = nn.Linear(params.hidden_dims, params.y_dim)
         torch.nn.init.xavier_uniform_(self.fin_layer.weight)
+	torch.nn.init.xavier_uniform_(self.out_layer.weight)
 
     def forward(self, inputs):
         #o0 = self.drp(self.bn_1(inputs)).permute(0,2,1)

utils/data_helpers.py

@@ -49,7 +49,7 @@ def pad_sentences(sentence_sets, padding_word="<PAD/>", max_length=500):
     return padded_sentence_sets, sequence_length
 
 
-def load_data_and_labels(data):
+def load_data_and_labels(data, M=0, N=0):
     x_text = [clean_str(doc['text']) for doc in data]
     x_text = [s.split(" ") for s in x_text]
     labels = [doc['catgy'] for doc in data]
@@ -62,8 +62,16 @@ def load_data_and_labels(data):
             val_idx.append(1)
     m = max(row_idx) + 1
     n = max(col_idx) + 1
-    Y = sp.csr_matrix((val_idx, (row_idx, col_idx)), shape=(m, n))
-    return [x_text, Y]
+    if(M and N):
+    	if(N > n):
+       		#y_te = y_te.resize((np.shape(y_te)[0], np.shape(y_tr)[1]))
+	    	Y = sp.csr_matrix((val_idx, (row_idx, col_idx)), shape=(m, N))
+    	elif(N < n):
+		Y = sp.csr_matrix((val_idx, (row_idx, col_idx)), shape=(m, N))
+        	Y = Y[:, :N]
+    else:
+	Y = sp.csr_matrix((val_idx, (row_idx, col_idx)), shape=(m, n))
+    return [x_text, Y, m, n]
 
 
 def build_vocab(sentences, params, vocab_size=50000):
@@ -96,8 +104,8 @@ def load_data(params, max_length=500, vocab_size=50000):
     if len(test) == 0:
         test[:5] = train[:5]
 
-    trn_sents, Y_trn = load_data_and_labels(train)
-    tst_sents, Y_tst = load_data_and_labels(test)
+    trn_sents, Y_trn, m, n = load_data_and_labels(train)
+    tst_sents, Y_tst, m, n = load_data_and_labels(test, M=m, N=n)
     sents_padded_sets, params.sequence_length = pad_sentences([trn_sents, tst_sents] , padding_word=params.pad_token, max_length=max_length)
     # tst_sents_padded = pad_sentences(tst_sents, padding_word=params.pad_token, max_length=max_length)
     vocabulary, vocabulary_inv = build_vocab(sents_padded_sets[0] + sents_padded_sets[1], params, vocab_size=vocab_size)

utils/futils.py

@@ -21,7 +21,7 @@ def weights_init(m):
     if(torch.__version__=='0.4.0'):
     	torch.nn.init.xavier_uniform_(m)
     else:
-	    torch.nn.init.xavier_uniform(m)
+	torch.nn.init.xavier_uniform(m)
 def get_gpu_memory_map(boom, name=False):
     result = subprocess.check_output(
         [
@@ -49,6 +49,30 @@ def count_parameters(model):
 def effective_k(k, d):
     return (k - 1) * d + 1
 
+def load_model(model, name, optimizer=None):
+    if(torch.cuda.is_available()):
+        checkpoint = torch.load(name)
+    else:
+        checkpoint = torch.load(name, map_location=lambda storage, loc: storage)
+
+    model.load_state_dict(checkpoint['state_dict'])
+
+    if optimizer is not None:
+        optimizer.load_state_dict(checkpoint['optimizer'])
+        init = checkpoint['epoch']
+        return model, optimizer, init
+    else:
+        return model
+
+def save_model(model, optimizer, epoch, name):
+    if not os.path.exists('saved_models/' + params.model_name ):
+        os.makedirs('saved_models/' + params.model_name)
+    checkpoint = {
+        'state_dict': model.state_dict(),
+        'optimizer': optimizer.state_dict(),
+        'epoch': epoch
+    }
+    torch.save(checkpoint, "saved_models/" + name)
 def sample_z(mu, log_var, params, dtype_f):
     eps = Variable(torch.randn(params.batch_size, params.Z_dim).type(dtype_f))
     k = torch.exp(log_var / 2) * eps
@@ -139,9 +163,7 @@ def save_load_data(params, save=0):
     params.vocab_size = len(vocabulary)
     params.classes = y_tr.shape[1]
 
-    # import pdb
-    # pdb.set_trace()
-    return x_tr, x_te, y_tr, y_te[:, :-1], vocabulary, vocabulary_inv, params
+    return x_tr, x_te, y_tr, y_te, vocabulary, vocabulary_inv, params
 
 def load_batch_cnn(x_tr, y_tr, params, batch=True, batch_size=0, decoder_word_input=None, decoder_target=None, testing=0):
 
@@ -188,30 +210,3 @@ def sample_word_from_distribution(params, distribution):
     x = np.zeros((params.vocab_size, 1))
     x[ix] = 1
     return params.vocabulary_inv[np.argmax(x)]
-
-def load_model(model, name, optimizer=None):
-    if(torch.cuda.is_available()):
-        checkpoint = torch.load(name)
-    else:
-        checkpoint = torch.load(
-            name, map_location=lambda storage, loc: storage)
-
-    model.load_state_dict(checkpoint['state_dict'])
-
-    if optimizer is not None:
-        optimizer.load_state_dict(checkpoint['optimizer'])
-        init = checkpoint['epoch']
-        return model, optimizer, init
-    else:
-        return model
-
-
-def save_model(model, optimizer, epoch, name):
-    if not os.path.exists('saved_models/'):
-        os.makedirs('saved_models/')
-    checkpoint = {
-        'state_dict': model.state_dict(),
-        'optimizer': optimizer.state_dict(),
-        'epoch': epoch
-    }
-    torch.save(checkpoint, "saved_models/" + name)

utils/loss.py

@@ -25,16 +25,7 @@ def MSLoss(self, X_sample, X):
         return t
 
     def BCELoss(self, y_pred, y, eps = 1e-25):
-        # y_pred_1 = torch.log(y_pred+ eps)
-        # y_pred_2 = torch.log(1 - y_pred + eps)
-        # t = -torch.sum(torch.mean(y_pred_1*y + y_pred_2*(1-y),dim=0))
         t = torch.nn.functional.binary_cross_entropy(y_pred, y)*y.shape[-1]
-        if(torch.isnan(t).any()):
-            print("nan")
-            pdb.set_trace()
-        if(t<0):
-            print("negative")            
-            pdb.set_trace()
         return t
 
     def L1Loss(self, X_sample, X):