torch-rechub 0.0.1__py3-none-any.whl → 0.0.4__py3-none-any.whl

torch_rechub/__init__.py

@@ -0,0 +1,14 @@
+"""Torch-RecHub: A PyTorch Toolbox for Recommendation Models."""
+
+__version__ = "0.1.0"
+
+# 导入主要模块
+from . import basic, models, trainers, utils
+
+__all__ = [
+    "__version__",
+    "basic",
+    "models",
+    "trainers",
+    "utils",
+]

torch_rechub/basic/activation.py

@@ -30,7 +30,7 @@ def activation_layer(act_name):
 
     Args:
         act_name: str or nn.Module, name of activation function
-    
+
     Returns:
         act_layer: activation layer
     """
@@ -45,6 +45,8 @@ def activation_layer(act_name):
             act_layer = nn.PReLU()
         elif act_name.lower() == "softmax":
             act_layer = nn.Softmax(dim=1)
+        elif act_name.lower() == 'leakyrelu':
+            act_layer = nn.LeakyReLU()
     elif issubclass(act_name, nn.Module):
         act_layer = act_name()
     else:

torch_rechub/basic/callback.py

@@ -3,7 +3,7 @@ import copy
 
 class EarlyStopper(object):
     """Early stops the training if validation loss doesn't improve after a given patience.
-        
+
     Args:
         patience (int): How long to wait after last time validation auc improved.
     """
@@ -30,4 +30,4 @@ class EarlyStopper(object):
             self.trial_counter += 1
             return False
         else:
-            return True
+            return True

torch_rechub/basic/features.py

@@ -1,4 +1,5 @@
-from .utils import get_auto_embedding_dim
+from ..utils.data import get_auto_embedding_dim
+from .initializers import RandomNormal
 
 
 class SequenceFeature(object):
@@ -13,17 +14,29 @@ class SequenceFeature(object):
         embed_dim (int): embedding vector's length
         pooling (str): pooling method, support `["mean", "sum", "concat"]` (default=`"mean"`)
         shared_with (str): the another feature name which this feature will shared with embedding.
+        padding_idx (int, optional): If specified, the entries at padding_idx will be masked 0 in InputMask Layer.
+        initializer(Initializer): Initializer the embedding layer weight.
     """
 
-    def __init__(self, name, vocab_size, embed_dim=None, pooling="mean", shared_with=None):
+    def __init__(self, name, vocab_size, embed_dim=None, pooling="mean", shared_with=None, padding_idx=None, initializer=RandomNormal(0, 0.0001)):
         self.name = name
         self.vocab_size = vocab_size
-        if embed_dim == None:
+        if embed_dim is None:
             self.embed_dim = get_auto_embedding_dim(vocab_size)
         else:
             self.embed_dim = embed_dim
         self.pooling = pooling
         self.shared_with = shared_with
+        self.padding_idx = padding_idx
+        self.initializer = initializer
+
+    def __repr__(self):
+        return f'<SequenceFeature {self.name} with Embedding shape ({self.vocab_size}, {self.embed_dim})>'
+
+    def get_embedding_layer(self):
+        if not hasattr(self, 'embed'):
+            self.embed = self.initializer(self.vocab_size, self.embed_dim)
+        return self.embed
 
 
 class SparseFeature(object):
@@ -33,15 +46,29 @@ class SparseFeature(object):
         name (str): feature's name.
         vocab_size (int): vocabulary size of embedding table.
         embed_dim (int): embedding vector's length
+        shared_with (str): the another feature name which this feature will shared with embedding.
+        padding_idx (int, optional): If specified, the entries at padding_idx will be masked 0 in InputMask Layer.
+        initializer(Initializer): Initializer the embedding layer weight.
     """
 
-    def __init__(self, name, vocab_size, embed_dim=None):
+    def __init__(self, name, vocab_size, embed_dim=None, shared_with=None, padding_idx=None, initializer=RandomNormal(0, 0.0001)):
         self.name = name
         self.vocab_size = vocab_size
-        if embed_dim == None:
+        if embed_dim is None:
             self.embed_dim = get_auto_embedding_dim(vocab_size)
         else:
             self.embed_dim = embed_dim
+        self.shared_with = shared_with
+        self.padding_idx = padding_idx
+        self.initializer = initializer
+
+    def __repr__(self):
+        return f'<SparseFeature {self.name} with Embedding shape ({self.vocab_size}, {self.embed_dim})>'
+
+    def get_embedding_layer(self):
+        if not hasattr(self, 'embed'):
+            self.embed = self.initializer(self.vocab_size, self.embed_dim)
+        return self.embed
 
 
 class DenseFeature(object):
@@ -49,9 +76,12 @@ class DenseFeature(object):
 
     Args:
         name (str): feature's name.
-        embed_dim (int): embedding vector's length, the value fixed `1`.
+        embed_dim (int): embedding vector's length, the value fixed `1`. If you put a vector (torch.tensor) , replace the embed_dim with your vector dimension.
     """
 
