remove useless code

Author: captain

Untitled.ipynb

@@ -6,8 +6,17 @@
 from util import eval_RMSE
 import math
 import numpy as np
-from cnn_model import CNN
+from text_analysis.cnn_model import CNN
 from torch.autograd import Variable
+import torch
+
+'''
+尚未解决的问题：
+1、word_embedding
+2、batch
+3、give_item_weight到底是做什么用的
+4、模型中seed的用法
+'''
 
 
 def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
@@ -31,6 +40,7 @@ def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
     Test_R = test_user[1]
     Valid_R = valid_user[1]
 
+    # 这一部分到底是做什么用的
     if give_item_weight is True:
         item_weight = np.array([math.sqrt(len(i))
                                 for i in Train_R_J], dtype=float)
@@ -40,17 +50,15 @@ def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
 
     pre_val_eval = 1e10
 
-    # dimension: latent of dimension for users and items
-    # emb_dim: Size of latent dimension for word vectors
+    # dimension: 用户和物品的隐特征维数
+    # emb_dim: 词向量的维数
     cnn_module = CNN(dimension, vocab_size, dropout_rate,
-                            emb_dim, max_len, num_kernel_per_ws, init_W)
+                     emb_dim, max_len, num_kernel_per_ws, init_W)
 
     # return the output of CNN
-    # size of V is (dimension, num_item)
-    theta = cnn_module(Variable(CNN_X))
+    # size of V is (num_item, dimension)
+    cnn_module = cnn_module.cuda()
     theta = cnn_module.get_projection_layer(CNN_X)
-    np.random.seed(133)
-    # dimension is the k
     U = np.random.uniform(size=(num_user, dimension))
     V = theta
 
@@ -98,25 +106,29 @@ def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
         loss = loss + np.sum(sub_loss)
         seed = np.random.randint(100000)
 
-        # important
-        history = cnn_module.train(CNN_X, V, item_weight, seed)
+        # 用V训练CNN模型，更新V
+        cnn_module.train(CNN_X, V)
         theta = cnn_module.get_projection_layer(CNN_X)
 
-        cnn_loss = history.history['loss'][-1]
+        # 这部分添加计算CNN模型的损失
+        # cnn_loss = history.history['loss'][-1]
 
-        loss -= 0.5 * lambda_v * cnn_loss * num_item
+        # loss -= 0.5 * lambda_v * cnn_loss * num_item
 
         tr_eval = eval_RMSE(Train_R_I, U, V, train_user[0])
         val_eval = eval_RMSE(Valid_R, U, V, valid_user[0])
         te_eval = eval_RMSE(Test_R, U, V, test_user[0])
 
+        # 计算一次迭代的时间
         toc = time.time()
         elapsed = toc - tic
 
+        # 计算Loss下降率
         converge = abs((loss - PREV_LOSS) / PREV_LOSS)
 
+        # 存储模型参数
         if val_eval < pre_val_eval:
-            cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
+            # cnn_module.save_model(res_dir + '/CNN_weights.hdf5')
             np.savetxt(res_dir + '/U.dat', U)
             np.savetxt(res_dir + '/V.dat', V)
             np.savetxt(res_dir + '/theta.dat', theta)
@@ -125,12 +137,12 @@ def ConvMF(res_dir, train_user, train_item, valid_user, test_user,
 
         pre_val_eval = val_eval
 
-        print("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
-            loss, elapsed, converge, tr_eval, val_eval, te_eval))
-        f1.write("Loss: %.5f Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
-            loss, elapsed, converge, tr_eval, val_eval, te_eval))
+        print("Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f" % (
+             elapsed, converge, tr_eval, val_eval, te_eval))
+        f1.write("Elpased: %.4fs Converge: %.6f Tr: %.5f Val: %.5f Te: %.5f\n" % (
+            elapsed, converge, tr_eval, val_eval, te_eval))
 
-        # endure_count = 5
+        # 超过五次则退出迭代训练
         if count == endure_count:
             break
 

__pycache__/models.cpython-36.pyc

@@ -1,9 +1,10 @@
-#coding:utf-8
+# coding:utf-8
 
 import argparse
 import sys
 import os
 from data_manager import Data_Factory
+import numpy as np
 
 parser = argparse.ArgumentParser()
 
