Merge pull request #32 from hand10ryo/develop

Develop

Author: hand10ryo

PyTorchCML/adaptors/BaseAdaptor.py

@@ -0,0 +1,26 @@
+from torch import nn
+
+
+class BaseAdaptor(nn.Module):
+    """Astract class of module for domain adaptation."""
+
+    def __init__(self, weight):
+        """Set some parameters
+
+        Args:
+            weight (float, optional): Loss weights for domain adaptation. Defaults to 1e-3.
+        """
+        super().__init__()
+        self.weight = weight
+
+    def forward(self, indices, embeddings):
+        """Method to calculate loss for domain adaptation.
+
+        Args:
+            indices (torch.Tensor): Indices of users or items. size = (n_user, n_sample)
+            embeddings (torch.Tensor): The embeddings corresponding to indices. size = (n_user, n_sample, n_dim)
+
+        Raises:
+            NotImplementedError: [description]
+        """
+        raise NotImplementedError

PyTorchCML/adaptors/MLPAdaptor.py

@@ -0,0 +1,55 @@
+import torch
+
+from torch import nn
+
+from .BaseAdaptor import BaseAdaptor
+
+
+class MLPAdaptor(BaseAdaptor):
+    """Class of module for domain adaptation with MLP."""
+
+    def __init__(
+        self,
+        features: torch.Tensor,
+        n_dim: int = 20,
+        n_hidden: list = [100],
+        weight: float = 1e-3,
+    ):
+        """Set MLP model for domain adaptation.
+
+        Args:
+            features (torch.Tensor): A feature of users or items. size = (n_user, n_feature)
+            n_dim (int, optional): A number of dimention of embeddings. Defaults to 20.
+            n_hidden (list, optional): A list of numbers of neuron for each hidden layers. Defaults to [100].
+            weight (float, optional): Loss weights for domain adaptation. Defaults to 1e-3.
+        """
+        super().__init__(weight)
+        self.features_embeddings = nn.Embedding.from_pretrained(features)
+        self.features_embeddings.weight.requires_grad = False
+
+        self.n_input = features.shape[1]
+        self.n_hidden = n_hidden
+        self.n_output = n_dim
+
+        projection_layers = [nn.Linear(self.n_input, self.n_hidden[0]), nn.ReLU()]
+        for i in range(len(self.n_hidden) - 1):
+            layer = [nn.Linear(self.n_hidden[i], self.n_hidden[i + 1]), nn.ReLU()]
+            projection_layers += layer
+        projection_layers += [nn.Linear(self.n_hidden[-1], self.n_output)]
+
+        self.projector = nn.Sequential(*projection_layers)
+
+    def forward(self, indices: torch.Tensor, embeddings: torch.Tensor):
+        """Method to calculate loss for domain adaptation.
+
+        Args:
+            indices (torch.Tensor): Indices of users or items. size = (n_user, n_sample)
+            embeddings (torch.Tensor): The embeddings corresponding to indices. size = (n_user, n_sample, n_dim)
+
+        Returns:
+            [torch.Tensor]: loss for domain adaptation. dim = 0.
+        """
+        features = self.features_embeddings(indices)
+        projection = self.projector(features)
+        dist = torch.sqrt(torch.pow(projection - embeddings, 2).sum(axis=2))
+        return self.weight * dist.sum()

PyTorchCML/adaptors/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+from .BaseAdaptor import BaseAdaptor
+from .MLPAdaptor import MLPAdaptor

PyTorchCML/losses/BaseLoss.py

@@ -0,0 +1,65 @@
+import torch
+from torch import nn
+
+
+class BaseLoss(nn.Module):
+    """Class of abstract loss module for pairwise loss like matrix factorization."""
+
+    def __init__(self, regularizers: list = []):
+        super().__init__()
+        self.regularizers = regularizers
+
+    def forward(
+        self, embeddings_dict: dict, batch: torch.Tensor, column_names: dict
+    ) -> torch.Tensor:
+        loss = self.main(embeddings_dict, batch, column_names)
+        loss += self.regularize(embeddings_dict)
+        return loss
+
+    def main(
+        self, embeddings_dict: dict, batch: torch.Tensor, column_names: dict
+    ) -> torch.Tensor:
+        """
+        Args:
+            embeddings_dict (dict): A dictionary of embddings.
+            (e.g. It has following key and values.)
+                user_embedding : embeddings of user, size (n_batch, 1, d)
+                pos_item_embedding : embeddings of positive item, size (n_batch, 1, d)
+                neg_item_embedding : embeddings of negative item, size (n_batch, n_neg_samples, d)
+                user_bias : bias of user, size (n_batch, 1)
+                pos_item_bias : bias of positive item, size (n_batch, 1)
+                neg_item_bias : bias of negative item, size (n_batch, n_neg_samples)
+
+            batch (torch.Tensor) : A tensor of batch, size (n_batch, *).
+            column_names (dict) : A dictionary that maps names to indices of rows of batch.
+
+        Raises:
+            NotImplementedError: [description]
+
+        Returns:
+            torch.Tensor: [description]
+
+         ---   example code   ---
+
+        embeddings_dict = {
+           "user_embedding": user_embedding,
+            "pos_item_embedding": pos_item_embedding,
+            "neg_item_embedding": neg_item_embedding,
+            "user_bias": user_bias,
+            "pos_item_bias": pos_item_bias,
+            "neg_item_bias": neg_item_bias,
+        }
+
+        loss = loss_function(embeddings_dict, batch, column_names)
+
+        return loss
+        """
+
+        raise NotImplementedError
+
+    def regularize(self, embeddings_dict: dict):
+        reg = 0
+        for regularizer in self.regularizers:
+            reg += regularizer(embeddings_dict)
+
+        return reg

