def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
lr_scheduler_func: Optional[Callable] = None,
weight_decay: float = 0.0,
optimizer_config_list: List[Dict[str, Union[float, List[str],
str]]] = None,
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None,
**kwargs):
stage_list = None
if load_model_path is None:
if optimizer_config_list is None:
raise ValueError(
'Must provide ``optimizer_config_list`` when initializing a new multi-stage '
'model!')
else:
stage_list = list(
OrderedDict.fromkeys([
optimizer_config['stage']
for optimizer_config in optimizer_config_list
]))
super().__init__(stage_list=stage_list, **get_init_arguments())
if load_model_path is None:
# set stage if we have not already loaded it in and set it there
self.hparams.stage = self.hparams.stage_list[0]
self.set_stage(self.hparams.stage)
def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
embedding_dim: int = 30,
sparse: bool = False,
lr: float = 1e-3,
lr_scheduler_func: Optional[Callable] = partial(
ReduceLROnPlateau, patience=1, verbose=True),
weight_decay: float = 0.0,
optimizer: Union[str, Callable] = 'adam',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
y_range: Optional[Tuple[float, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None):
super().__init__(**get_init_arguments())
def __init__(
self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
item_metadata: Union[torch.tensor, pd.DataFrame, np.array] = None,
trained_model: MatrixFactorizationModel = None,
metadata_layers_dims: Optional[List[int]] = None,
combined_layers_dims: List[int] = [128, 64, 32],
freeze_embeddings: bool = True,
dropout_p: float = 0.0,
lr: float = 1e-3,
lr_scheduler_func: Optional[Callable] = partial(ReduceLROnPlateau,
patience=1,
verbose=True),
weight_decay: float = 0.0,
optimizer: Union[str, Callable] = 'adam',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
# y_range: Optional[Tuple[float, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None):
item_metadata_num_cols = None
if load_model_path is None:
if trained_model is None:
raise ValueError(
'Must provide ``trained_model`` for ``HybridPretrainedModel``.'
)
if item_metadata is None:
raise ValueError(
'Must provide item metadata for ``HybridPretrainedModel``.'
)
elif isinstance(item_metadata, pd.DataFrame):
item_metadata = torch.from_numpy(item_metadata.to_numpy())
elif isinstance(item_metadata, np.ndarray):
item_metadata = torch.from_numpy(item_metadata)
item_metadata = item_metadata.float()
item_metadata_num_cols = item_metadata.shape[1]
super().__init__(**get_init_arguments(),
item_metadata_num_cols=item_metadata_num_cols)
def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
user_embedding_dim: int = 60,
item_embedding_dim: int = 60,
user_dense_layers_dims: List[float] = [48, 32],
item_dense_layers_dims: List[float] = [48, 32],
embedding_dropout_p: float = 0.0,
dense_dropout_p: float = 0.0,
lr: float = 1e-3,
bias_lr: Optional[Union[float, str]] = 1e-2,
lr_scheduler_func: Optional[Callable] = partial(
ReduceLROnPlateau, patience=1, verbose=True),
weight_decay: float = 0.0,
optimizer: Union[str, Callable] = 'adam',
bias_optimizer: Optional[Union[str, Callable]] = 'sgd',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
y_range: Optional[Tuple[float, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None):
super().__init__(**get_init_arguments())
def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
lr: float = 1e-3,
lr_scheduler_func: Optional[Callable] = None,
weight_decay: float = 0.0,
optimizer: Union[str, Callable] = 'adam',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None,
**kwargs):
if isinstance(train, Interactions) or isinstance(
train, ExplicitInteractions):
train = InteractionsDataLoader(interactions=train, shuffle=True)
if isinstance(val, Interactions) or isinstance(val,
ExplicitInteractions):
val = InteractionsDataLoader(interactions=val, shuffle=False)
super().__init__()
# save datasets as class-level attributes and NOT ``hparams`` so model checkpointing /
# saving can complete faster
self.train_loader = train
self.val_loader = val
# potential issue with PyTorch Lightning is that a function cannot be saved as a
# hyperparameter, so we will sidestep this by setting it as a class-level attribute
# https://github.com/PyTorchLightning/pytorch-lightning/issues/2444
self.lr_scheduler_func = lr_scheduler_func
self.loss = loss
self.optimizer = optimizer
self.bias_optimizer = kwargs.get('bias_optimizer')
if load_model_path is not None:
# we are loading in a previously-saved model, not creating a new one
self._load_model_init_helper(load_model_path=load_model_path,
map_location=map_location,
**kwargs)
else:
if self.train_loader is None:
raise TypeError(
'``train`` must be provided to all newly-instantiated models!'
)
elif self.val_loader is not None:
assert self.train_loader.num_users == self.val_loader.num_users, (
'Both training and val ``num_users`` must equal: '
f'{self.train_loader.num_users} != {self.val_loader.num_users}.'
)
assert self.train_loader.num_items == self.val_loader.num_items, (
'Both training and val ``num_items`` must equal: '
f'{self.train_loader.num_items} != {self.val_loader.num_items}.'
)
if (hasattr(self.train_loader, 'num_negative_samples')
or hasattr(self.val_loader, 'num_negative_samples')):
num_negative_samples_error = (
'Training and val ``num_negative_samples`` property must both equal ``1``'
f' or both be greater than ``1``, not: {self.train_loader.num_items} and'
f' {self.val_loader.num_items}, respectively.')
if self.train_loader.num_negative_samples == 1:
assert self.val_loader.num_negative_samples == 1, num_negative_samples_error
elif self.train_loader.num_negative_samples > 1:
assert self.val_loader.num_negative_samples > 1, num_negative_samples_error
else:
raise ValueError(
'``self.train_loader.num_negative_samples`` must be greater than ``0``,'
f' not {self.train_loader.num_negative_samples}.')
# saves all passed-in parameters
init_args = get_init_arguments(
exclude=['train', 'val', 'item_metadata', 'trained_model'],
verbose=False,
)
self.save_hyperparameters(init_args, *kwargs.keys())
self.hparams.num_users = self.train_loader.num_users
self.hparams.num_items = self.train_loader.num_items
self.hparams.num_epochs_completed = 0
self._configure_loss()
# check weight decay and sparsity
if hasattr(self.hparams, 'sparse'):
if self.hparams.sparse and self.hparams.weight_decay != 0:
warnings.warn(
textwrap.dedent(f'''
``weight_decay`` value must be 0 when ``sparse`` is flagged, not
{self.hparams.weight_decay}. Setting to 0.
''').replace('\n', ' ').strip())
self.hparams.weight_decay = 0.0
# set up the actual model
self._setup_model(**kwargs)
def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
item_metadata: Union[torch.tensor, pd.DataFrame, np.array] = None,
embedding_dim: int = 30,
metadata_layers_dims: Optional[List[int]] = None,
combined_layers_dims: List[int] = [128, 64, 32],
dropout_p: float = 0.0,
lr: float = 1e-3,
bias_lr: Optional[Union[float, str]] = 1e-2,
metadata_only_stage_lr: float = 1e-3,
all_stage_lr: float = 1e-4,
lr_scheduler_func: Optional[Callable] = partial(
ReduceLROnPlateau,
patience=1,
verbose=False,
),
weight_decay: float = 0.0,
optimizer: Union[str, Callable] = 'adam',
bias_optimizer: Optional[Union[str, Callable]] = 'sgd',
metadata_only_stage_optimizer: Union[str, Callable] = 'adam',
all_stage_optimizer: Union[str, Callable] = 'adam',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None):
item_metadata_num_cols = None
optimizer_config_list = None
if load_model_path is None:
if item_metadata is None:
raise ValueError('Must provide item metadata for ``HybridPretrainedModel``.')
elif isinstance(item_metadata, pd.DataFrame):
item_metadata = torch.from_numpy(item_metadata.to_numpy())
elif isinstance(item_metadata, np.ndarray):
item_metadata = torch.from_numpy(item_metadata)
item_metadata = item_metadata.float()
item_metadata_num_cols = item_metadata.shape[1]
if bias_optimizer is not None:
initial_optimizer_block = [
{
'lr': lr,
'optimizer': optimizer,
# optimize embeddings...
'parameter_prefix_list': ['user_embedding', 'item_embedding'],
'stage': 'matrix_factorization',
},
{
'lr': lr if bias_lr == 'infer' else bias_lr,
'optimizer': optimizer if bias_optimizer == 'infer' else bias_optimizer,
# ... and optimize bias terms too
'parameter_prefix_list': ['user_bias', 'item_bias'],
'stage': 'matrix_factorization',
},
]
else:
initial_optimizer_block = [
{
'lr': lr,
'optimizer': optimizer,
# optimize embeddings and bias terms all together
'parameter_prefix_list': [
'user_embedding',
'item_embedding',
'user_bias',
'item_bias'],
'stage': 'matrix_factorization',
},
]
optimizer_config_list = initial_optimizer_block + [
{
'lr': metadata_only_stage_lr,
'optimizer': metadata_only_stage_optimizer,
# optimize metadata layers only
'parameter_prefix_list': ['metadata', 'combined', 'user_bias', 'item_bias'],
'stage': 'metadata_only',
},
{
'lr': all_stage_lr,
'optimizer': all_stage_optimizer,
# optimize everything
'parameter_prefix_list': ['user', 'item', 'metadata', 'combined'],
'stage': 'all',
},
]
super().__init__(optimizer_config_list=optimizer_config_list,
item_metadata_num_cols=item_metadata_num_cols,
**get_init_arguments())
def __init__(self, var_1, var_2=2468, **kwargs):
super().__init__()
self.actual = get_init_arguments(exclude=['var_4'], verbose=True)
def __init__(self, var_1, var_2=2468, **kwargs):
super().__init__()
self.actual = get_init_arguments(exclude=['var_2', 'var_3'])
def __init__(self, var_1, var_2=12345, **kwargs):
super().__init__()
self.actual = get_init_arguments()
def __init__(self, **kwargs):
super().__init__()
self.actual = get_init_arguments()
def __init__(self, var_1, var_2=54321):
super().__init__()
self.actual = get_init_arguments()
def __init__(self,
train: INTERACTIONS_LIKE_INPUT = None,
val: INTERACTIONS_LIKE_INPUT = None,
item_buckets: Iterable[int] = None,
embedding_dim: int = 30,
dropout_p: float = 0.0,
sparse: bool = False,
item_buckets_stage_lr: float = 1e-3,
no_buckets_stage_lr: float = 1e-3,
lr_scheduler_func: Optional[Callable] = partial(
ReduceLROnPlateau,
patience=1,
verbose=False,
),
weight_decay: float = 0.0,
item_buckets_stage_optimizer: Union[str, Callable] = 'adam',
no_buckets_stage_optimizer: Union[str, Callable] = 'adam',
loss: Union[str, Callable] = 'hinge',
metadata_for_loss: Optional[Dict[str, torch.tensor]] = None,
metadata_for_loss_weights: Optional[Dict[str, float]] = None,
load_model_path: Optional[str] = None,
map_location: Optional[str] = None):
optimizer_config_list = None
num_item_buckets = None
if load_model_path is None:
# TODO: separate out optimizer and bias optimizer somehow
optimizer_config_list = [
{
'lr': item_buckets_stage_lr,
'optimizer': item_buckets_stage_optimizer,
'parameter_prefix_list': [
'user_embed',
'user_bias',
'item_bucket_embed',
'item_bucket_bias',
],
'stage': 'item_buckets',
},
{
'lr': no_buckets_stage_lr,
'optimizer': no_buckets_stage_optimizer,
'parameter_prefix_list': [
'user_embed',
'user_bias',
'item_embed',
'item_bias',
],
'stage': 'no_buckets',
},
]
if not isinstance(item_buckets, torch.Tensor):
item_buckets = torch.tensor(item_buckets)
# data quality checks for ``item_buckets``
assert item_buckets.dim() == 1, (
f'``item_buckets`` must be 1-dimensional, not {item_buckets.dim()}-dimensional!'
)
if len(item_buckets) != train.num_items:
raise ValueError(
'Length of ``item_buckets`` must be equal to the number of items in the '
f'dataset: {len(item_buckets)} != {train.num_items}.'
)
if min(item_buckets) != 0:
raise ValueError(f'``item_buckets`` IDs must start at 0, not {min(item_buckets)}!')
num_item_buckets = item_buckets.max().item() + 1
super().__init__(optimizer_config_list=optimizer_config_list,
num_item_buckets=num_item_buckets,
**get_init_arguments())