@@ -39,7 +40,7 @@
 parser.add_argument("-e", "--emb_dim", type=int,
                     help="Size of latent dimension for word vectors (default: 200)", default=200)
 parser.add_argument("-p", "--pretrain_w2v", type=str,
-                    help="Path to pretrain word embedding model  to initialize word vectors")
+                    help="Path to pretrain word embedding model  to initialize word vectors", default=None)
 parser.add_argument("-g", "--give_item_weight", type=bool,
                     help="True or False to give item weight of ConvMF (default = False)", default=True)
 parser.add_argument("-k", "--dimension", type=int,
@@ -136,7 +137,14 @@
     valid_user = data_factory.read_rating(data_path + '/valid_user.dat')
     test_user = data_factory.read_rating(data_path + '/test_user.dat')
 
+    # CNN_X添加padding，以处理不同长度的文本数据
+    input_array = np.full((len(CNN_X), 300), 8000)
+    for i in range(len(CNN_X)):
+        for j in range(len(CNN_X[i])):
+            input_array[i][j] = CNN_X[i][j]
+
+    # 使用新的填充后的文本数据
     ConvMF(max_iter=max_iter, res_dir=res_dir,
            lambda_u=lambda_u, lambda_v=lambda_v, dimension=dimension, vocab_size=vocab_size, init_W=init_W,
-           give_item_weight=give_item_weight, CNN_X=CNN_X, emb_dim=emb_dim, num_kernel_per_ws=num_kernel_per_ws,
+           give_item_weight=give_item_weight, CNN_X=input_array, emb_dim=emb_dim, num_kernel_per_ws=num_kernel_per_ws,
            train_user=train_user, train_item=train_item, valid_user=valid_user, test_user=test_user, R=R)

ml-1m/0.2/test_item.dat

@@ -4,13 +4,13 @@ python ./run.py \
 -a ./data/preprocessed/ml-1m/ \
 -o ./result/ml-1m/1_100_200 \
 -e 50 \
--p ./data/glove/glove.6B.50d.txt \
 -u 10 \
 -v 100 \
 -g True
 
 
 ##!/usr/bin/env bash
+# -p ./data/glove.6B/glove.6B.50d.txt \
 #python ./run.py \
 #-d ./data/preprocessed/aiv/0.2/ \
 #-a ./data/preprocessed/aiv/ \

ml-1m/0.2/test_user.dat

@@ -4,14 +4,18 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+import numpy as np
 import torch.optim as optim
 from torch.autograd import Variable
 
 
 class CNN(nn.Module):
+    batch_size = 128
+    # More than this epoch cause easily over-fitting on our data sets
+    nb_epoch = 5
+
     def __init__(self, output_dimesion, vocab_size, dropout_rate, emb_dim, max_len, n_filters, init_W=None):
-        # number_filters
-        print(type(self))
+        # n_filter为卷积核个数
         super(CNN, self).__init__()
 
         self.max_len = max_len
@@ -21,9 +25,10 @@ def __init__(self, output_dimesion, vocab_size, dropout_rate, emb_dim, max_len,
         self.qual_conv_set = {}
 
         '''Embedding Layer'''
-        if init_W is None:
-            # 先尝试使用embedding随机赋值
-            self.embedding = nn.Embedding(vocab_size, emb_dim)
+        # if init_W is None:
+        #     # 最后一个索引为填充的标记文本
+        #     # 先尝试使用随机生成的词向量值
+        self.embedding = nn.Embedding(vocab_size + 1, emb_dim)
 
         self.conv1 = nn.Sequential(
             # 卷积层的激活函数
@@ -53,22 +58,57 @@ def __init__(self, output_dimesion, vocab_size, dropout_rate, emb_dim, max_len,
         # output_layer = Dense(projection_dimension, activation='tanh')(layer)
         self.output_layer = nn.Linear(vanila_dimension, projection_dimension)
 
-    def forward(self, input):
-        embeds = self.embedding(input)
+    def forward(self, inputs):
+        size = len(inputs)
+        embeds = self.embedding(inputs)
+
         # 进入卷积层前需要将Tensor第二个维度变成emb_dim，作为卷积的通道数
         embeds = embeds.view([len(embeds), self.emb_dim, -1])
         # concatenate the tensors
         x = self.conv1(embeds)
         y = self.conv2(embeds)
         z = self.conv3(embeds)
-        flatten = torch.cat((x.view(-1), y.view(-1), z.view(-1)), 1)
+        flatten = torch.cat((x.view(size, -1), y.view(size, -1), z.view(size, -1)), 1)
 
         out = F.tanh(self.layer(flatten))
         out = self.dropout(out)
         out = F.tanh(self.output_layer(out))
 
-    def train(self, X_train, V, item_weight, seed):
-        pass
+        return out
+
+    def train(self, X_train, V):
+
+        # learning rate暂时定为0.001
+        optimizer = torch.optim.Adam(self.parameters(), lr=0.001)
+
+        for epoch in range(1, self.nb_epoch + 1):
+
+            print('<---epoch' + str(epoch))
+            n_batch = len(X_train) // self.batch_size
+
+            # 这里会漏掉一些训练集，先这样写
+            for i in range(n_batch):
+                begin_idx, end_idx = i * self.batch_size, (i + 1) * self.batch_size
+                feature = X_train[begin_idx:end_idx][...]
+                target = V[begin_idx:end_idx][...]
+
+                feature = Variable(torch.from_numpy(feature.astype('int64')).long())
+                target = Variable(torch.from_numpy(target))
+                feature, target = feature.cuda(), target.cuda()
+
+                optimizer.zero_grad()
+                logit = self(feature)
+
+                loss = F.mse_loss(logit, target)
+                loss.backward()
+                optimizer.step()
+
+    def get_projection_layer(self, X_train):
+        inputs = Variable(torch.from_numpy(X_train.astype('int64')).long())
+        inputs = inputs.cuda()
+        outputs = self(inputs)
+        return outputs.cpu().data.numpy()
+
 
     # 获取CNN模型的输出
 
@@ -78,7 +118,7 @@ def train(self, X_train, V, item_weight, seed):
     #     np.random.seed(seed)
     #     X_train = np.random.permutation(X_train)
     #     np.random.seed(seed)
-    #     V = np.random.permutation(V)
+    #     V = np.random.permutation(V)ojecti
     #     np.random.seed(seed)
     #     item_weight = np.random.permutation(item_weight)
     #

ml-1m/0.2/train_item.dat

@@ -139,5 +139,6 @@ def train(self, X_train, V, item_weight, seed):
 
     def get_projection_layer(self, X_train):
         X_train = sequence.pad_sequences(X_train, maxlen=self.max_len)
+        X_train = X_train.cuda()
         Y = self.model.predict(X_train, batch_size=len(X_train))
         return Y