PyTorchCML/losses/BasePairwiseLoss.py

@@ -1,25 +1,25 @@
 import torch
 from torch import nn
 
-from .BasePairwiseLoss import BasePairwiseLoss
+from .BaseLoss import BaseLoss
 
 
-class LogitPairwiseLoss(BasePairwiseLoss):
+class LogitPairwiseLoss(BaseLoss):
     """Class of pairwise logit loss for Logistic Matrix Factorization"""
 
     def __init__(self, regularizers: list = []):
         super().__init__(regularizers)
         self.LogSigmoid = nn.LogSigmoid()
 
-    def forward(
+    def main(
         self, embeddings_dict: dict, batch: torch.Tensor, column_names: dict
     ) -> torch.Tensor:
-        """Method of forwarding loss
+        """Method of forwarding main loss
 
         Args:
             embeddings_dict (dict): A dictionary of embddings which has following key and values.
-                user_embedding : embeddings of user, size (n_batch, d)
-                pos_item_embedding : embeddings of positive item, size (n_batch, d)
+                user_embedding : embeddings of user, size (n_batch, 1, d)
+                pos_item_embedding : embeddings of positive item, size (n_batch, 1, d)
                 neg_item_embedding : embeddings of negative item, size (n_batch, n_neg_samples, d)
                 user_bias : bias of user, size (n_batch, 1)
                 pos_item_bias : bias of positive item, size (n_batch, 1)
@@ -34,13 +34,13 @@ def forward(
         n_pos = 1
 
         pos_inner = torch.einsum(
-            "nd,nd->n",
+            "nid,nid->n",
             embeddings_dict["user_embedding"],
             embeddings_dict["pos_item_embedding"],
         )
 
         neg_inner = torch.einsum(
-            "nd,njd->nj",
+            "nid,njd->nj",
             embeddings_dict["user_embedding"],
             embeddings_dict["neg_item_embedding"],
         )
@@ -55,6 +55,5 @@ def forward(
         neg_loss = -nn.LogSigmoid()(-neg_y_hat).sum()
 
         loss = (pos_loss + neg_loss) / (n_batch * (n_pos + n_neg))
-        reg = self.regularize(embeddings_dict)
 
-        return loss + reg
+        return loss

PyTorchCML/losses/BaseTripletLoss.py

@@ -1,20 +1,20 @@
 import torch
 
-from .BasePairwiseLoss import BasePairwiseLoss
+from .BaseLoss import BaseLoss
 
 
-class MSEPairwiseLoss(BasePairwiseLoss):
+class MSEPairwiseLoss(BaseLoss):
     """Class of loss for MSE in implicit feedback"""
 
-    def forward(
+    def main(
         self, embeddings_dict: dict, batch: torch.Tensor, column_names: dict
     ) -> torch.Tensor:
-        """Method of forwarding loss
+        """Method of forwarding main loss
 
         Args:
             embeddings_dict (dict): A dictionary of embddings which has following key and values.
-                "user_embedding" : embeddings of user, size (n_batch, d)
-                "pos_item_embedding" : embeddings of positive item, size (n_batch, d)
+                "user_embedding" : embeddings of user, size (n_batch, 1, d)
+                "pos_item_embedding" : embeddings of positive item, size (n_batch, 1, d)
                 "neg_item_embedding" : embeddings of negative item, size (n_batch, n_neg_samples, d)
                 "user_bias" : bias of user, size (n_batch, 1)
                 "pos_item_bias" : bias of positive item, size (n_batch, 1)
@@ -32,13 +32,13 @@ def forward(
         n_pos = 1
 
         pos_inner = torch.einsum(
-            "nd,nd->n",
+            "nid,nid->n",
             embeddings_dict["user_embedding"],
             embeddings_dict["pos_item_embedding"],
         )
 
         neg_inner = torch.einsum(
-            "nd,njd->nj",
+            "nid,njd->nj",
             embeddings_dict["user_embedding"],
             embeddings_dict["neg_item_embedding"],
         )
@@ -53,6 +53,5 @@ def forward(
         neg_loss = (torch.sigmoid(neg_r_hat) ** 2).sum()
 
         loss = (pos_loss + neg_loss) / (n_batch * (n_pos + n_neg))
-        reg = self.regularize(embeddings_dict)
 
-        return loss + reg
+        return loss