-    def __init__(self, name):
+    def __init__(self, name, embed_dim=1):
         self.name = name
-        self.embed_dim = 1
+        self.embed_dim = embed_dim
+
+    def __repr__(self):
+        return f'<DenseFeature {self.name}>'

torch_rechub/basic/initializers.py

@@ -0,0 +1,92 @@
+import torch
+
+
+class RandomNormal(object):
+    """Returns an embedding initialized with a normal distribution.
+
+    Args:
+        mean (float): the mean of the normal distribution
+        std (float): the standard deviation of the normal distribution
+    """
+
+    def __init__(self, mean=0.0, std=1.0):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, vocab_size, embed_dim):
+        embed = torch.nn.Embedding(vocab_size, embed_dim)
+        torch.nn.init.normal_(embed.weight, self.mean, self.std)
+        return embed
+
+
+class RandomUniform(object):
+    """Returns an embedding initialized with a uniform distribution.
+
+    Args:
+        minval (float): Lower bound of the range of random values of the uniform distribution.
+        maxval (float): Upper bound of the range of random values of the uniform distribution.
+    """
+
+    def __init__(self, minval=0.0, maxval=1.0):
+        self.minval = minval
+        self.maxval = maxval
+
+    def __call__(self, vocab_size, embed_dim):
+        embed = torch.nn.Embedding(vocab_size, embed_dim)
+        torch.nn.init.uniform_(embed.weight, self.minval, self.maxval)
+        return embed
+
+
+class XavierNormal(object):
+    """Returns an embedding initialized with  the method described in
+    `Understanding the difficulty of training deep feedforward neural networks`
+    - Glorot, X. & Bengio, Y. (2010), using a uniform distribution.
+
+    Args:
+        gain (float): stddev = gain*sqrt(2 / (fan_in + fan_out))
+    """
+
+    def __init__(self, gain=1.0):
+        self.gain = gain
+
+    def __call__(self, vocab_size, embed_dim):
+        embed = torch.nn.Embedding(vocab_size, embed_dim)
+        torch.nn.init.xavier_normal_(embed.weight, self.gain)
+        return embed
+
+
+class XavierUniform(object):
+    """Returns an embedding initialized with the method described in
+    `Understanding the difficulty of training deep feedforward neural networks`
+    - Glorot, X. & Bengio, Y. (2010), using a uniform distribution.
+
+    Args:
+        gain (float): stddev = gain*sqrt(6 / (fan_in + fan_out))
+    """
+
+    def __init__(self, gain=1.0):
+        self.gain = gain
+
+    def __call__(self, vocab_size, embed_dim):
+        embed = torch.nn.Embedding(vocab_size, embed_dim)
+        torch.nn.init.xavier_uniform_(embed.weight, self.gain)
+        return embed
+
+
+class Pretrained(object):
+    """Creates Embedding instance from given 2-dimensional FloatTensor.
+
+    Args:
+        embedding_weight(Tensor or ndarray or List[List[int]]): FloatTensor containing weights for the Embedding.
+                First dimension is being passed to Embedding as ``num_embeddings``, second as ``embedding_dim``.
+        freeze (boolean, optional): If ``True``, the tensor does not get updated in the learning process.
+    """
+
+    def __init__(self, embedding_weight, freeze=True):
+        self.embedding_weight = torch.FloatTensor(embedding_weight)
+        self.freeze = freeze
+
+    def __call__(self, vocab_size, embed_dim):
+        assert vocab_size == self.embedding_weight.shape[0] and embed_dim == self.embedding_weight.shape[1]
+        embed = torch.nn.Embedding.from_pretrained(self.embedding_weight, freeze=self.freeze)
+        return embed