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))