eps = 1e-6
loss_type = 'CrossEntropy'
lr = 0.01
dropout_hidden = 0
dropout_input = 0
batch_size = 50
momentum = 0
gru = GRU(input_size,
if_embedding,
embedding_size,
hidden_size,
output_size,
num_layers=num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda,
cuda_id=cuda_id)
print(loss_type + ':')
for i in range(1, 21):
model_name = 'GRU4REC_CrossEntropy_Adagrad_0.01_epoch%d' % i
print(model_name)
model_file = r'./models/' + model_name
gru.load_state_dict(torch.load(model_file))
model = GRU4REC(input_size,
if_embedding,
def __init__(self,
input_size,
hidden_size,
output_size,
num_layers=1,
optimizer_type='Adagrad',
lr=.01,
weight_decay=0,
momentum=0,
eps=1e-6,
loss_type='TOP1',
clip_grad=-1,
dropout_input=.0,
dropout_hidden=.5,
batch_size=50,
use_cuda=True,
time_sort=False,
pretrained=None,
n_sample=2048,
sample_alpha=0.75,
sample_store=10000000,
bpreg=1.0):
""" The GRU4REC model
Args:
input_size (int): dimension of the gru input variables
hidden_size (int): dimension of the gru hidden units
output_size (int): dimension of the gru output variables
num_layers (int): the number of layers in the GRU
optimizer_type (str): optimizer type for GRU weights
lr (float): learning rate for the optimizer
weight_decay (float): weight decay for the optimizer
momentum (float): momentum for the optimizer
eps (float): eps for the optimizer
loss_type (str): type of the loss function to use
clip_grad (float): clip the gradient norm at clip_grad. No clipping if clip_grad = -1
dropout_input (float): dropout probability for the input layer
dropout_hidden (float): dropout probability for the hidden layer
batch_size (int): mini-batch size
use_cuda (bool): whether you want to use cuda or not
time_sort (bool): whether to ensure the the order of sessions is chronological (default: False)
pretrained (modules.layer.GRU): pretrained GRU layer, if it exists (default: None)
"""
# Initialize the GRU Layer
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.batch_size = batch_size
self.use_cuda = use_cuda
self.device = torch.device('cuda' if use_cuda else 'cpu')
###修改###
self.n_sample = n_sample
self.sample_alpha = sample_alpha
self.sample_store = sample_store
self.bpreg = bpreg
###修改###
if pretrained is None:
self.gru = GRU(input_size,
hidden_size,
output_size,
num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda)
else:
self.gru = pretrained
# Initialize the optimizer
self.optimizer_type = optimizer_type
self.weight_decay = weight_decay
self.momentum = momentum
self.lr = lr
self.eps = eps
self.optimizer = Optimizer(self.gru.parameters(),
optimizer_type=optimizer_type,
lr=lr,
weight_decay=weight_decay,
momentum=momentum,
eps=eps)
# Initialize the loss function
self.loss_type = loss_type
self.loss_fn = LossFunction(loss_type, use_cuda)
# gradient clipping(optional)
self.clip_grad = clip_grad
# etc
self.time_sort = time_sort
model_name = 'GRU4REC_TOP1_Adagrad_0.01_epoch5'
model_file = PATH_MODEL / model_name
loss_type = 'TOP1'
lr = 0.01
dropout_hidden = .5
dropout_input = 0
batch_size = 50
momentum = 0
gru = GRU(input_size,
hidden_size,
output_size,
num_layers=num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda)
gru.load_state_dict(torch.load(model_file))
model = GRU4REC(input_size,
hidden_size,
output_size,
num_layers=num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda,
loss_type=loss_type,
def main():
parser = argparse.ArgumentParser()
# Model filename
parser.add_argument('model_file', type=str)
# Size of the recommendation list
parser.add_argument('--k', default=20, type=int)
# parse the nn arguments
parser.add_argument('--hidden_size', default=100, type=int)
parser.add_argument('--num_layers', default=1, type=int)
parser.add_argument('--batch_size', default=50, type=int)
parser.add_argument('--dropout_input', default=0, type=float)
parser.add_argument('--dropout_hidden', default=.5, type=float)
# parse the optimizer arguments
parser.add_argument('--optimizer_type', default='Adagrad', type=str)
parser.add_argument('--lr', default=.01, type=float)
parser.add_argument('--weight_decay', default=0, type=float)
parser.add_argument('--momentum', default=0, type=float)
parser.add_argument('--eps', default=1e-6, type=float)
# parse the loss type
parser.add_argument('--loss_type', default='TOP1', type=str)
# etc
parser.add_argument('--n_epochs', default=2, type=int)
parser.add_argument('--time_sort', default=False, type=bool)
parser.add_argument('--n_samples', default=-1, type=int)
# Get the arguments
args = parser.parse_args()
# PATH_DATA = Path('./data/rsc15/processed')
PATH_DATA = Path('/content/data') # on colab
PATH_MODEL = Path('./models')
train = 'rsc15_train_tr.txt'
test = 'rsc15_test.txt'
PATH_TRAIN = PATH_DATA / train
PATH_TEST = PATH_DATA / test
df_train = pd.read_csv(PATH_TRAIN,
sep='\t',
names=['SessionId', 'ItemId', 'TimeStamp'])
df_test = pd.read_csv(PATH_TEST,
sep='\t',
names=['SessionId', 'ItemId', 'TimeStamp'])
# sampling, if needed
n_samples = args.n_samples
if n_samples != -1:
df_train = df_train[:n_samples]
df_test = df_test[:n_samples]
session_key = 'SessionId'
item_key = 'ItemId'
time_key = 'TimeStamp'
use_cuda = True
input_size = df_train[item_key].nunique()
hidden_size = args.hidden_size
num_layers = args.num_layers
output_size = input_size
batch_size = args.batch_size
dropout_input = args.dropout_input
dropout_hidden = args.dropout_hidden
loss_type = args.loss_type
optimizer_type = args.optimizer_type
lr = args.lr
weight_decay = args.weight_decay
momentum = args.momentum
eps = args.eps
n_epochs = args.n_epochs
time_sort = args.time_sort
MODEL_FILE = PATH_MODEL / args.model_file
gru = GRU(input_size,
hidden_size,
output_size,
num_layers=num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda)
gru.load_state_dict(torch.load(MODEL_FILE))
model = GRU4REC(input_size,
hidden_size,
output_size,
num_layers=num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda,
loss_type=loss_type,
optimizer_type=optimizer_type,
lr=lr,
momentum=momentum,
time_sort=time_sort,
pretrained=gru)
model.init_data(df_train,
df_test,
session_key=session_key,
time_key=time_key,
item_key=item_key)
k = args.k
recall, mrr = model.test(k=k, batch_size=batch_size)
result = f'Recall@{k}:{recall:.7f},MRR@{k}:{mrr:.7f}'
print(result)
def __init__(self,
input_size,
if_embedding,
embedding_size,
hidden_size,
output_size,
num_layers=1,
optimizer_type='Adagrad',
lr=.01,
weight_decay=0,
momentum=0,
eps=1e-6,
loss_type='TOP1',
clip_grad=-1,
dropout_input=.0,
dropout_hidden=.5,
batch_size=50,
use_cuda=True,
cuda_id=1,
compress=False,
time_sort=False,
pretrained=None):
""" The GRU4REC model
Args:
input_size (int): dimension of the gru input variables
hidden_size (int): dimension of the gru hidden units
output_size (int): dimension of the gru output variables
num_layers (int): the number of layers in the GRU
optimizer_type (str): optimizer type for GRU weights
lr (float): learning rate for the optimizer
weight_decay (float): weight decay for the optimizer
momentum (float): momentum for the optimizer
eps (float): eps for the optimizer
loss_type (str): type of the loss function to use
clip_grad (float): clip the gradient norm at clip_grad. No clipping if clip_grad = -1
dropout_input (float): dropout probability for the input layer
dropout_hidden (float): dropout probability for the hidden layer
batch_size (int): mini-batch size
use_cuda (bool): whether you want to use cuda or not
time_sort (bool): whether to ensure the the order of sessions is chronological (default: False)
pretrained (modules.layer.GRU): pretrained GRU layer, if it exists (default: None)
"""
# Initialize the GRU Layer
self.input_size = input_size
self.if_embedding = if_embedding
self.embedding_size = embedding_size
self.hidden_size = hidden_size
self.output_size = output_size
self.batch_size = batch_size
self.use_cuda = use_cuda
self.cuda_id = cuda_id
self.device = torch.device(
'cuda:%d' % cuda_id if use_cuda else 'cpu'
) # must specify cuda_id or it will be torch.cuda.current_device()
print(self.device)
if pretrained is None:
self.gru = GRU(input_size,
if_embedding,
embedding_size,
hidden_size,
output_size,
num_layers,
dropout_input=dropout_input,
dropout_hidden=dropout_hidden,
batch_size=batch_size,
use_cuda=use_cuda,
cuda_id=cuda_id)
else:
self.gru = pretrained
# Initialize the optimizer
self.optimizer_type = optimizer_type
self.weight_decay = weight_decay
self.momentum = momentum
self.lr = lr
self.eps = eps
self.compress = compress
self.compression_scheduler = None
if self.compress:
# Create a CompressionScheduler and configure it from a YAML schedule file
source = self.compress
self.compression_scheduler = distiller.config.file_config(
self.gru, None, self.compress)
self.optimizer = Optimizer(self.gru.parameters(),
optimizer_type=optimizer_type,
lr=lr,
weight_decay=weight_decay,
momentum=momentum,
eps=eps)
# Initialize the loss function
self.loss_type = loss_type
self.loss_fn = LossFunction(loss_type, use_cuda, cuda_id)
# gradient clipping(optional)
self.clip_grad = clip_grad
# etc
self.time_sort = time_sort