def __init__(self, data, config, params, *args, **kwargs):
"""
Create a CML instance.
(see https://vision.cornell.edu/se3/wp-content/uploads/2017/03/WWW-fp0554-hsiehA.pdf for details about the algorithm design choices).
Args:
data: data loader object
params: model parameters {embed_k: embedding size,
[l_w, l_b]: regularization,
lr: learning rate}
"""
self._random = np.random
self._params_list = [
("_user_factors", "factors", "factors", 100, None, None),
("_learning_rate", "lr", "lr", 0.001, None, None),
("_l_w", "l_w", "l_w", 0.001, None, None),
("_l_b", "l_b", "l_b", 0.001, None, None),
("_margin", "margin", "margin", 0.5, None, None),
]
self.autoset_params()
self._item_factors = self._user_factors
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
self._model = CML_model(self._user_factors, self._item_factors,
self._learning_rate, self._l_w, self._l_b,
self._margin, self._num_users, self._num_items)
def __init__(self, data, config, params, *args, **kwargs):
self._random = np.random
self._params_list = [
("_lr", "lr", "lr", 0.001, None, None),
("_lj_reg", "lj_reg", "ljreg", 0.001, None, None),
("_li_reg", "li_reg", "lireg", 0.1, None, None),
]
self.autoset_params()
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sp_i_train = self._data.sp_i_train
self._i_items_set = list(range(self._num_items))
self._sampler = cs.Sampler(self._data.i_train_dict)
self._model = BPRSlimModel(self._data,
self._num_users,
self._num_items,
self._lr,
self._lj_reg,
self._li_reg,
self._sampler,
random_seed=42)
def __init__(self, data, config, params, *args, **kwargs):
"""
Create a BPR-MF instance.
(see https://arxiv.org/pdf/1205.2618 for details about the algorithm design choices).
Args:
data: data loader object
params: model parameters {embed_k: embedding size,
[l_w, l_b]: regularization,
lr: learning rate}
"""
self._random = np.random
self._params_list = [
("_factors", "factors", "factors", 10, None, None),
("_learning_rate", "lr", "lr", 0.001, None, None),
("_l_w", "l_w", "l_w", 0.1, None, None),
("_l_b", "l_b", "l_b", 0.001, None, None),
]
self.autoset_params()
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
self._model = BPRMF_batch_model(self._factors, self._learning_rate,
self._l_w, self._l_b, self._num_users,
self._num_items)
def __init__(self, data, config, params, *args, **kwargs):
self._random = np.random
self._sampler = cs.Sampler(self._data.i_train_dict)
self._params_list = [
("_learning_rate", "lr", "lr", 0.001, None, None),
("_l_w", "l_w", "l_w", 0.001, None, None),
("_mf_factors", "mf_factors", "mffactors", 10, None, None),
("_mlp_hidden_size", "mlp_hidden_size", "mlpunits", "(64,32)",
lambda x: list(make_tuple(str(x))),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_dropout", "dropout", "drop", 0.45, None, None)
]
self.autoset_params()
item_indices = [
self._data.item_mapping[self._data.private_items[item]]
for item in range(self._num_items)
]
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sp_i_train = self._data.sp_i_train
self._i_items_set = list(range(self._num_items))
self._model = VNPRModel(self._num_users, self._num_items,
self._mf_factors, self._l_w,
self._mlp_hidden_size, self._dropout,
self._learning_rate,
self._data.visual_features[item_indices])
def __init__(self, data, config, params, *args, **kwargs):
super().__init__(data, config, params, *args, **kwargs)
self._num_items = self._data.num_items
self._num_users = self._data.num_users
self._random = np.random
self._params_list = [
("_factors", "factors", "factors", 100, None, None),
("_factors_d", "factors_d", "factors_d", 20, None, None),
("_learning_rate", "lr", "lr", 0.0005, None, None),
("_l_w", "l_w", "l_w", 0.000025, None, None),
("_l_b", "l_b", "l_b", 0, None, None),
("_l_e", "l_e", "l_e", 0.002, None, None)
]
self.autoset_params()
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
item_indices = [
self._data.item_mapping[self._data.private_items[item]]
for item in range(self._num_items)
]
self._model = VBPR_model(self._factors, self._factors_d,
self._learning_rate, self._l_w, self._l_b,
self._l_e,
self._data.visual_features[item_indices],
self._num_users, self._num_items)
def __init__(self, data, config, params, *args, **kwargs):
self._random = np.random
self._params_list = [
("_factors", "factors", "f", 10, int, None),
("_learning_rate", "lr", "lr", 0.05, None, None),
("_bias_regularization", "bias_regularization", "bias_reg", 0, None, None),
("_user_regularization", "user_regularization", "u_reg", 0.0025,
None, None),
("_positive_item_regularization", "positive_item_regularization", "pos_i_reg", 0.0025,
None, None),
("_negative_item_regularization", "negative_item_regularization", "neg_i_reg", 0.00025,
None, None),
("_update_negative_item_factors", "update_negative_item_factors", "up_neg_i_f", True,
None, None),
("_update_users", "update_users", "up_u", True, None, None),
("_update_items", "update_items", "up_i", True, None, None),
("_update_bias", "update_bias", "up_b", True, None, None),
]
self.autoset_params()
self._batch_size = 1
self._ratings = self._data.train_dict
self._model = MFModel(self._factors,
self._data,
self._learning_rate,
self._user_regularization,
self._bias_regularization,
self._positive_item_regularization,
self._negative_item_regularization)
self._sampler = cs.Sampler(self._data.i_train_dict)
def __init__(self, data, config, params, *args, **kwargs):
"""
"""
self._random = np.random
self._random_p = random
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
if self._batch_size < 1:
self._batch_size = self._num_users
######################################
self._params_list = [
("_learning_rate", "lr", "lr", 0.0005, None, None),
("_factors", "latent_dim", "factors", 64, None, None),
("_n_layers", "n_layers", "n_layers", 1, None, None),
("_l_w", "l_w", "l_w", 0.1, None, None),
("_n_fold", "n_fold", "n_fold", 1, None, None),
]
self.autoset_params()
self._adjacency, self._laplacian = self._create_adj_mat()
self._model = LightGCNModel(num_users=self._num_users,
num_items=self._num_items,
learning_rate=self._learning_rate,
embed_k=self._factors,
n_layers=self._n_layers,
l_w=self._l_w,
n_fold=self._n_fold,
adjacency=self._adjacency,
laplacian=self._laplacian)
def __init__(self, data, config, params, *args, **kwargs):
self._random = np.random
self._sampler = cs.Sampler(self._data.i_train_dict)
self._params_list = [
("_lr", "lr", "lr", 0.001, None, None),
("_embedding_size", "embedding_size", "embedding_size", 100, None,
None),
("_cnn_channels", "cnn_channels", "cnn_channels", "(1, 32, 32)",
lambda x: list(make_tuple(str(x))),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_cnn_kernels", "cnn_kernels", "cnn_kernels", "(2,2)",
lambda x: list(make_tuple(str(x))),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_cnn_strides", "cnn_strides", "cnn_strides", "(2,2)",
lambda x: list(make_tuple(str(x))),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_dropout_prob", "dropout_prob", "dropout_prob", 0, None, None),
("_l_w", "l_w", "l_w", 0.005, None, None),
("_l_b", "l_b", "l_b", 0.0005, None, None),
]
self.autoset_params()
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sp_i_train = self._data.sp_i_train
self._i_items_set = list(range(self._num_items))
self._model = ConvNeuralMatrixFactorizationModel(
self._num_users, self._num_items, self._embedding_size, self._lr,
self._cnn_channels, self._cnn_kernels, self._cnn_strides,
self._dropout_prob, self._l_w, self._l_b)
def __init__(self, data, config, params, *args, **kwargs):
"""
Create a BPR-MF instance.
(see https://arxiv.org/pdf/1205.2618 for details about the algorithm design choices).
Args:
data: data loader object
params: model parameters {embed_k: embedding size,
[l_w, l_b]: regularization,
lr: learning rate}
"""
######################################
self._params_list = [
("_learning_rate", "lr", "lr", 0.0001, None, None),
("_l_w", "l_w", "l_w", 0.005, None, None),
("_l_b", "l_b", "l_b", 0, None, None),
("_seed", "seed", "seed", 42, None, None)
]
self.autoset_params()
np.random.seed(self._seed)
self._random = np.random
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
feature_map = self._data.side_information_data.kahfm_feature_map
self._tfidf_obj = TFIDF(feature_map)
self._tfidf = self._tfidf_obj.tfidf()
self._user_profiles = self._tfidf_obj.get_profiles(self._ratings)
self._user_factors = \
np.zeros(shape=(len(self._data.users), len(self._data.features)))
self._item_factors = \
np.zeros(shape=(len(self._data.items), len(self._data.features)))
for i, f_dict in self._tfidf.items():
if i in self._data.items:
for f, v in f_dict.items():
self._item_factors[self._data.public_items[i]][self._data.public_features[f]] = v
for u, f_dict in self._user_profiles.items():
for f, v in f_dict.items():
self._user_factors[self._data.public_users[u]][self._data.public_features[f]] = v
if self._batch_size < 1:
self._batch_size = self._num_users
self._factors = self._data.features
self._transactions_per_epoch = self._data.transactions
self._model = KaHFMEmbeddingsModel(self._user_factors,
self._item_factors,
self._params.lr,
self._params.l_w,
self._params.l_b)
def __init__(self, data, config, params, *args, **kwargs):
"""
Create a AMR instance.
(see https://arxiv.org/pdf/1809.07062.pdf for details about the algorithm design choices).
Args:
data: data loader object
params: model parameters {embed_k: embedding size,
[l_w, l_b]: regularization,
[eps, l_adv]: adversarial budget perturbation and adversarial regularization parameter,
lr: learning rate}
"""
super().__init__(data, config, params, *args, **kwargs)
self._num_items = self._data.num_items
self._num_users = self._data.num_users
self._random = np.random
self._params_list = [
("_factors", "factors", "factors", 200, None, None),
("_factors_d", "factors_d", "factors_d", 20, None, None),
("_learning_rate", "lr", "lr", 0.001, None, None),
("_l_w", "l_w", "l_w", 0.1, None, None),
("_l_b", "l_b", "l_b", 0.001, None, None),
("_l_e", "l_e", "l_e", 0.1, None, None),
("_eps", "eps", "eps", 0.1, None, None),
("_l_adv", "l_adv", "l_adv", 0.001, None, None),
("_adversarial_epochs", "adversarial_epochs", "adv_epochs",
self._epochs // 2, None, None)
]
self.autoset_params()
if self._adversarial_epochs > self._epochs:
raise Exception(
f"The total epoch ({self._epochs}) "
f"is smaller than the adversarial epochs ({self._adversarial_epochs})."
)
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
item_indices = [
self._data.item_mapping[self._data.private_items[item]]
for item in range(self._num_items)
]
self._model = AMR_model(self._factors, self._factors_d,
self._learning_rate, self._l_w, self._l_b,
self._l_e, self._eps, self._l_adv,
self._data.visual_features[item_indices],
self._num_users, self._num_items)
def __init__(self, data, config, params, *args, **kwargs):
"""
"""
self._random = np.random
self._random_p = random
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
if self._batch_size < 1:
self._batch_size = self._num_users
######################################
self._params_list = [
("_learning_rate", "lr", "lr", 0.1, None, None),
("_factors", "latent_dim", "factors", 64, None, None),
("_l_w", "l_w", "l_w", 0.01, None, None),
("_weight_size", "weight_size", "weight_size", "(64,32)", lambda x: list(make_tuple(x)),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_node_dropout", "node_dropout", "node_dropout", "(64,32)", lambda x: list(make_tuple(x)),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_message_dropout", "message_dropout", "message_dropout", "(64,32)", lambda x: list(make_tuple(x)),
lambda x: self._batch_remove(str(x), " []").replace(",", "-")),
("_n_fold", "n_fold", "n_fold", 1, None, None),
]
self.autoset_params()
self._n_layers = len(self._weight_size)
self._adjacency, self._laplacian = self._create_adj_mat()
self._model = NGCFModel(
num_users=self._num_users,
num_items=self._num_items,
learning_rate=self._learning_rate,
embed_k=self._factors,
l_w=self._l_w,
weight_size=self._weight_size,
n_layers=self._n_layers,
node_dropout=self._node_dropout,
message_dropout=self._message_dropout,
n_fold=self._n_fold,
adjacency=self._adjacency,
laplacian=self._laplacian
)
def __init__(self, data, config, params, *args, **kwargs):
"""
Create a APR-MF (AMF) instance.
(see https://arxiv.org/abs/1808.03908 for details about the algorithm design choices).
Args:
data: data loader object
params: model parameters {embed_k: embedding size,
[l_w, l_b]: regularization,
[eps, l_adv]: adversarial budget perturbation and adversarial regularization parameter,
lr: learning rate}
"""
self._random = np.random
self._params_list = [
("_factors", "factors", "factors", 200, int, None),
("_learning_rate", "lr", "lr", 0.001, None, None),
("_l_w", "l_w", "l_w", 0.1, None, None),
("_l_b", "l_b", "l_b", 0.001, None, None),
("_eps", "eps", "eps", 0.1, None, None),
("_l_adv", "l_adv", "l_adv", 0.001, None, None),
("_adversarial_epochs", "adversarial_epochs", "adv_epochs", self._epochs//2, int, None)
]
self.autoset_params()
if self._adversarial_epochs > self._epochs:
raise Exception(f"The total epoch ({self._epochs}) "
f"is smaller than the adversarial epochs ({self._adversarial_epochs}).")
if self._batch_size < 1:
self._batch_size = self._data.transactions
self._ratings = self._data.train_dict
self._sampler = cs.Sampler(self._data.i_train_dict)
self._model = AMF_model(self._factors,
self._learning_rate,
self._l_w,
self._l_b,
self._eps,
self._l_adv,
self._num_users,
self._num_items)
