def single_test(sample_size,fill_method):
input_size = 2
dl = dataset_loader(dataset_path)
dl.load(fixed_sig_size=sample_size, fill_method=fill_method) #mock load
la_to_ho = h_u_l
# la_to_ho = dl.get_labels_to_hot_dict()
num_classes = len(la_to_ho)
rnn = RNN.RNN(input_size,nW_hidden,sample_size,num_classes)
# Get batch and its labels
cctime = time.time()
train(rnn,dl)
print test(rnn,dl,la_to_ho)," ,",time.time()-cctime," s."
rnn.sess.close()
ops.reset_default_graph()
def run(metric, method, epochs, evaluation_threads, dataset, data_path,
start_fold, num_folds, verbose):
all_best_mrr_ten, all_best_ndcg_ten, all_best_mrr,all_best_ndcg,all_best_loss = [], [], [],[], []
for fold in range(start_fold, num_folds):
# Loading data
print("Fold " + str(fold))
t1 = time()
path = data_path + "fold" + str(fold) + "/"
dataset_name = dataset_loader(path, dataset, method)
training_data_matrix, test_ratings, test_positives, train_items = \
dataset_name.train_matrix, dataset_name.test_ratings, dataset_name.test_positives, dataset_name.train_items
num_users, num_items = training_data_matrix.shape
print(
"Data load done in [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d"
% (time() - t1, num_users, num_items, training_data_matrix.nnz,
len(test_ratings)))
itempop = training_data_matrix.sum(axis=0)
all_mrr_ten, all_ndcg_ten, all_mrr, all_ndcg = [], [], [], []
best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg, best_loss = 0.0, 0.0, 0.0, 0.0, 123456789
for epoch in xrange(epochs):
# Evaluation
if epoch % verbose == 0:
mrr_tens, ndcg_tens, mrrs, ndcgs, losses = evaluate_model(
train_items, method, metric, dataset, itempop,
test_ratings, test_positives, None, 10, evaluation_threads,
None)
mrr_ten, ndcg_ten,mrr,ndcg,loss = np.array(mrr_tens).mean(), np.array(ndcg_tens).mean(), \
np.array(mrrs).mean(), np.array(ndcgs).mean(), np.array(losses).mean()
all_mrr_ten.append(mrr_ten)
all_ndcg_ten.append(ndcg_ten)
all_mrr.append(mrr)
all_ndcg.append(ndcg)
print(
'Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f,MRR = %.3f, NDCG = %.3f, LOSS = %.3f'
% (epoch, mrr_ten, ndcg_ten, mrr, ndcg, loss))
print('AvgMRR@10 = %.3f, AvgNDCG@10 = %.3f,AvgMRR = %.3f, AvgNDCG = %.3f'
%(np.array(all_mrr_ten).mean(), np.array(all_ndcg_ten).mean() , \
np.array(all_mrr).mean(), np.array(all_ndcg).mean()))
if ndcg_ten > best_ndcg_ten:
best_itr, best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg, best_loss = epoch, mrr_ten, ndcg_ten, mrr, ndcg, loss
#if args.out > 0:
#model.save_weights(model_out_file, overwrite=True)
print(
"End. Best Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. "
% (best_itr, best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg,
best_loss))
all_best_mrr_ten.append(best_mrr_ten)
all_best_ndcg_ten.append(best_ndcg_ten)
all_best_mrr.append(best_mrr)
all_best_ndcg.append(best_ndcg)
all_best_loss.append(best_loss)
print(
"End. Mean Scores : MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. "
% (np.array(all_best_mrr_ten).mean(),
np.array(all_best_ndcg_ten).mean(), np.array(all_best_mrr).mean(),
np.array(all_best_ndcg).mean(), np.array(all_best_loss).mean()))
from __future__ import print_function
import os, sys
import os
import dataset_loader
import torch
import util
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import torchvision.transforms as transforms
ann_path = '/data/xiaobing.wang/xiangyu.zhu/FashionAI/data/warm_up_train/Annotations/annotations.csv'
img_dir = '/data/xiaobing.wang/xiangyu.zhu/FashionAI/data/warm_up_train/'
train_loader = torch.utils.data.DataLoader(dataset_loader.dataset_loader(
img_dir, ann_path, 8, transforms.ToTensor()),
batch_size=4,
shuffle=True,
num_workers=2,
pin_memory=True)
for i, (input, heatmap) in enumerate(train_loader):
imgs = input.numpy()
heats = heatmap.numpy()
break
def train_net(model, args):
ann_path = '../FashionAI/data/train/Annotations/trainminusval.csv'
img_dir = '../FashionAI/data/train/'
stride = 8
cudnn.benchmark = True
config = util.Config('./config.yml')
train_loader = torch.utils.data.DataLoader(
dataset_loader.dataset_loader(img_dir, ann_path, stride,
transforms.ToTensor()),
batch_size=config.batch_size, shuffle=True,
num_workers=config.workers, pin_memory=True)
criterion = nn.MSELoss().cuda()
params, multiple = get_parameters(model, config, False)
optimizer = torch.optim.SGD(params, config.base_lr, momentum=config.momentum,
weight_decay=config.weight_decay)
model.train()
iters = 0
batch_time = util.AverageMeter()
data_time = util.AverageMeter()
losses = util.AverageMeter()
losses_list = [util.AverageMeter() for i in range(12)]
end = time.time()
heat_weight = 48 * 48 * 25 / 2.0 # for convenient to compare with origin code
# heat_weight = 1
while iters < config.max_iter:
for i, (input, heatmap) in enumerate(train_loader):
learning_rate = util.adjust_learning_rate(optimizer, iters, config.base_lr, policy=config.lr_policy,\
policy_parameter=config.policy_parameter, multiple=multiple)
data_time.update(time.time() - end)
input = input.cuda(async=True)
heatmap = heatmap.cuda(async=True)
input_var = torch.autograd.Variable(input)
heatmap_var = torch.autograd.Variable(heatmap)
heat1, heat2, heat3, heat4, heat5, heat6 = model(input_var)
loss1 = criterion(heat1,heatmap_var) * heat_weight
loss2 = criterion(heat2, heatmap_var) * heat_weight
loss3 = criterion(heat3, heatmap_var) * heat_weight
loss4 = criterion(heat4, heatmap_var) * heat_weight
loss5 = criterion(heat5, heatmap_var) * heat_weight
loss6 = criterion(heat6, heatmap_var) * heat_weight
loss = loss1 + loss2 + loss3 + loss4 + loss5 + loss6
losses.update(loss.data[0], input.size(0))
loss_list = [loss1 , loss2 , loss3 , loss4 , loss5 , loss6]
for cnt, l in enumerate(loss_list):
losses_list[cnt].update(l.data[0], input.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
end = time.time()
iters += 1
if iters % config.display == 0:
print('Train Iteration: {0}\t'
'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t'
'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n'
'Learning rate = {2}\n'
'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.format(
iters, config.display, learning_rate, batch_time=batch_time,
data_time=data_time, loss=losses))
for cnt in range(0, 6):
print('Loss{0}_1 = {loss1.val:.8f} (ave = {loss1.avg:.8f})'.format(cnt + 1,loss1=losses_list[cnt]))
print(time.strftime(
'%Y-%m-%d %H:%M:%S -----------------------------------------------------------------------------------------------------------------\n',
time.localtime()))
batch_time.reset()
data_time.reset()
losses.reset()
for cnt in range(12):
losses_list[cnt].reset()
if iters % 5000 == 0:
torch.save({
'iter': iters,
'state_dict': model.state_dict(),
}, str(iters) + '.pth.tar')
if iters == config.max_iter:
break
return
def train_net(model, args):
ann_path = '../FashionAI/data/train/Annotations/trainminusval.csv'
img_dir = '../FashionAI/data/train/'
stride = 8
cudnn.benchmark = True
config = util.Config('./config.yml')
train_loader = torch.utils.data.DataLoader(dataset_loader.dataset_loader(
img_dir,
ann_path,
stride,
Mytransforms.Compose([
Mytransforms.RandomResized(),
Mytransforms.RandomRotate(40),
Mytransforms.RandomCrop(384),
]),
sigma=15),
batch_size=config.batch_size,
shuffle=True,
num_workers=config.workers,
pin_memory=True)
criterion = nn.MSELoss().cuda()
params = []
for key, value in model.named_parameters():
if value.requires_grad != False:
params.append({'params': value, 'lr': config.base_lr})
optimizer = torch.optim.SGD(params,
config.base_lr,
momentum=config.momentum,
weight_decay=config.weight_decay)
# model.train() # only for bn and dropout
model.eval()
from matplotlib import pyplot as plt
iters = 0
batch_time = util.AverageMeter()
data_time = util.AverageMeter()
losses = util.AverageMeter()
losses_list = [util.AverageMeter() for i in range(12)]
end = time.time()
heat_weight = 48 * 48 * 25 / 2.0 # for convenient to compare with origin code
# heat_weight = 1
while iters < config.max_iter:
for i, (input, heatmap) in enumerate(train_loader):
learning_rate = util.adjust_learning_rate(optimizer, iters, config.base_lr, policy=config.lr_policy,\
policy_parameter=config.policy_parameter)
data_time.update(time.time() - end)
input = input.cuda(async=True)
heatmap = heatmap.cuda(async=True)
input_var = torch.autograd.Variable(input)
heatmap_var = torch.autograd.Variable(heatmap)
heat = model(input_var)
# feat = C4.cpu().data.numpy()
# for n in range(100):
# plt.subplot(10, 10, n + 1);
# plt.imshow(feat[0, n, :, :], cmap='gray')
# plt.xticks([]);
# plt.yticks([])
# plt.show()
loss1 = criterion(heat, heatmap_var) * heat_weight
# loss2 = criterion(heat4, heatmap_var) * heat_weight
# loss3 = criterion(heat5, heatmap_var) * heat_weight
# loss4 = criterion(heat6, heatmap_var) * heat_weight
# loss5 = criterion(heat, heatmap_var)
# loss6 = criterion(heat, heatmap_var)
loss = loss1 # + loss2 + loss3# + loss4# + loss5 + loss6
losses.update(loss.data[0], input.size(0))
loss_list = [loss1] #, loss2, loss3]# , loss4 ]# , loss5 , loss6]
for cnt, l in enumerate(loss_list):
losses_list[cnt].update(l.data[0], input.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
end = time.time()
iters += 1
if iters % config.display == 0:
print(
'Train Iteration: {0}\t'
'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t'
'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n'
'Learning rate = {2}\n'
'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.format(
iters,
config.display,
learning_rate,
batch_time=batch_time,
data_time=data_time,
loss=losses))
for cnt in range(0, 1):
print(
'Loss{0}_1 = {loss1.val:.8f} (ave = {loss1.avg:.8f})'.
format(cnt + 1, loss1=losses_list[cnt]))
print(
time.strftime(
'%Y-%m-%d %H:%M:%S -----------------------------------------------------------------------------------------------------------------\n',
time.localtime()))
batch_time.reset()
data_time.reset()
losses.reset()
for cnt in range(12):
losses_list[cnt].reset()
if iters % 5000 == 0:
torch.save({
'iter': iters,
'state_dict': model.state_dict(),
},
str(iters) + '.pth.tar')
if iters == config.max_iter:
break
return
def __init__(self):
self.dataset = dataset_loader()
################################## ######## FIXED PARAMETERS ######## ################################## num_epochs = 200 alpha = 0.01 batch_size = 100 nW_hidden = 60 test_repeat = 10 e_s = 10 # error samples num_clases = 0 sample_size_idx = 0 fill_method_idx = 0 dl = dataset_loader(dataset_path) dl.load(fixed_sig_size=100) #mock load h_u_l = dl.get_labels_to_hot_dict() #homogenized unique labels so that every training use the same ################################## ########### VARIABLES ############ ################################## "sample sizes' = [int(100*(1.3**ii)) for ii in range(10)]" "fill_methods = [interpolation, left_padding, right_padding]" fill_methods = ["interpolation", "left_padding", "right_padding"] # fill_methods = ["left_padding"] sample_sizes = [100, 130, 169, 219, 285, 371, 482, 627, 815, 1060] decreasing = False if decreasing:
def train_net():
annList = [
'../data/train/Annotations/blouse.csv',
'../data/train/Annotations/dress.csv',
'../data/train/Annotations/outwear.csv',
'../data/train/Annotations/skirt.csv',
'../data/train/Annotations/trousers.csv'
]
classNumList = [13, 15, 14, 4, 7]
index_array = [[2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14, 15, 16],
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 19, 20],
[2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
[17, 18, 19, 20], [17, 18, 21, 22, 23, 24, 25]]
paramsNameList = ['blouse', 'dress', 'outwear', 'skirt', 'trousers']
modelSaveList = [
'../saveparameter/blouse/', '../saveparameter/dress/',
'../saveparameter/outwear/', '../saveparameter/skirt/',
'../saveparameter/trousers/'
]
paramsOldList = [
'../saveparameter/blouse/3000res50.pth.tar',
'../saveparameter/dress/15000new2.pth.tar',
'../saveparameter/outwear/10000new2.pth.tar',
'../saveparameter/skirt/5000new2.pth.tar',
'/home/tanghm/Documents/YFF/project/saveparameter/trousers/15000new2.pth.tar'
]
for idx in range(0, 1):
#打印当前训练的服饰类别
print('train' + paramsNameList[idx])
#该服饰一共需要预测多少个关键点
numpoints = classNumList[idx]
#构建模型
model = construct_model(numpoints)
state_dict = torch.load(paramsOldList[idx])['state_dict']
model.load_state_dict(state_dict)
# lable文件的路径
ann_path = annList[idx]
#图像所在路径
img_dir = '../data/train/'
stride = 8
cudnn.benchmark = True
config = util.Config('./config.yml')
#构建训练的数据
train_loader = torch.utils.data.DataLoader(
dataset_loader.dataset_loader(numpoints,
img_dir,
ann_path,
stride,
Mytransforms.Compose([
Mytransforms.RandomResized(),
Mytransforms.RandomRotate(40),
Mytransforms.RandomCrop(384),
]),
sigma=15),
batch_size=config.batch_size,
shuffle=True,
num_workers=config.workers,
pin_memory=True)
#网络的loss函数类型
if (torch.cuda.is_available()):
criterion = nn.MSELoss().cuda()
params = []
for key, value in model.named_parameters():
if value.requires_grad != False:
params.append({'params': value, 'lr': config.base_lr})
# optimizer = torch.optim.SGD(params, config.base_lr, momentum=config.momentum,
# weight_decay=config.weight_decay)
optimizer = torch.optim.Adam(params,
lr=config.base_lr,
betas=(0.9, 0.99),
weight_decay=config.weight_decay)
# model.train() # only for bn and dropout
model.eval()
# from matplotlib import pyplot as plt
iters = 0
batch_time = util.AverageMeter()
data_time = util.AverageMeter()
losses = util.AverageMeter()
losses_list = [util.AverageMeter() for i in range(12)]
end = time.time()
heat_weight = 48 * 48 * (
classNumList[idx] +
1) / 2.0 # for convenient to compare with origin code
# heat_weight = 1
while iters < config.max_iter:
#input 表示图片，heatmap表示网络输出值
for i, (input, heatmap) in enumerate(train_loader):
learning_rate = util.adjust_learning_rate(optimizer, iters, config.base_lr, policy=config.lr_policy, \
policy_parameter=config.policy_parameter)
data_time.update(time.time() - end)
if (torch.cuda.is_available()):
input = input.cuda(async=True)
heatmap = heatmap.cuda(async=True)
input_var = torch.autograd.Variable(input)
heatmap_var = torch.autograd.Variable(heatmap)
#将图像进行tensor和Variable转化后喂进模型
heat = model(input_var)
# feat = C4.cpu().data.numpy()
# for n in range(100):
# plt.subplot(10, 10, n + 1);
# plt.imshow(feat[0, n, :, :], cmap='gray')
# plt.xticks([]);
# plt.yticks([])
# plt.show()
loss1 = criterion(heat, heatmap_var) * heat_weight
# loss2 = criterion(heat4, heatmap_var) * heat_weight
# loss3 = criterion(heat5, heatmap_var) * heat_weight
# loss4 = criterion(heat6, heatmap_var) * heat_weight
# loss5 = criterion(heat, heatmap_var)
# loss6 = criterion(heat, heatmap_var)
loss = loss1 # + loss2 + loss3# + loss4# + loss5 + loss6
losses.update(loss.data[0], input.size(0))
loss_list = [loss1
] # , loss2, loss3]# , loss4 ]# , loss5 , loss6]
for cnt, l in enumerate(loss_list):
losses_list[cnt].update(l.data[0], input.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
batch_time.update(time.time() - end)
end = time.time()
iters += 1
if iters % config.display == 0:
print(
'Train Iteration: {0}\t'
'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t'
'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n'
'Learning rate = {2}\n'
'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.
format(iters,
config.display,
learning_rate,
batch_time=batch_time,
data_time=data_time,
loss=losses))
for cnt in range(0, 1):
print(
'Loss{0}_1 = {loss1.val:.8f} (ave = {loss1.avg:.8f})'
.format(cnt + 1, loss1=losses_list[cnt]))
print(
time.strftime(
'%Y-%m-%d %H:%M:%S -----------------------------------------------------------------------------------------------------------------\n',
time.localtime()))
batch_time.reset()
data_time.reset()
losses.reset()
for cnt in range(12):
losses_list[cnt].reset()
if iters % 1000 == 0:
torch.save(
{
'iter': iters,
'state_dict': model.state_dict(),
}, modelSaveList[idx] + str(iters) + 'res50.pth.tar')
with open('./logLoss2.txt', 'a') as f:
f.write(
'Train Iteration: {0}\t'
'Time {batch_time.sum:.3f}s / {1}iters, ({batch_time.avg:.3f})\t'
'Data load {data_time.sum:.3f}s / {1}iters, ({data_time.avg:3f})\n'
'Learning rate = {2}\n'
'Loss = {loss.val:.8f} (ave = {loss.avg:.8f})\n'.
format(iters,
config.display,
learning_rate,
batch_time=batch_time,
data_time=data_time,
loss=losses) + '\n')
if iters == config.max_iter:
break
return
def run(dropout_rate, num_negatives, metric, method, layers, reg_layers, decay,
batch_size, learning_rate, epochs, evaluation_threads, dataset,
data_path, start_fold, num_folds, verbose):
all_best_mrr_ten, all_best_ndcg_ten, all_best_mrr,all_best_ndcg,all_best_loss = [], [], [],[], []
for fold in range(start_fold, num_folds):
learning_rate = float(os.getenv("lr", learning_rate))
print("Fold " + str(fold))
t1 = time()
path = data_path + "fold" + str(fold) + "/"
dataset_name = dataset_loader(path, dataset, method)
training_data_matrix, test_ratings, test_positives, itemAttributes, train_items = \
dataset_name.train_matrix, dataset_name.test_ratings, dataset_name.test_positives, \
dataset_name.item_features, dataset_name.train_items
num_users, num_items = training_data_matrix.shape
print(
"Data load done in [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d"
% (time() - t1, num_users, num_items, training_data_matrix.nnz,
len(test_ratings)))
if (method == "neumf"):
model = deeprec_neumf(num_users, num_items, layers, reg_layers)
elif (method == "dser"):
model = deeprec_dser(dropout_rate, num_users, num_items, layers,
reg_layers)
model.compile(optimizer=Adam(lr=learning_rate, decay=decay),
loss=metric) #mean_squared_error
all_mrr_ten, all_ndcg_ten, all_mrr, all_ndcg = [], [], [], []
best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg, best_loss = 0.0, 0.0, 0.0, 0.0, 123456789
for epoch in xrange(epochs):
user_input, item_input, labels = \
get_train_instances(training_data_matrix, train_items,num_negatives)
#np.array(user_gender_input),np.array(user_age_input),
model.fit(
[np.array(user_input),
np.array(item_input)], #input
np.array(labels), # labels
batch_size=batch_size,
validation_split=0.00,
epochs=1,
verbose=0,
shuffle=True) #validation_split=0.30,
# Evaluation
if epoch % verbose == 0:
mrr_tens, ndcg_tens, mrrs, ndcgs, losses = evaluate_model(
train_items, method, metric, dataset, model, test_ratings,
test_positives, itemAttributes, 10, evaluation_threads,
None)
mrr_ten, ndcg_ten,mrr,ndcg,loss = np.array(mrr_tens).mean(), np.array(ndcg_tens).mean(), \
np.array(mrrs).mean(), np.array(ndcgs).mean(), np.array(losses).mean()
all_mrr_ten.append(mrr_ten)
all_ndcg_ten.append(ndcg_ten)
all_mrr.append(mrr)
all_ndcg.append(ndcg)
print(
'Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f,MRR = %.3f, NDCG = %.3f, LOSS = %.3f'
% (epoch, mrr_ten, ndcg_ten, mrr, ndcg, loss))
print('AvgMRR@10 = %.3f, AvgNDCG@10 = %.3f,AvgMRR = %.3f, AvgNDCG = %.3f'
%(np.array(all_mrr_ten).mean(), np.array(all_ndcg_ten).mean() , \
np.array(all_mrr).mean(), np.array(all_ndcg).mean()))
if ndcg_ten > best_ndcg_ten:
best_itr, best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg, best_loss = epoch, mrr_ten, ndcg_ten, mrr, ndcg, loss
#if args.out > 0:
#model.save_weights(model_out_file, overwrite=True)
print(
"End. Best Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. "
% (best_itr, best_mrr_ten, best_ndcg_ten, best_mrr, best_ndcg,
best_loss))
all_best_mrr_ten.append(best_mrr_ten)
all_best_ndcg_ten.append(best_ndcg_ten)
all_best_mrr.append(best_mrr)
all_best_ndcg.append(best_ndcg)
all_best_loss.append(best_loss)
print(
"End. Mean Scores : MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. "
% (np.array(all_best_mrr_ten).mean(),
np.array(all_best_ndcg_ten).mean(), np.array(all_best_mrr).mean(),
np.array(all_best_ndcg).mean(), np.array(all_best_loss).mean()))
def run(metric,learning_rate,bpr_k,epochs, evaluation_threads, dataset, data_path, start_fold, num_folds,verbose):
#all parameters needed setting are here
penalty_factor = 0.0001
bpr_args = BPRArgs(learning_rate, 1, 0.01, 0.01, 0.01)
all_best_mrr_ten, all_best_ndcg_ten, all_best_mrr,all_best_ndcg,all_best_loss = [], [], [],[], []
for fold in range(start_fold,num_folds):
# Loading data
print("Fold " + str(fold))
t1 = time()
path = data_path + "fold" + str(fold) + "/"
dataset_name = dataset_loader(path, dataset,"map-bpr")
training_data_matrix, test_ratings, test_data_matrix, test_positives, train_items = \
dataset_name.train_matrix, dataset_name.test_ratings,dataset_name.test_matrix, dataset_name.test_positives, dataset_name.train_items
training_data = sp.csc_matrix(training_data_matrix)
test_data = sp.csc_matrix(test_data_matrix)
attr = []
splitter = ds.DataSplitter(training_data,test_data, attr, 1)
data_matrix = splitter.split_data()
attr_matix = None#splitter.split_attr()
num_users, num_items = training_data.shape
print("Data load done in [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d"
%(time()-t1, num_users, num_items, training_data.nnz, len(test_ratings)))
model = mapper.BPR(train_items,training_data_matrix,sp.hstack(data_matrix,"csc"), None, bpr_k, bpr_args, learning_rate, penalty_factor, path)
all_mrr_ten, all_ndcg_ten,all_mrr,all_ndcg = [], [], [],[]
best_mrr_ten, best_ndcg_ten, best_mrr,best_ndcg, best_loss = 0.0, 0.0, 0.0, 0.0, 123456789
for it in range(epochs):
bpr_users, bpr_items, loss = model.train(it,epochs)
# Evaluation
if it %verbose == 0:
mrr_tens, ndcg_tens,mrrs,ndcgs, losses = evaluate_model(train_items,"bpr",metric, dataset, model, test_ratings, test_positives, None, 10, evaluation_threads, None)
mrr_ten, ndcg_ten,mrr,ndcg,loss = np.array(mrr_tens).mean(), np.array(ndcg_tens).mean(), \
np.array(mrrs).mean(), np.array(ndcgs).mean(), np.array(losses).mean()
all_mrr_ten.append(mrr_ten)
all_ndcg_ten.append(ndcg_ten)
all_mrr.append(mrr)
all_ndcg.append(ndcg)
print('Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f,MRR = %.3f, NDCG = %.3f, LOSS = %.3f'
% (it, mrr_ten, ndcg_ten,mrr,ndcg,loss))
print('AvgMRR@10 = %.3f, AvgNDCG@10 = %.3f,AvgMRR = %.3f, AvgNDCG = %.3f'
%(np.array(all_mrr_ten).mean(), np.array(all_ndcg_ten).mean() , \
np.array(all_mrr).mean(), np.array(all_ndcg).mean()))
if ndcg_ten > best_ndcg_ten:
best_itr, best_mrr_ten, best_ndcg_ten, best_mrr,best_ndcg,best_loss = it,mrr_ten, ndcg_ten,mrr,ndcg,loss
#if args.out > 0:
#model.save_weights(model_out_file, overwrite=True)
print("End. Best Iteration %d: MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. " %(best_itr,best_mrr_ten, best_ndcg_ten,best_mrr,best_ndcg,best_loss))
all_best_mrr_ten.append(best_mrr_ten)
all_best_ndcg_ten.append(best_ndcg_ten)
all_best_mrr.append(best_mrr)
all_best_ndcg.append(best_ndcg)
all_best_loss.append(best_loss)
print("End. Mean Scores : MRR@10 = %.3f, NDCG@10 = %.3f, MRR = %.3f, NDCG = %.3f, LOSS = %.3f. " %(np.array(all_best_mrr_ten).mean(),np.array(all_best_ndcg_ten).mean(),np.array(all_best_mrr).mean(),np.array(all_best_ndcg).mean() ,np.array(all_best_loss).mean()))
from reportlab.graphics.charts.axes import sample0a __author__ = 'geco' import SLP import numpy as np from dataset_loader import dataset_loader dataset_path = "./dataset/" num_epochs = 2000 # dataset_lenght = 100 sample_size = 100 alpha = 0.01 nW_hidden = 400 batch_size = 30 dl = dataset_loader(dataset_path) dl.load(fixed_sig_size=sample_size) la_to_ho = dl.get_labels_to_hot_dict() print la_to_ho num_classes = len(la_to_ho) slp = SLP.SLP(sample_size*2,nW_hidden,num_classes) # Get batch and its labels batch,labels,hotone_labels = dl.next_2d_batch(batch_size) # Get the labels in the hot-one form, using the dictionary # batch2,labels2 = dl.next_2d_batch(batch_size) # Number of inputs will depend on the adjusted size of each sample # Number of outputs will depend on the number of different classes to classify err = 0 for ii in range(num_epochs):