def __init__(self, n_items, h_dim_size, wide, wide_dim, fc1=64, fc2=32,): super(WideAndDeepPretrained, self).__init__() self.n_items = n_items self.h_dim_size = h_dim_size self.embedding = EmbeddingGrad(n_items, h_dim_size) self.fc_1 = nn.Linear(h_dim_size, fc1) self.fc_2 = nn.Linear(fc1, fc2) self.wide = EmbeddingGrad(n_items, wide_dim, init_embed=wide) self.output_layer = nn.Linear(wide_dim + fc2, 1)
def __init__(self, config): super(MLP, self).__init__() self.config = config self.num_users = config['num_users'] self.num_items = config['num_items'] self.latent_dim = config['latent_dim'] self.use_cuda = config['use_cuda'] self.use_logit = config["use_logit"] self.device = torch.device('cuda' if self.use_cuda else 'cpu') self.embedding_user = torch.nn.Embedding(num_embeddings=self.num_users, embedding_dim=self.latent_dim) self.embedding = EmbeddingGrad(num_embedding=self.num_items, embedding_dim=self.latent_dim) self.fc_layers = torch.nn.ModuleList() for idx, (in_size, out_size) in enumerate( zip(config['layers'][:-1], config['layers'][1:])): self.fc_layers.append(torch.nn.Linear(in_size, out_size)) self.affine_output = torch.nn.Linear(in_features=config['layers'][-1], out_features=1) self.logistic = torch.nn.Sigmoid() if self.use_cuda: self = self.cuda()
def __init__(self, n_items, h_dim_size, gru_hidden_size, n_layers=3, use_cuda=False, batch_size=32, use_logit=False): super(SRNN, self).__init__() self.batch_size = batch_size self.n_items = n_items self.h_dim_size = h_dim_size self.gru_hidden_size = gru_hidden_size self.n_layers = n_layers self.device = torch.device('cuda' if use_cuda else 'cpu') self.use_cuda = use_cuda self.gru = nn.GRU(input_size=self.h_dim_size, hidden_size=self.h_dim_size, num_layers=self.n_layers) self.activation = nn.Tanh() self.out = nn.Linear(h_dim_size, 1) self.embedding = EmbeddingGrad(n_items, h_dim_size, use_cuda=use_cuda) self.use_logit = use_logit self.logistic = torch.nn.Sigmoid() if use_cuda: self = self.cuda()
def __init__(self, n_users, n_items, n_factors=40, dropout_p=0, sparse=False, use_logit=False, use_cuda=False): """ Parameters ---------- n_users : int Number of users n_items : int Number of items n_factors : int Number of latent factors (or embeddings or whatever you want to call it). dropout_p : float p in nn.Dropout module. Probability of dropout. sparse : bool Whether or not to treat embeddings as sparse. NOTE: cannot use weight decay on the optimizer if sparse=True. Also, can only use Adagrad. """ super(MatrixFactorization, self).__init__() self.n_users = n_users self.n_items = n_items self.n_factors = n_factors self.user_biases = nn.Embedding(n_users, 1, sparse=sparse) self.item_biases = EmbeddingGrad(n_items, 1) self.user_embeddings = nn.Embedding(n_users, n_factors, sparse=sparse) self.item_embeddings = EmbeddingGrad(num_embedding=self.n_items, embedding_dim=self.n_factors) self.dropout_p = dropout_p self.dropout = nn.Dropout(p=self.dropout_p) self.logistic = torch.nn.Sigmoid() self.sparse = sparse self.use_logit = use_logit self.use_cuda = use_cuda self.device = torch.device('cuda' if use_cuda else 'cpu') if use_cuda: self = self.cuda()
def __init__(self, n_items, h_dim_size, use_cuda=False): super(UtilityEncoder, self).__init__() self.n_items = n_items self.h_dim_size = h_dim_size self.device = torch.device('cuda' if use_cuda else 'cpu') self.use_cuda = use_cuda self.embedding = EmbeddingGrad(n_items, h_dim_size) self.weights = nn.Linear(h_dim_size, 1) if use_cuda: self = self.cuda()
def __init__(self, n_users, n_items, h_dim_size, use_cuda, use_logit=False): super(GMF, self).__init__() self.num_users = n_users self.num_items = n_items self.latent_dim = h_dim_size self.device = torch.device('cuda' if use_cuda else 'cpu') self.use_cuda = use_cuda self.use_logit = use_logit self.embedding_user = torch.nn.Embedding(num_embeddings=self.num_users, embedding_dim=self.latent_dim) self.embedding = EmbeddingGrad(num_embedding=self.num_items, embedding_dim=self.latent_dim) self.affine_output = torch.nn.Linear(in_features=self.latent_dim, out_features=1) self.logistic = torch.nn.Sigmoid() if use_cuda: self = self.cuda()
def __init__(self, n_items, h_dim_size, fc1=64, fc2=32, use_cuda=False, use_embedding=True, use_logit=False): super(WideAndDeep, self).__init__() self.n_items = n_items self.h_dim_size = h_dim_size self.device = torch.device('cuda' if use_cuda else 'cpu') self.use_cuda = use_cuda self.use_logit = use_logit self.use_embedding = use_embedding self.embedding = EmbeddingGrad(n_items, h_dim_size, use_cuda=use_cuda) self.fc_1 = nn.Linear(h_dim_size, fc1) self.fc_2 = nn.Linear(fc1, fc2) self.output_layer = nn.Linear(n_items + fc2, 1) self.logistic = torch.nn.Sigmoid() if use_cuda: self = self.cuda()
def __init__(self, field_dims, output_dim=1): super().__init__() self.fc = EmbeddingGrad(sum(field_dims), output_dim) self.bias = torch.nn.Parameter(torch.zeros((output_dim, ))) self.offsets = np.array((0, *np.cumsum(field_dims)[:-1]), dtype=np.long)
def __init__(self, field_dims, embed_dim): super().__init__() self.embedding = EmbeddingGrad(sum(field_dims), embed_dim) self.offsets = np.array((0, *np.cumsum(field_dims)[:-1]), dtype=np.long) torch.nn.init.xavier_uniform_(self.embedding.weights.weight.data)
def __init__(self, backbone, n_items, h_dim_size, use_embedding=True): super(NeuralUtility, self).__init__() self.use_embedding = use_embedding self.embedding = EmbeddingGrad(n_items, h_dim_size) self.backbone = backbone