Merge pull request #31 from hand10ryo/feature/adaptors

Feature/adaptors

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

@@ -11,6 +11,13 @@ def __init__(self, regularizers: list = []):
 
     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:
@@ -34,18 +41,18 @@ def forward(
 
          ---   example code   ---
 
-        # embeddings_dict = {
-        #   "user_embedding": user_emb,
-        #    "pos_item_embedding": pos_item_emb,
-        #    "neg_item_embedding": neg_item_emb,
-        #    "user_bias": user_bias,
-        #    "pos_item_bias": pos_item_bias,
-        #    "neg_item_bias": neg_item_bias,
-        #}
+        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)
-        reg = self.regularize(embeddings_dict)
-        return loss + reg
+
+        return loss
         """
 
         raise NotImplementedError

PyTorchCML/losses/LogitPairwiseLoss.py

@@ -11,10 +11,10 @@ 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.
@@ -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/MSEPairwiseLoss.py

@@ -6,10 +6,10 @@
 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.
@@ -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

PyTorchCML/losses/MinTripletLoss.py

@@ -11,10 +11,10 @@ def __init__(self, margin: float = 1, regularizers: list = []):
         self.margin = margin
         self.ReLU = nn.ReLU()
 
-    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.
@@ -41,6 +41,5 @@ def forward(
         pairwiseloss = self.ReLU(self.margin + pos_dist ** 2 - min_neg_dist.values ** 2)
 
         loss = torch.mean(pairwiseloss)
-        reg = self.regularize(embeddings_dict)
 
-        return loss + reg
+        return loss

PyTorchCML/losses/RelevancePairwiseLoss.py

@@ -28,10 +28,10 @@ def __init__(self, regularizers: list = [], delta: str = "logistic"):
         else:
             raise NotImplementedError
 
-    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.
@@ -79,6 +79,5 @@ def forward(
         neg_loss = self.delta_neg(neg_r_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/SumTripletLoss.py

@@ -12,10 +12,10 @@ def __init__(self, margin: float = 1, regularizers: list = []):
         self.margin = margin
         self.ReLU = nn.ReLU()
 
-    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
@@ -39,6 +39,5 @@ def forward(
 
         tripletloss = self.ReLU(self.margin + pos_dist ** 2 - neg_dist ** 2)
         loss = torch.mean(tripletloss)
-        reg = self.regularize(embeddings_dict)
 
-        return loss + reg
+        return loss

PyTorchCML/models/BaseEmbeddingModel.py

@@ -3,6 +3,8 @@
 import torch
 from torch import nn
 
+from ..adaptors import BaseAdaptor
+
 
 class BaseEmbeddingModel(nn.Module):
     """Class of abstract embeddings model getting embedding or predict relevance from indices."""
@@ -15,6 +17,8 @@ def __init__(
         max_norm: Optional[float] = 1,
         user_embedding_init: Optional[torch.Tensor] = None,
         item_embedding_init: Optional[torch.Tensor] = None,
+        user_adaptor: Optional[BaseAdaptor] = None,
+        item_adaptor: Optional[BaseAdaptor] = None,
     ):
         """Set embeddings.
 
@@ -31,6 +35,8 @@ def __init__(
         self.n_item = n_item
         self.n_dim = n_dim
         self.max_norm = max_norm
+        self.user_adaptor = user_adaptor
+        self.item_adaptor = item_adaptor
 
         if user_embedding_init is None:
             self.user_embedding = nn.Embedding(
@@ -71,7 +77,7 @@ def predict(self, pairs: torch.Tensor) -> torch.Tensor:
         """Method of predicting relevance for each pair of user and item.
 
         Args:
-            pairs (torch.Tensor): Tensor which columns are [user_id, item_id]
+            pairs (torch.Tensor): Tensor whose columns are [user_id, item_id]
 
         Raises:
             NotImplementedError: [description]