def fit(self, interactions, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.SequenceInteractions`
The input sequence dataset.
"""
sequences = interactions.sequences.astype(np.int64)
if not self._initialized:
self._initialize(interactions)
self._check_input(sequences)
for epoch_num in range(self._n_iter):
sequences = shuffle(sequences, random_state=self._random_state)
sequences_tensor = gpu(torch.from_numpy(sequences), self._use_cuda)
epoch_loss = 0.0
for minibatch_num, batch_sequence in enumerate(minibatch(sequences_tensor, batch_size=self._batch_size)):
sequence_var = batch_sequence
user_representation, _ = self._net.user_representation(sequence_var)
positive_prediction = self._net(user_representation, sequence_var)
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
sequence_var.size(), user_representation, n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(sequence_var.size(), user_representation)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction, negative_prediction, mask=(sequence_var != PADDING_IDX))
epoch_loss += loss.item()
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError('Degenerate epoch loss: {}'.format(epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset. Must have ratings.
verbose: bool
Output additional information about current epoch and loss.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
for epoch_num in range(self._n_iter):
users, items, ratings = shuffle(user_ids, item_ids, interactions.ratings, random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
ratings_tensor = gpu(torch.from_numpy(ratings), self._use_cuda)
epoch_loss = 0.0
for (minibatch_num, (batch_user, batch_item, batch_ratings)) in enumerate(
minibatch(user_ids_tensor, item_ids_tensor, ratings_tensor, batch_size=self._batch_size)):
predictions = self._net(batch_user, batch_item)
if self._loss == 'poisson':
predictions = torch.exp(predictions)
self._optimizer.zero_grad()
loss = self._loss_func(batch_ratings, predictions)
epoch_loss += loss.item()
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError('Degenerate epoch loss: {}'.format(epoch_loss))
def _get_validation_loss(self, sequences, weights):
with torch.no_grad():
sequences, weights = shuffle(sequences,
weights,
random_state=self._random_state)
sequences_tensor = gpu(torch.from_numpy(sequences),
self._use_cuda).detach()
weights_tensor = gpu(torch.from_numpy(weights),
self._use_cuda).detach()
epoch_loss = 0
for minibatch_num, (batch_sequence, batch_weights) in enumerate(
minibatch(sequences_tensor,
weights_tensor,
batch_size=self._batch_size)):
sequence_var = batch_sequence
weights_var = batch_weights
user_representation, _ = self._net.user_representation(
sequence_var)
user_representation = user_representation.detach()
positive_prediction = self._net(user_representation,
sequence_var).detach()
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
sequence_var.size(),
user_representation,
n=self._num_negative_samples).detach()
else:
negative_prediction = self._get_negative_prediction(
sequence_var.size(), user_representation).detach()
loss = self._loss_func(positive_prediction,
negative_prediction,
mask=(sequence_var != PADDING_IDX),
weights=weights_var).detach()
epoch_loss += loss.item()
epoch_loss /= minibatch_num + 1
return epoch_loss
def _get_validation_loss(self, interactions):
with torch.no_grad():
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
weights = interactions.weights.astype(np.float32)
users, items, weights = shuffle(user_ids,
item_ids,
weights,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users),
self._use_cuda).detach()
item_ids_tensor = gpu(torch.from_numpy(items),
self._use_cuda).detach()
weights_tensor = gpu(torch.from_numpy(weights),
self._use_cuda).detach()
epoch_loss = 0
for (minibatch_num, (batch_user, batch_item,
batch_weight)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
weights_tensor,
batch_size=self._batch_size)):
positive_prediction = self._net(batch_user,
batch_item).detach()
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
batch_user, n=self._num_negative_samples).detach()
else:
negative_prediction = self._get_negative_prediction(
batch_user).detach()
loss = self._loss_func(positive_prediction,
negative_prediction,
weights=batch_weight).detach()
epoch_loss += loss.item()
epoch_loss /= minibatch_num + 1
return epoch_loss
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset. Must have ratings.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
(self._num_users, self._num_items) = (interactions.num_users,
interactions.num_items)
self._net = gpu(
BilinearNet(self._num_users,
self._num_items,
self._embedding_dim,
sparse=self._sparse), self._use_cuda)
if self._optimizer is None:
self._optimizer = optim.Adam(self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate)
if self._loss == 'regression':
loss_fnc = regression_loss
elif self._loss == 'poisson':
loss_fnc = poisson_loss
else:
raise ValueError('Unknown loss: {}'.format(self._loss))
for epoch_num in range(self._n_iter):
users, items, ratings = shuffle(user_ids,
item_ids,
interactions.ratings,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
ratings_tensor = gpu(torch.from_numpy(ratings), self._use_cuda)
epoch_loss = 0.0
for (batch_user, batch_item,
batch_ratings) in minibatch(user_ids_tensor,
item_ids_tensor,
ratings_tensor,
batch_size=self._batch_size):
user_var = Variable(batch_user)
item_var = Variable(batch_item)
ratings_var = Variable(batch_ratings)
predictions = self._net(user_var, item_var)
if self._loss == 'poisson':
predictions = torch.exp(predictions)
self._optimizer.zero_grad()
loss = loss_fnc(ratings_var, predictions)
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
(self._num_users, self._num_items) = (interactions.num_users,
interactions.num_items)
self._net = gpu(
BilinearNet(self._num_users,
self._num_items,
self._embedding_dim,
sparse=self._sparse), self._use_cuda)
if self._optimizer is None:
self._optimizer = optim.Adam(self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate)
else:
self._optimizer = self._optimizer_func(self._net.parameters())
if self._loss == 'pointwise':
loss_fnc = pointwise_loss
elif self._loss == 'bpr':
loss_fnc = bpr_loss
elif self._loss == 'hinge':
loss_fnc = hinge_loss
else:
loss_fnc = adaptive_hinge_loss
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
epoch_loss = 0.0
for (minibatch_num, (batch_user, batch_item)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
batch_size=self._batch_size)):
user_var = Variable(batch_user)
item_var = Variable(batch_item)
positive_prediction = self._net(user_var, item_var)
if self._loss == 'adaptive_hinge':
negative_prediction = [
self._get_negative_prediction(user_var)
for _ in range(5)
]
else:
negative_prediction = self._get_negative_prediction(
user_var)
self._optimizer.zero_grad()
loss = loss_fnc(positive_prediction, negative_prediction)
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.SequenceInteractions`
The input sequence dataset.
"""
sequences = interactions.sequences.astype(np.int64)
self._num_items = interactions.num_items
if self._representation == 'pooling':
self._net = PoolNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
elif self._representation == 'cnn':
self._net = CNNNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
elif self._representation == 'lstm':
self._net = LSTMNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
else:
self._net = self._representation
self._net = gpu(self._net, self._use_cuda)
if self._optimizer is None:
self._optimizer = optim.Adam(self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate)
if self._loss == 'pointwise':
loss_fnc = pointwise_loss
elif self._loss == 'bpr':
loss_fnc = bpr_loss
elif self._loss == 'hinge':
loss_fnc = hinge_loss
else:
loss_fnc = adaptive_hinge_loss
for epoch_num in range(self._n_iter):
sequences = shuffle(sequences, random_state=self._random_state)
sequences_tensor = gpu(torch.from_numpy(sequences), self._use_cuda)
epoch_loss = 0.0
for minibatch_num, batch_sequence in enumerate(
minibatch(sequences_tensor, batch_size=self._batch_size)):
sequence_var = Variable(batch_sequence)
user_representation, _ = self._net.user_representation(
sequence_var)
positive_prediction = self._net(user_representation,
sequence_var)
if self._loss == 'adaptive_hinge':
negative_prediction = [
self._get_negative_prediction(sequence_var.size(),
user_representation)
for __ in range(5)
]
else:
negative_prediction = self._get_negative_prediction(
sequence_var.size(), user_representation)
self._optimizer.zero_grad()
loss = loss_fnc(positive_prediction,
negative_prediction,
mask=(sequence_var != PADDING_IDX))
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
epoch_loss = 0.0
for (minibatch_num, (batch_user, batch_item)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
batch_size=self._batch_size)):
user_var = Variable(batch_user)
item_var = Variable(batch_item)
positive_prediction = self._net(user_var, item_var)
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
user_var, n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(
user_var)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction,
negative_prediction)
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError(
'Degenerate epoch loss: {}'.format(epoch_loss))
def fit(self, interactions, verbose=False, return_loss=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
verbose: bool
Output additional information about current epoch and loss.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
epoch_loss = 0.0
epoch_cov_norm = 0.0
for (minibatch_num, (batch_user, batch_item)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
batch_size=self._batch_size)):
positive_prediction = self._net(batch_user, batch_item)
if self._loss in ('warp', 'adaptive_hinge'):
negative_prediction = self._get_multiple_negative_predictions(
batch_user, n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(
batch_user)
self._optimizer.zero_grad()
if self._margin is not None:
loss = self._loss_func(positive_prediction,
negative_prediction,
m=self._margin)
else:
loss = self._loss_func(positive_prediction,
negative_prediction)
epoch_loss += loss.item()
if self._cov_reg is not None:
cov_loss = self._covariance_loss()
loss += cov_loss * self._cov_reg
epoch_cov_norm += cov_loss.item()
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
epoch_cov_norm /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}, cov_norm {}'.format(
epoch_num, epoch_loss, epoch_cov_norm))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError(
'Degenerate epoch loss: {}'.format(epoch_loss))
if return_loss:
return epoch_loss, epoch_cov_norm
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset. Must have ratings.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
(self._num_users,
self._num_items) = (interactions.num_users,
interactions.num_items)
self._net = gpu(
BilinearNet(self._num_users,
self._num_items,
self._embedding_dim,
sparse=self._sparse),
self._use_cuda
)
if self._optimizer_func is None:
self._optimizer = optim.Adam(
self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate
)
else:
self._optimizer = self._optimizer_func(self._net.parameters())
if self._loss == 'regression':
loss_fnc = regression_loss
elif self._loss == 'poisson':
loss_fnc = poisson_loss
else:
raise ValueError('Unknown loss: {}'.format(self._loss))
for epoch_num in range(self._n_iter):
users, items, ratings = shuffle(user_ids,
item_ids,
interactions.ratings,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users),
self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items),
self._use_cuda)
ratings_tensor = gpu(torch.from_numpy(ratings),
self._use_cuda)
epoch_loss = 0.0
for (minibatch_num,
(batch_user,
batch_item,
batch_ratings)) in enumerate(minibatch(user_ids_tensor,
item_ids_tensor,
ratings_tensor,
batch_size=self._batch_size)):
user_var = Variable(batch_user)
item_var = Variable(batch_item)
ratings_var = Variable(batch_ratings)
predictions = self._net(user_var, item_var)
if self._loss == 'poisson':
predictions = torch.exp(predictions)
self._optimizer.zero_grad()
loss = loss_fnc(ratings_var, predictions)
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
def fit(self, interactions, validation_interactions=None, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
verbose: bool
Output additional information about current epoch and loss.
"""
train_loss = np.zeros(self._n_iter)
val_loss = np.zeros(self._n_iter)
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
weights = interactions.weights.astype(np.float32)
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
for epoch_num in range(self._n_iter):
users, items, weights = shuffle(user_ids,
item_ids,
weights,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
weights_tensor = gpu(torch.from_numpy(weights), self._use_cuda)
epoch_loss = 0.0
for (minibatch_num, (batch_user, batch_item,
batch_weight)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
weights_tensor,
batch_size=self._batch_size)):
positive_prediction = self._net(batch_user, batch_item)
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
batch_user, n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(
batch_user)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction,
negative_prediction,
weights=batch_weight)
epoch_loss += loss.item()
loss.backward()
self._optimizer.step()
train_loss[epoch_num] = epoch_loss / (minibatch_num + 1)
if validation_interactions is not None:
val_loss[epoch_num] = self._get_validation_loss(
validation_interactions)
if verbose and validation_interactions is not None:
print('Epoch {}: loss {} \t val-loss {}'.format(
epoch_num, train_loss[epoch_num], val_loss[epoch_num]))
else:
print('Epoch {}: loss {}'.format(epoch_num,
train_loss[epoch_num]))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError(
'Degenerate epoch loss: {}'.format(epoch_loss))
return train_loss, val_loss
def fit(self, interactions, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
verbose: bool
Output additional information about current epoch and loss.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
time_step = 0
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users), self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items), self._use_cuda)
epoch_loss = 0.0
interval_loss = 0.0
interval_batches = 0.0
epoch_batches = 0.0
for (minibatch_num, (batch_user, batch_item)) in enumerate(
minibatch(user_ids_tensor,
item_ids_tensor,
batch_size=self._batch_size)):
self._net.train(True)
positive_prediction = self._net(batch_user, batch_item)
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
batch_user, n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(
batch_user)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction,
negative_prediction)
loss_val = loss.item()
epoch_loss += loss_val
interval_loss += loss_val
loss.backward()
self._optimizer.step()
interval_batches += 1
if time_step % self._log_loss_interval == 0:
if self._notify_loss_completion:
self._notify_loss_completion(
epoch_num, time_step,
interval_loss / interval_batches, self._net, self)
if time_step % self._log_eval_interval == 0:
if self._notify_batch_eval_completion:
self._notify_batch_eval_completion(
epoch_num, time_step,
interval_loss / interval_batches, self._net, self)
if time_step % self._log_loss_interval == 0:
interval_loss = 0.0
interval_batches = 0.0
time_step += 1
epoch_batches += 1
epoch_loss /= epoch_batches
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
if self._notify_epoch_completion:
self._notify_epoch_completion(epoch_num, epoch_loss, self._net,
self)
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError(
'Degenerate epoch loss: {}'.format(epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
When called repeatedly, model fitting will resume from
the point at which training stopped in the previous fit
call.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
verbose: bool
Output additional information about current epoch and loss.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
ratings = interactions.ratings.astype(np.int64)
user_ids = user_ids[0:self.inputSample]
item_ids = item_ids[0:self.inputSample]
ratings = ratings[0:self.inputSample]
# pdb.Pdb.complete = rlcompleter.Completer(locals()).complete
# pdb.set_trace()
if not self._initialized:
self._initialize(interactions)
self._check_input(user_ids, item_ids)
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users),
self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items),
self._use_cuda)
rating_ids_tensor = gpu(torch.from_numpy(ratings),
self._use_cuda)
epoch_loss = 0.0
for (minibatch_num,
(batch_user,
batch_item, batch_rating)) in enumerate(minibatch(user_ids_tensor,
item_ids_tensor, rating_ids_tensor,
batch_size=self._batch_size)):
user_var = Variable(batch_user)
pos_item = Variable(batch_item)
rating = Variable(batch_rating)
neg_item = self._get_negative_items(user_var)
x, target = self._rankDataPrepSwapping(user_var, pos_item, rating, neg_item)
pred_prob = self._net(x)
self._optimizer.zero_grad()
loss = self.bceLoss(pred_prob, target)
# loss = self._loss_func(pred_prob, target)
'''
if random > 0.5:
pred = self._net(user_var, pos_item, neg_item)
else:
pred = self._net(user_var, neg_item, pos_item)
pred = self._net(user_var, item_var, neg_item)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction, negative_prediction)
'''
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
if np.isnan(epoch_loss) or epoch_loss == 0.0:
raise ValueError('Degenerate epoch loss: {}'
.format(epoch_loss))
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.SequenceInteractions`
The input sequence dataset.
"""
sequences = interactions.sequences.astype(np.int64)
self._num_items = interactions.num_items
if self._representation == 'pooling':
self._net = PoolNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
elif self._representation == 'cnn':
self._net = CNNNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
elif self._representation == 'lstm':
self._net = LSTMNet(self._num_items,
self._embedding_dim,
sparse=self._sparse)
else:
self._net = self._representation
self._net = gpu(self._net, self._use_cuda)
if self._optimizer is None:
self._optimizer = optim.Adam(
self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate
)
else:
self._optimizer = self._optimizer_func(self._net.parameters())
if self._loss == 'pointwise':
loss_fnc = pointwise_loss
elif self._loss == 'bpr':
loss_fnc = bpr_loss
elif self._loss == 'hinge':
loss_fnc = hinge_loss
else:
loss_fnc = adaptive_hinge_loss
for epoch_num in range(self._n_iter):
sequences = shuffle(sequences,
random_state=self._random_state)
sequences_tensor = gpu(torch.from_numpy(sequences),
self._use_cuda)
epoch_loss = 0.0
for minibatch_num, batch_sequence in enumerate(minibatch(sequences_tensor,
batch_size=self._batch_size)):
sequence_var = Variable(batch_sequence)
user_representation, _ = self._net.user_representation(
sequence_var
)
positive_prediction = self._net(user_representation,
sequence_var)
if self._loss == 'adaptive_hinge':
negative_prediction = [self._get_negative_prediction(sequence_var.size(),
user_representation)
for __ in range(5)]
else:
negative_prediction = self._get_negative_prediction(sequence_var.size(),
user_representation)
self._optimizer.zero_grad()
loss = loss_fnc(positive_prediction,
negative_prediction,
mask=(sequence_var != PADDING_IDX))
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
def run_epoch(sequences_tensor, self, epoch_num, time_step):
epoch_loss = 0.0
interval_loss = 0.0
interval_batches = 0.0
epoch_batches = 0.0
for minibatch_num, batch_sequence in enumerate(minibatch(sequences_tensor,
batch_size=self._batch_size)):
self._net.train()
sequence_var = batch_sequence
user_representation, _ = self._net.user_representation(
sequence_var
)
positive_prediction = self._net(user_representation,
sequence_var)
if self._loss == 'adaptive_hinge':
negative_prediction = self._get_multiple_negative_predictions(
sequence_var.size(),
user_representation,
n=self._num_negative_samples)
else:
negative_prediction = self._get_negative_prediction(sequence_var.size(),
user_representation)
self._optimizer.zero_grad()
loss = self._loss_func(positive_prediction,
negative_prediction,
mask=(sequence_var != PADDING_IDX))
loss_val = loss.item()
epoch_loss += loss_val
interval_loss += loss_val
loss.backward()
self._optimizer.step()
interval_batches += 1
if time_step % self._log_loss_interval == 0:
if self._notify_loss_completion:
self._notify_loss_completion(epoch_num,
time_step,
interval_loss / interval_batches,
self._net,
self)
if time_step % self._log_eval_interval == 0:
if self._notify_batch_eval_completion:
self._notify_batch_eval_completion(epoch_num,
time_step,
interval_loss / interval_batches,
self._net,
self)
if time_step % self._log_loss_interval == 0:
interval_loss = 0.0
interval_batches = 0.0
time_step += 1
epoch_batches += 1
epoch_loss /= epoch_batches
return epoch_loss, time_step
def fit(self, interactions, verbose=False):
"""
Fit the model.
Parameters
----------
interactions: :class:`spotlight.interactions.Interactions`
The input dataset.
"""
user_ids = interactions.user_ids.astype(np.int64)
item_ids = interactions.item_ids.astype(np.int64)
(self._num_users,
self._num_items) = (interactions.num_users,
interactions.num_items)
self._net = gpu(
BilinearNet(self._num_users,
self._num_items,
self._embedding_dim,
sparse=self._sparse),
self._use_cuda
)
if self._optimizer is None:
self._optimizer = optim.Adam(
self._net.parameters(),
weight_decay=self._l2,
lr=self._learning_rate
)
else:
self._optimizer = self._optimizer_func(self._net.parameters())
if self._loss == 'pointwise':
loss_fnc = pointwise_loss
elif self._loss == 'bpr':
loss_fnc = bpr_loss
elif self._loss == 'hinge':
loss_fnc = hinge_loss
else:
loss_fnc = adaptive_hinge_loss
for epoch_num in range(self._n_iter):
users, items = shuffle(user_ids,
item_ids,
random_state=self._random_state)
user_ids_tensor = gpu(torch.from_numpy(users),
self._use_cuda)
item_ids_tensor = gpu(torch.from_numpy(items),
self._use_cuda)
epoch_loss = 0.0
for (minibatch_num,
(batch_user,
batch_item)) in enumerate(minibatch(user_ids_tensor,
item_ids_tensor,
batch_size=self._batch_size)):
user_var = Variable(batch_user)
item_var = Variable(batch_item)
positive_prediction = self._net(user_var, item_var)
if self._loss == 'adaptive_hinge':
negative_prediction = [self._get_negative_prediction(user_var)
for _ in range(5)]
else:
negative_prediction = self._get_negative_prediction(user_var)
self._optimizer.zero_grad()
loss = loss_fnc(positive_prediction, negative_prediction)
epoch_loss += loss.data[0]
loss.backward()
self._optimizer.step()
epoch_loss /= minibatch_num + 1
if verbose:
print('Epoch {}: loss {}'.format(epoch_num, epoch_loss))
