Update init args, fix dimension mismatch in ConvMF (#348)

Author: tqtg

cornac/models/conv_mf/convmf.py

@@ -16,18 +16,29 @@
 import tensorflow as tf
 
 
-def conv_layer(input, num_input_channels,
-               filter_height, filter_width,
-               num_filters, seed=None, use_pooling=True):
+def conv_layer(
+    input,
+    num_input_channels,
+    filter_height,
+    filter_width,
+    num_filters,
+    seed=None,
+    use_pooling=True,
+):
     shape = [filter_height, filter_width, num_input_channels, num_filters]
     weights = tf.Variable(tf.truncated_normal(shape, stddev=0.05, seed=seed))
     biases = tf.Variable(tf.constant(0.05, shape=[num_filters]))
-    layer = tf.nn.conv2d(input=input, filter=weights,
-                         strides=[1, 1, 1, 1], padding="VALID")
+    layer = tf.nn.conv2d(
+        input=input, filter=weights, strides=[1, 1, 1, 1], padding="VALID"
+    )
     layer = layer + biases
     if use_pooling:
-        layer = tf.nn.max_pool(value=layer, ksize=[1, input.shape[1] - filter_height + 1, 1, 1],
-                               strides=[1, 1, 1, 1], padding="VALID")
+        layer = tf.nn.max_pool(
+            value=layer,
+            ksize=[1, input.shape[1] - filter_height + 1, 1, 1],
+            strides=[1, 1, 1, 1],
+            padding="VALID",
+        )
     layer = tf.nn.relu(layer)
     return layer, weights
 
@@ -40,28 +51,39 @@ def flatten_layer(layer):
 
 
 def fc_layer(input, num_input, num_output, seed=None):
-    weights = tf.Variable(tf.truncated_normal([num_input, num_output], stddev=0.05, seed=seed))
+    weights = tf.Variable(
+        tf.truncated_normal([num_input, num_output], stddev=0.05, seed=seed)
+    )
     biases = tf.Variable(tf.constant(0.05, shape=[num_output]))
     layer = tf.matmul(input, weights) + biases
     layer = tf.nn.tanh(layer)
     return layer
 
 
-class CNN_module():
-
-    def __init__(self, output_dimension, dropout_rate,
-                 emb_dim, max_len, nb_filters, seed,
-                 init_W, learning_rate=0.001):
+class CNN_module:
+    def __init__(
+        self,
+        output_dimension,
+        dropout_rate,
+        emb_dim,
+        max_len,
+        filter_sizes,
+        num_filters,
+        hidden_dim,
+        seed,
+        init_W,
+        learning_rate=0.001,
+    ):
         self.drop_rate = dropout_rate
         self.max_len = max_len
         self.seed = seed
         self.learning_rate = learning_rate
         self.init_W = tf.constant(init_W)
         self.output_dimension = output_dimension
         self.emb_dim = emb_dim
-        self.nb_filters = nb_filters
-        self.filter_lengths = [3, 4, 5]
-        self.vanila_dimension = 200
+        self.filter_lengths = filter_sizes
+        self.nb_filters = num_filters
+        self.vanila_dimension = hidden_dim
 
         self._build_graph()
 
@@ -76,28 +98,46 @@ def _build_graph(self):
         self.reshape = tf.reshape(self.seq_emb, [-1, self.max_len, self.emb_dim, 1])
         self.convs = []
 
-        # Convolutional layer
+        # Convolutional layers
         for i in self.filter_lengths:
-            convolutional_layer, weights = conv_layer(input=self.reshape, num_input_channels=1,
-                                                      filter_height=i, filter_width=self.emb_dim,
-                                                      num_filters=self.nb_filters, use_pooling=True)
+            convolutional_layer, weights = conv_layer(
+                input=self.reshape,
+                num_input_channels=1,
+                filter_height=i,
+                filter_width=self.emb_dim,
+                num_filters=self.nb_filters,
+                use_pooling=True,
+            )
 
             flat_layer, _ = flatten_layer(convolutional_layer)
             self.convs.append(flat_layer)
 
         self.model_output = tf.concat(self.convs, axis=-1)
         # Fully-connected layers
-        self.model_output = fc_layer(input=self.model_output, num_input=self.model_input.get_shape()[1].value,
-                                     num_output=self.vanila_dimension)
+        self.model_output = fc_layer(
+            input=self.model_output,
+            num_input=self.model_output.get_shape()[-1].value,
+            num_output=self.vanila_dimension,
+        )
         # Dropout layer
         self.model_output = tf.nn.dropout(self.model_output, self.drop_rate)
         # Output layer
-        self.model_output = fc_layer(input=self.model_output, num_input=self.vanila_dimension,
-                                     num_output=self.output_dimension)
+        self.model_output = fc_layer(
+            input=self.model_output,
+            num_input=self.vanila_dimension,
+            num_output=self.output_dimension,
+        )
         # Weighted MEA loss function
-        self.mean_square_loss = tf.losses.mean_squared_error(labels=self.v, predictions=self.model_output,
-                                                             reduction=tf.losses.Reduction.NONE)
+        self.mean_square_loss = tf.losses.mean_squared_error(
+            labels=self.v,
+            predictions=self.model_output,
+            reduction=tf.losses.Reduction.NONE,
+        )
         self.weighted_loss = tf.reduce_sum(
-            tf.reduce_sum(self.mean_square_loss, axis=1, keepdims=True) * self.sample_weight)
+            tf.reduce_sum(self.mean_square_loss, axis=1, keepdims=True)
+            * self.sample_weight
+        )
         # RMSPro optimizer
-        self.optimizer = tf.train.RMSPropOptimizer(learning_rate=self.learning_rate).minimize(self.weighted_loss)
+        self.optimizer = tf.train.RMSPropOptimizer(
+            learning_rate=self.learning_rate
+        ).minimize(self.weighted_loss)

