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_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_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()
class NeuralUtility(nn.Module):
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
def get_input_grad(self, indices):
"""
Get gradients with respect to inputs
:param indices: (ndarray) array of item indices
:return: (tensor) tensor of gradients with respect to inputs
"""
if indices.ndim == 1:
indices = indices.reshape(-1, 1)
dims = [d for d in indices.shape] + [1]
idx_tensor = torch.LongTensor(indices).reshape(dims)
if self.use_embedding:
grad = self.embedding.get_grad(indices)
else:
grad = self.backbone.embedding.get_grad(indices)
grad_at_idx = torch.gather(grad, -1, idx_tensor)
return torch.squeeze(grad_at_idx)
def forward(self, users, items):
if self.use_embedding:
e_i = self.embedding.forward(users)
y_hat = self.backbone.forward(e_i)
else:
y_hat = self.backbone.forward(users, items)
return y_hat
def predict(self, users, items):
return self.forward(users, items)
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)
class SRNN(nn.Module):
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 forward(self, users, items):
embedded = self.embedding(items)
#embedded = embedded.unsqueeze(0)
o, h = self.gru(torch.transpose(torch.squeeze(embedded), 0, 1))
# o = o.view(-1, o.size(-1))
y_hat = torch.squeeze(self.activation(self.out(o)))
if self.use_logit:
y_hat = self.logistic(y_hat)
return torch.transpose(y_hat, 0, 1)
def one_hot(self, input):
self.one_hot_embedding.zero_()
index = input.view(-1, 1)
one_hot = self.one_hot_embedding.scatter_(1, index, 1)
return one_hot
def init_onehot_embedding(self):
onehot = torch.FloatTensor(self.batch_size, self.n_items)
onehot = onehot.to(self.device)
return onehot
def get_input_grad(self, indices):
"""
Get gradients with respect to inputs
:param indices: (ndarray) array of item indices
:return: (tensor) tensor of gradients with respect to inputs
"""
if indices.ndim == 1:
indices = indices.reshape(-1, 1)
dims = [d for d in indices.shape] + [1]
idx_tensor = torch.LongTensor(indices).reshape(dims)
grad = self.embedding.get_grad(indices)
grad_at_idx = torch.gather(grad, -1, idx_tensor)
return torch.squeeze(grad_at_idx)
def predict(self, X_test):
n_samples = X_test.shape[0]
h = torch.zeros(self.n_layers, n_samples,
self.h_dim_size).to(self.device)
return self.forward(X_test, hidden=h)
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
class WideAndDeepPretrained(nn.Module):
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 get_input_grad(self, indices):
"""
Get gradients with respect to inputs
:param indices: (ndarray) array of item indices
:return: (tensor) tensor of gradients with respect to inputs
"""
if indices.ndim == 1:
indices = indices.reshape(-1, 1)
dims = [d for d in indices.shape] + [1]
idx_tensor = torch.LongTensor(indices).reshape(dims)
grad = self.embedding.get_grad(indices)
grad_at_idx = torch.gather(grad, -1, idx_tensor)
return torch.squeeze(grad_at_idx)
def _forward_set(self, x):
h = self.embedding(x)
h = F.relu(self.fc_1(h))
h = F.relu(self.fc_2(h))
wide = self.wide(x)
h = torch.cat([h, wide], dim=-1)
y_hat = self.output_layer(h)
return y_hat
def forward(self, x, x_c=None, x_s=None):
y_hat = self._forward_set(x)
if x_c is not None and x_s is not None:
y_hat_c = self._forward_set(x_c)
y_hat_s = self._forward_set(x_s)
return y_hat, torch.squeeze(y_hat_c), torch.squeeze(y_hat_s)
else:
return y_hat
def fit(self, X_train, y_train, batch_size, k, lr, n_epochs, loss_step, eps):
pass
def predict(self, X_test):
pass