torch-rechub 0.0.3__py3-none-any.whl → 0.0.5__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

@@ -1,54 +1,54 @@
-import torch
-import torch.nn as nn
-
-
-class Dice(nn.Module):
-    """The Dice activation function mentioned in the `DIN paper
-    https://arxiv.org/abs/1706.06978`
-    """
-
-    def __init__(self, epsilon=1e-3):
-        super(Dice, self).__init__()
-        self.epsilon = epsilon
-        self.alpha = nn.Parameter(torch.randn(1))
-
-    def forward(self, x: torch.Tensor):
-        # x: N * num_neurons
-        avg = x.mean(dim=1)  # N
-        avg = avg.unsqueeze(dim=1)  # N * 1
-        var = torch.pow(x - avg, 2) + self.epsilon  # N * num_neurons
-        var = var.sum(dim=1).unsqueeze(dim=1)  # N * 1
-
-        ps = (x - avg) / torch.sqrt(var)  # N * 1
-
-        ps = nn.Sigmoid()(ps)  # N * 1
-        return ps * x + (1 - ps) * self.alpha * x
-
-
-def activation_layer(act_name):
-    """Construct activation layers
-
-    Args:
-        act_name: str or nn.Module, name of activation function
-    
-    Returns:
-        act_layer: activation layer
-    """
-    if isinstance(act_name, str):
-        if act_name.lower() == 'sigmoid':
-            act_layer = nn.Sigmoid()
-        elif act_name.lower() == 'relu':
-            act_layer = nn.ReLU(inplace=True)
-        elif act_name.lower() == 'dice':
-            act_layer = Dice()
-        elif act_name.lower() == 'prelu':
-            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:
-        raise NotImplementedError
-    return act_layer
+import torch
+import torch.nn as nn
+
+
+class Dice(nn.Module):
+    """The Dice activation function mentioned in the `DIN paper
+    https://arxiv.org/abs/1706.06978`
+    """
+
+    def __init__(self, epsilon=1e-3):
+        super(Dice, self).__init__()
+        self.epsilon = epsilon
+        self.alpha = nn.Parameter(torch.randn(1))
+
+    def forward(self, x: torch.Tensor):
+        # x: N * num_neurons
+        avg = x.mean(dim=1)  # N
+        avg = avg.unsqueeze(dim=1)  # N * 1
+        var = torch.pow(x - avg, 2) + self.epsilon  # N * num_neurons
+        var = var.sum(dim=1).unsqueeze(dim=1)  # N * 1
+
+        ps = (x - avg) / torch.sqrt(var)  # N * 1
+
+        ps = nn.Sigmoid()(ps)  # N * 1
+        return ps * x + (1 - ps) * self.alpha * x
+
+
+def activation_layer(act_name):
+    """Construct activation layers
+
+    Args:
+        act_name: str or nn.Module, name of activation function
+
+    Returns:
+        act_layer: activation layer
+    """
+    if isinstance(act_name, str):
+        if act_name.lower() == 'sigmoid':
+            act_layer = nn.Sigmoid()
+        elif act_name.lower() == 'relu':
+            act_layer = nn.ReLU(inplace=True)
+        elif act_name.lower() == 'dice':
+            act_layer = Dice()
+        elif act_name.lower() == 'prelu':
+            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:
+        raise NotImplementedError
+    return act_layer

torch_rechub/basic/callback.py

@@ -1,33 +1,33 @@
-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.
-    """
-
-    def __init__(self, patience):
-        self.patience = patience
-        self.trial_counter = 0
-        self.best_auc = 0
-        self.best_weights = None
-
-    def stop_training(self, val_auc, weights):
-        """whether to stop training.
-
-        Args:
-            val_auc (float): auc score in val data.
-            weights (tensor): the weights of model
-        """
-        if val_auc > self.best_auc:
-            self.best_auc = val_auc
-            self.trial_counter = 0
-            self.best_weights = copy.deepcopy(weights)
-            return False
-        elif self.trial_counter + 1 < self.patience:
-            self.trial_counter += 1
-            return False
-        else:
-            return True
+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.
+    """
+
+    def __init__(self, patience):
+        self.patience = patience
+        self.trial_counter = 0
+        self.best_auc = 0
+        self.best_weights = None
+
+    def stop_training(self, val_auc, weights):
+        """whether to stop training.
+
+        Args:
+            val_auc (float): auc score in val data.
+            weights (tensor): the weights of model
+        """
+        if val_auc > self.best_auc:
+            self.best_auc = val_auc
+            self.trial_counter = 0
+            self.best_weights = copy.deepcopy(weights)
+            return False
+        elif self.trial_counter + 1 < self.patience:
+            self.trial_counter += 1
+            return False
+        else:
+            return True

torch_rechub/basic/features.py

@@ -1,94 +1,87 @@
-from ..utils.data import get_auto_embedding_dim
-from .initializers import RandomNormal
-
-
-class SequenceFeature(object):
-    """The Feature Class for Sequence feature or multi-hot feature.
-    In recommendation, there are many user behaviour features which we want to take the sequence model
-    and tag featurs (multi hot) which we want to pooling. Note that if you use this feature, you must padding
-    the feature value before training.
-
-    Args:
-        name (str): feature's name.
-        vocab_size (int): vocabulary size of embedding table.
-        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,
-                 padding_idx=None,
-                 initializer=RandomNormal(0, 0.0001)):
-        self.name = name
-        self.vocab_size = vocab_size
-        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):
-    """The Feature Class for Sparse feature.
-
-    Args:
-        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, shared_with=None, padding_idx=None, initializer=RandomNormal(0, 0.0001)):
-        self.name = name
-        self.vocab_size = vocab_size
-        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):
-    """The Feature Class for Dense feature.
-
-    Args:
-        name (str): feature's name.
-        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, embed_dim = 1):
-        self.name = name
-        self.embed_dim = embed_dim
-
-    def __repr__(self):
-        return f'<DenseFeature {self.name}>'
+from ..utils.data import get_auto_embedding_dim
+from .initializers import RandomNormal
+
+
+class SequenceFeature(object):
+    """The Feature Class for Sequence feature or multi-hot feature.
+    In recommendation, there are many user behaviour features which we want to take the sequence model
+    and tag featurs (multi hot) which we want to pooling. Note that if you use this feature, you must padding
+    the feature value before training.
+
+    Args:
+        name (str): feature's name.
+        vocab_size (int): vocabulary size of embedding table.
+        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, padding_idx=None, initializer=RandomNormal(0, 0.0001)):
+        self.name = name
+        self.vocab_size = vocab_size
+        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):
+    """The Feature Class for Sparse feature.
+
+    Args:
+        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, shared_with=None, padding_idx=None, initializer=RandomNormal(0, 0.0001)):
+        self.name = name
+        self.vocab_size = vocab_size
+        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):
+    """The Feature Class for Dense feature.
+
+    Args:
+        name (str): feature's name.
+        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, embed_dim=1):
+        self.name = name
+        self.embed_dim = embed_dim
+
+    def __repr__(self):
+        return f'<DenseFeature {self.name}>'

torch_rechub/basic/initializers.py

@@ -1,92 +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
+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