cornac/models/conv_mf/recom_convmf.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 
+import os
 import time
 import math
 
@@ -35,6 +36,9 @@ class ConvMF(Recommender):
     n_epochs: int, optional, default: 50
         Maximum number of epochs for training.
 
+    cnn_epochs: int, optional, default: 5
+        Number of epochs for optimizing the CNN for each overall training epoch.
+
     lambda_u: float, optional, default: 1.0
         The regularization hyper-parameter for user latent factor.
 
@@ -47,8 +51,14 @@ class ConvMF(Recommender):
     max_len: int, optional, default 300
         The maximum length of item's document
 
-    num_kernel_per_ws: int, optional, default: 100
-        The number of kernel filter in convolutional layer
+    filter_sizes: list, optional, default: [3, 4, 5]
+        The length of filters in convolutional layer
+
+    num_filters: int, optional, default: 100
+        The number of filters in convolutional layer
+        
+    hidden_dim: int, optional, default: 200
+        The dimension of hidden layer after the pooling of all convolutional layers
 
     dropout_rate: float, optional, default: 0.2
         Dropout rate while training CNN
@@ -71,19 +81,21 @@ class ConvMF(Recommender):
 
     def __init__(
         self,
-        give_item_weight=True,
-        cnn_epochs=5,
+        name="ConvMF",
+        k=50,
         n_epochs=50,
+        cnn_epochs=5,
         lambda_u=1,
         lambda_v=100,
-        k=50,
-        name="ConvMF",
-        trainable=True,
-        verbose=False,
-        dropout_rate=0.2,
         emb_dim=200,
         max_len=300,
-        num_kernel_per_ws=100,
+        filter_sizes=[3, 4, 5],
+        num_filters=100,
+        hidden_dim=200,
+        dropout_rate=0.2,
+        give_item_weight=True,
+        trainable=True,
+        verbose=False,
         init_params=None,
         seed=None,
     ):
@@ -96,7 +108,9 @@ def __init__(
         self.dropout_rate = dropout_rate
         self.emb_dim = emb_dim
         self.max_len = max_len
-        self.num_kernel_per_ws = num_kernel_per_ws
+        self.filter_sizes = filter_sizes
+        self.num_filters = num_filters
+        self.hidden_dim = hidden_dim
         self.name = name
         self.verbose = verbose
         self.cnn_epochs = cnn_epochs
@@ -138,7 +152,7 @@ def fit(self, train_set, val_set=None):
         Recommender.fit(self, train_set, val_set)
 
         self._init()
-            
+
         if self.trainable:
             self._fit_convmf()
 
@@ -175,16 +189,22 @@ def _fit_convmf(self):
             item_weight = np.ones(n_item, dtype=float)
 
         # Initialize cnn module
+        import tensorflow.compat.v1 as tf
         from .convmf import CNN_module
-        import tensorflow as tf
+        
+        # less verbose TF
+        os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+        tf.logging.set_verbosity(tf.logging.ERROR)
 
         tf.set_random_seed(self.seed)
         cnn_module = CNN_module(
             output_dimension=self.k,
             dropout_rate=self.dropout_rate,
             emb_dim=self.emb_dim,
             max_len=self.max_len,
-            nb_filters=self.num_kernel_per_ws,
+            filter_sizes=self.filter_sizes,
+            num_filters=self.num_filters,
+            hidden_dim=self.hidden_dim,
             seed=self.seed,
             init_W=self.W,
         )
@@ -207,8 +227,10 @@ def _fit_convmf(self):
         history = 1e-50
         loss = 0
 
-        for iter in range(self.n_epochs):
-            print("Iteration {}".format(iter + 1))
+        for epoch in range(1, self.n_epochs + 1):
+            if self.verbose:
+                print("Epoch: {}/{}".format(epoch, self.n_epochs))
+            
             tic = time.time()
 
             user_loss = np.zeros(n_user)
@@ -229,17 +251,15 @@ def _fit_convmf(self):
                 U_j = self.U[idx_user]
                 R_j = R_item[j]
 
-                A = self.lambda_v * item_weight[j] * np.eye(self.k) + U_j.T.dot(
-                    U_j
-                )
+                A = self.lambda_v * item_weight[j] * np.eye(self.k) + U_j.T.dot(U_j)
                 B = (U_j * (np.tile(R_j, (self.k, 1)).T)).sum(
                     0
                 ) + self.lambda_v * item_weight[j] * theta[j]
                 self.V[j] = np.linalg.solve(A, B)
 
                 item_loss[j] = -np.square(R_j - U_j.dot(self.V[j])).sum()
 
-            loop = trange(self.cnn_epochs, desc="CNN", disable=not self.verbose)
+            loop = trange(self.cnn_epochs, desc="Optimizing CNN", disable=not self.verbose)
             for _ in loop:
                 for batch_ids in self.train_set.item_iter(batch_size=128, shuffle=True):
                     batch_seq = self.train_set.item_text.batch_seq(
@@ -271,9 +291,12 @@ def _fit_convmf(self):
             toc = time.time()
             elapsed = toc - tic
             converge = abs((loss - history) / history)
-            print(
-                "Loss: %.5f Elpased: %.4fs Converge: %.6f " % (loss, elapsed, converge)
-            )
+            
+            if self.verbose:
+                print(
+                    "Loss: %.5f Elpased: %.4fs Converge: %.6f " % (loss, elapsed, converge)
+                )
+                
             history = loss
             if converge < converge_threshold:
                 endure -= 1

cornac/models/conv_mf/requirements.txt

@@ -1 +1 @@
-tensorflow>=1.10.0
+tensorflow>=1.15.2