def eval_classifier(classifierToUse, featuresToUse, testOrTrain="train"):
print("Chosen feature: {0}".format(featuresToUse) )
print("Chosen classifier: {0}".format(classifierToUse))
fe = FeatureExtractor(featuresToUse)
dataset = DataSet(fe)
classifier = Classifier()
evaluate = Evaluation()
print "test or Train %s" % testOrTrain
for feature_class, files in getTestData(testOrTrain).items():
print "%s" % testOrTrain
for f in files:
dataset.addFile(feature_class, f)
print "Dataset initialized"
print_class_stats(dataset.classes)
print "Test set created."
a_train, a_test, c_train, c_test = train_test_split(dataset.featureVector, dataset.classes, test_size=0.9)
c_pred = classifier.classification(a_train,a_test,c_train,c_test,classifierToUse)
evaluate.evaluate(c_pred,c_test,featuresToUse,classifierToUse)
def main(self):
"""
Method executing the whole pipeline.
"""
##
# get data
##
if (self.dataset in DataLoader.default_datasets
or os.path.exists(self.dataset)):
dataLoader = DataLoader(DataLoader.default_datasets[self.dataset])
data = dataLoader.load()
self.model_params['img_size'] = data.get_dimensions()
self.model_params['label_size'] = data.get_label_dimensions()
else:
print("Dataset " + self.dataset + " does not exist. Aborting...")
return -1
###
# Potential Graph creation
###
if not os.path.exists(os.path.join(self.model_folder, 'model.meta')):
builder = GraphBuilder()
builder.build_graph(self.model_name, self.model_params)
###
# Network training
###
if self.do_training:
network = Network(self.model_name, self.model_folder, self.opt,
self.opt_params, self.num_epochs,
self.batch_size, data, self.summary_folder,
self.summary_intervals, self.complete_set,
self.keep_prob, self.l2_reg, self.clip_gradient,
self.clip_value)
network.load_and_train()
###
# Evaluation
###
if self.do_eval:
evaluator = Evaluation(data, self.model_folder,
self.summary_folder, self.model_name,
self.summary_folder, self.batch_size,
**self.eval_params)
evaluator.evaluate()
print('Finished Evaluation.')
###
# Tensorboard
###
if self.tensorboard and self.do_training:
print("Opening Tensorboard")
os.system("tensorboard --logdir=" + self.summary_folder)
def identifyCorpus(corpus, x=-1):
""" update corpus with mwedictionaries (type, count, tokens),
train, predict and evaluate corpus
"""
print(XPParams.use_extern_labels)
if XPParams.use_extern_labels:
Parser.parse(corpus, "") # -> prediction
scores = Evaluation.evaluate(corpus) # -> evaluate
else:
corpus.update()
clf = EmbeddingOracle.train(corpus, x) # -> training
Parser.parse(corpus, clf) # -> prediction
scores = Evaluation.evaluate(corpus) # -> evaluate
return scores
def run(configFile, name):
OutputPath.init(configFile)
OutputPath.clear()
thread = ThreadWritableObject(configFile, name)
thread.start()
sys.stdout = thread
sys.errout = thread # XXX: Actually, it does NOT work
try:
db = Database(configFile, 'specials')
db.initialize()
skuManager = SkuManager(configFile, db)
couponManager = CouponManager(configFile, db)
discountManager = DiscountManager(configFile, db)
seckillManager = SeckillManager(db)
priceHistoryManager = PriceHistoryManager(db)
evaluation = Evaluation(configFile, db)
couponManager.update()
discountManager.update()
seckillManager.update()
skuManager.update()
evaluation.update()
priceHistoryManager.update()
evaluation.evaluate()
except KeyboardInterrupt:
pass
except Exception, e:
print 'Error occurs at', datetime.now().strftime('%Y-%m-%d %H:%M:%S')
traceback.print_exc(file=sys.stdout)
def eval_comp(config_name, trial, i, log_i):
global xp, testcases
config = configs[config_name]
for key in log_i._logs.keys():
print key, len(log_i._logs[key])
if i == 0:
config.gui = gui
config.env_cfg["gui"] = gui
xp = ToolsExperiment(config, log_dir=log_dir + config_name + "/")
else:
xp.ag.fast_forward(log_i)
xp.ag.eval_mode()
evaluation = Evaluation(xp.log, xp.ag, xp.env, testcases, modes=["inverse"])
result = evaluation.evaluate()
return result
def eval_comp(config_name, trial, i, log_i):
global xp, testcases
config = configs[config_name]
for key in log_i._logs.keys():
print key, len(log_i._logs[key])
if i == 0:
config.gui = gui
config.env_cfg['gui'] = gui
xp = ToolsExperiment(config, log_dir=log_dir + config_name + '/')
else:
xp.ag.fast_forward(log_i)
xp.ag.eval_mode()
evaluation = Evaluation(xp.log,
xp.ag,
xp.env,
testcases,
modes=["inverse"])
result = evaluation.evaluate()
return result
lr_schedular.step()
# save_weights(model, path)
e = Evaluation(10)
for image, label in dataloader_test:
image = image/255
predicted = model(image)
probs = softMax(predicted)
pred = np.argmax(probs,axis=0)
e.add_prediction(pred[np.newaxis],label)
print("the confusion Matrix:\n",e.get_confusion_Matrix())
print("the Mean F1 Score:\n",e.evaluate())
model1 = Model()
model1.add(Dense(784, 90))
model1.add(ReLU())
model1.add(Dense(90, 45))
model1.add(ReLU())
model1.add(Dense(45, 10))
model1.set_loss(CrossEntropyLoss())
optimizer1 = GradientDecent(model1.parameters(), learning_rate = 0.01)
epochs = 6
for epoch in range(epochs):
i = 0
for image, label in dataloader:
def train(dataset, alpha, A_type, normalize_type, model_pretrained_params,
model_type, batch_size, test_batch_size, negative_nums, item_emb_dim,
hid_dim1, hid_dim2, hid_dim3, lr_emb, l2_emb, lr_gcn, l2_gcn, lr_cnn,
l2_cnn, epochs, params_file_name):
# init
if dataset == 'LastFM':
# use LastFM dataset
data_obj = LastfmData()
elif dataset == 'Diginetica':
# use Diginetica dataset
data_obj = DigineticaData()
else:
# use yoochoose1_64 dataset
data_obj = YoochooseData(dataset=dataset)
# gpu device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# init A
# A: type=scipy.sparse
A = data_obj.get_decay_adj(
data_obj.d, tail=None,
alpha=alpha) if A_type == 'decay' else data_obj.get_gcn_adj(data_obj.d)
# normalize the adj, type = 'ramdom_walk'(row 1) or type = 'symmetric'
if normalize_type == 'random_walk':
print('----------------------------------')
print('Normalize_type is random_walk:')
A = spmx_1_normalize(A)
print('----------------------------------')
else:
print('----------------------------------')
print('Normalize_type is symmetric:')
A = spmx_sym_normalize(A)
print('----------------------------------')
# transform the adj to a sparse cpu tensor
A = spmx2torch_sparse_tensor(A)
# get cpu tensor: labels
labels = data_obj.get_labels(data_obj.d)
# get cpu sparse tensor: session adj
SI = data_obj.get_session_adj(data_obj.d, alpha=alpha)
# load model pretrained params
if model_pretrained_params == 'True':
print('----------------------------------')
if dataset == 'LastFM':
# use LastFM params
print('Use LastFM model pretraned params: ' + params_file_name +
'.pkl')
pretrained_state_dict = torch.load('./lastfm_pretrained_params/' +
params_file_name + '.pkl')
elif dataset == 'Diginetica':
# use Diginetica params
print('Use Diginetica model pretraned params: ' +
params_file_name + '.pkl')
pretrained_state_dict = torch.load('./dig_pretrained_params/' +
params_file_name + '.pkl')
else:
# use yoochoose1_64 params
print('Use yoochoose1_64 model pretraned params: ' +
params_file_name + '.pkl')
pretrained_state_dict = torch.load('./yoo1_64_pretrained_params/' +
params_file_name + '.pkl')
print('----------------------------------')
else:
pretrained_state_dict = None
# transform all tensor to cuda
A = A.to(device)
labels = labels.to(device)
SI = SI.to(device)
# define the evalution object
evalution5 = Evaluation(k=5)
evalution10 = Evaluation(k=10)
evalution15 = Evaluation(k=15)
evalution20 = Evaluation(k=20)
# define yoochoose data object
trainloader = SessionDataloader(train_size=data_obj.train_size,
test_size=data_obj.test_size,
item_size=data_obj.item_size,
labels=labels,
batch_size=batch_size,
train=True,
negative_nums=negative_nums,
shuffle=True)
testloader = SessionDataloader(train_size=data_obj.train_size,
test_size=data_obj.test_size,
item_size=data_obj.item_size,
labels=labels,
batch_size=test_batch_size *
data_obj.item_size,
train=False,
negative_nums=negative_nums,
shuffle=False)
# define model, then transform to cuda
if model_type == 'sgncf1_cnn':
# use sgncf1_cnn model:
model = sgncf1_cnn(dataset_nums=data_obj.train_size +
data_obj.test_size,
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1)
else:
# use sgncf2_cnn model:
model = sgncf2_cnn(dataset_nums=data_obj.train_size +
data_obj.test_size,
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
hid_dim2=hid_dim2)
model.to(device)
# update model_state_dict
if pretrained_state_dict is not None:
model_state_dict = model.state_dict()
pretrained_state_dict = {
k: v
for k, v in pretrained_state_dict.items() if k in model_state_dict
}
model_state_dict.update(pretrained_state_dict)
model.load_state_dict(model_state_dict)
# define loss and optim
criterion = nn.BCEWithLogitsLoss()
if model_type == 'sgncf1_cnn':
# use sgncf1 model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
optim_cnn = optim.Adam([{
'params': model.cnn_1d.parameters()
}, {
'params': model.fc.parameters()
}],
lr=lr_cnn,
weight_decay=l2_cnn)
else:
# use sgncf2 model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}, {
'params': model.gconv2.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
optim_cnn = optim.Adam([{
'params': model.cnn_1d.parameters()
}, {
'params': model.fc.parameters()
}],
lr=lr_cnn,
weight_decay=l2_cnn)
# figure recall mrr norm
fig_recalls = []
fig_mrrs = []
fig_emb_norms = []
fig_gcn_norms = []
fig_cnn_norms = []
fig_epochs = []
# train epochs
for epoch in range(epochs):
# model training
start = time.time()
# test evalution dict
r = {'5': [], '10': [], '15': [], '20': []}
m = {'5': [], '10': [], '15': [], '20': []}
# loss list
losses = []
model.train()
for i, data in enumerate(trainloader):
# zero optim
optim_emb.zero_grad()
optim_gcn.zero_grad()
optim_cnn.zero_grad()
# batch inputs
batch_sidxes, batch_iidxes, batch_labels = data[:, 0].long().to(
device), data[:,
1].long().to(device), data[:,
2].float().to(device)
# predicting
outs = model(batch_sidxes, batch_iidxes, A, SI)
# loss
loss = criterion(outs, batch_labels)
# backward
loss.backward()
# optim step
optim_emb.step()
optim_gcn.step()
optim_cnn.step()
# losses
losses.append(loss.item())
# print loss, recall, mrr
if i % 20 == 19:
print('[{0: 2d}, {1:5d}, {2: 7d}], loss:{3:.4f}'.format(
epoch + 1, int(i * (batch_size / (negative_nums + 1))),
data_obj.train_size, np.mean(losses)))
# print gcn_norm, emb_norm
emb_norm = get_norm(model, 'emb')
gcn_norm = get_norm(model, 'gcn')
cnn_norm = get_norm(model, 'cnn')
fig_emb_norms.append(emb_norm)
fig_gcn_norms.append(gcn_norm)
fig_cnn_norms.append(gcn_norm)
print('[gcn_norm]:{0:.4f} [emb_norm]:{1:.4f} [cnn_norm]:{2:.4f}'.
format(gcn_norm, emb_norm, cnn_norm))
# epoch time
print('[epoch time]:{0:.4f}'.format(time.time() - start))
# model eval
model.eval()
with torch.no_grad():
for j, d in enumerate(testloader):
# test batch inputs
b_sidxes, b_iidxes, b_labels = d[0][:, 0].long().to(
device), d[0][:, 1].long().to(device), d[1].to(device)
# predicting
o = model(b_sidxes, b_iidxes, A, SI)
o = o.view(-1, data_obj.item_size)
# evalution, k=5, 10, 15, 20
r['5'].append(evalution5.evaluate(o, b_labels)[0])
r['10'].append(evalution10.evaluate(o, b_labels)[0])
r['15'].append(evalution15.evaluate(o, b_labels)[0])
r['20'].append(evalution20.evaluate(o, b_labels)[0])
m['5'].append(evalution5.evaluate(o, b_labels)[1])
m['10'].append(evalution10.evaluate(o, b_labels)[1])
m['15'].append(evalution15.evaluate(o, b_labels)[1])
m['20'].append(evalution20.evaluate(o, b_labels)[1])
# print test inf
# print('[{0: 2d}, {1: 5d}, {2: 7d}]'.format(epoch+1,
# j * test_batch_size,
# data_obj.test_size))
# print test recall mrr
print('[{0: 2d}]'.format(epoch + 1))
print('[recall@5 ]:{0:.4f} [mrr@5 ]:{1:.4f}'.format(
np.sum(r['5']) / data_obj.test_size,
np.sum(m['5']) / data_obj.test_size))
print('[recall@10]:{0:.4f} [mrr@10]:{1:.4f}'.format(
np.sum(r['10']) / data_obj.test_size,
np.sum(m['10']) / data_obj.test_size))
print('[recall@15]:{0:.4f} [mrr@15]:{1:.4f}'.format(
np.sum(r['15']) / data_obj.test_size,
np.sum(m['15']) / data_obj.test_size))
print('[recall@20]:{0:.4f} [mrr@20]:{1:.4f}'.format(
np.sum(r['20']) / data_obj.test_size,
np.sum(m['20']) / data_obj.test_size))
# plt recall and mrr and norm
fig_epochs.append(epoch)
fig_recalls.append(np.sum(r['20']) / data_obj.test_size)
fig_mrrs.append(np.sum(m['20']) / data_obj.test_size)
plt_evalution(fig_epochs,
fig_recalls,
fig_mrrs,
k=20,
alpha=alpha,
lr_emb=lr_emb,
l2_emb=l2_emb,
lr_gcn=lr_gcn,
l2_gcn=l2_gcn,
model_type=model_type,
lr_cnn=lr_cnn,
l2_cnn=l2_cnn)
plt_norm(fig_epochs,
fig_emb_norms,
fig_gcn_norms,
fig_cnn_norms,
alpha=alpha,
lr_emb=lr_emb,
l2_emb=l2_emb,
lr_gcn=lr_gcn,
l2_gcn=l2_gcn,
model_type=model_type,
lr_cnn=lr_cnn,
l2_cnn=l2_cnn)
action='store_true',
help='Evaluate the model')
parser.add_argument('--num_points',
type=int,
default=2048,
help='Num of points to use')
parser.add_argument('--model_path',
type=str,
default='',
metavar='N',
help='Path to load model')
parser.add_argument('--num_workers',
type=int,
default=0,
metavar='N',
help='Number of workers to load data')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = get_parser()
if args.eval == False:
reconstruction = Trainer(args)
reconstruction.train()
else:
inference = Evaluation(args)
feature_dir = inference.evaluate()
svm = SVM(feature_dir)
svm.classify()
def identifyCorpus(corpus):
corpus.update()
clf = EmbeddingOracle.train(corpus)
Parser.parse(corpus, clf)
scores = Evaluation.evaluate(corpus)
return scores
def model_test(dataset, alpha, A_type, normalize_type, model_type,
negative_nums, item_emb_dim, hid_dim1, hid_dim2,
model_pretrained_params, params_file_name):
# init
if dataset == 'LastFM':
# use LastFM dataset
data_obj = LastfmData()
elif dataset == 'Diginetica':
# use Diginetica dataset
data_obj = DigineticaData()
else:
# use yoochoose1_64 dataset
data_obj = YoochooseData(dataset=dataset)
# gpu device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# init A
# A: type=scipy.sparse
A = data_obj.get_decay_adj(
data_obj.d, tail=None,
alpha=alpha) if A_type == 'decay' else data_obj.get_gcn_adj(data_obj.d)
# normalize the adj, type = 'ramdom_walk'(row 1) or type = 'symmetric'
if normalize_type == 'random_walk':
print('----------------------------------')
print('Normalize_type is random_walk:')
A = spmx_1_normalize(A)
print('----------------------------------')
else:
print('----------------------------------')
print('Normalize_type is symmetric:')
A = spmx_sym_normalize(A)
print('----------------------------------')
# transform the adj to a sparse cpu tensor
A = spmx2torch_sparse_tensor(A)
# get cpu tensor: labels
labels = data_obj.get_labels(data_obj.d)
# get cpu sparse tensor: session adj
SI = data_obj.get_session_adj(data_obj.d, alpha=alpha)
# load model pretrained params
if model_pretrained_params == 'True':
print('----------------------------------')
if dataset == 'LastFM':
# use LastFM params
print('Use LastFM model pretraned params: ' + params_file_name +
'.pkl')
pretrained_state_dict = torch.load('./lastfm_pretrained_params/' +
params_file_name + '.pkl')
elif dataset == 'Diginetica':
# use Diginetica params
print('Use Diginetica model pretraned params: ' +
params_file_name + '.pkl')
pretrained_state_dict = torch.load('./dig_pretrained_params/' +
params_file_name + '.pkl')
else:
# use yoochoose1_64 params
print('Use yoochoose1_64 model pretraned params: ' +
params_file_name + '.pkl')
pretrained_state_dict = torch.load('./yoo1_64_pretrained_params/' +
params_file_name + '.pkl')
print('----------------------------------')
else:
pretrained_state_dict = None
# transform all tensor to cuda
A = A.to(device)
labels = labels.to(device)
SI = SI.to(device)
# define the evalution object
evalution5 = Evaluation(k=5)
evalution10 = Evaluation(k=10)
evalution15 = Evaluation(k=15)
evalution20 = Evaluation(k=20)
# define yoochoose data object
testloader = SessionDataloader(train_size=data_obj.train_size,
test_size=data_obj.test_size,
item_size=data_obj.item_size,
labels=labels,
batch_size=50 * data_obj.item_size,
train=False,
negative_nums=negative_nums,
shuffle=False)
# define model, then transform to cuda
if model_type == 'sgncf1':
# use sgncf1_cnn model:
model = sgncf1(dataset_nums=data_obj.train_size + data_obj.test_size,
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
pretrained_item_emb=None)
else:
# use sgncf2_cnn model:
model = sgncf2(dataset_nums=data_obj.train_size + data_obj.test_size,
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
hid_dim2=hid_dim2,
pretrained_item_emb=None)
model.to(device)
# update model_state_dict
if pretrained_state_dict is not None:
model_state_dict = model.state_dict()
pretrained_state_dict = {
k: v
for k, v in pretrained_state_dict.items() if k in model_state_dict
}
model_state_dict.update(pretrained_state_dict)
model.load_state_dict(model_state_dict)
# test evalution dict
r = {'5': [], '10': [], '15': [], '20': []}
m = {'5': [], '10': [], '15': [], '20': []}
# model eval
model.eval()
with torch.no_grad():
for j, d in enumerate(testloader):
# test batch inputs
b_sidxes, b_iidxes, b_labels = d[0][:, 0].long().to(
device), d[0][:, 1].long().to(device), d[1].to(device)
# predicting
o = model(b_sidxes, b_iidxes, A, SI)
o = o.view(-1, data_obj.item_size)
# evalution, k=5, 10, 15, 20
r['5'].append(evalution5.evaluate(o, b_labels)[0])
r['10'].append(evalution10.evaluate(o, b_labels)[0])
r['15'].append(evalution15.evaluate(o, b_labels)[0])
r['20'].append(evalution20.evaluate(o, b_labels)[0])
m['5'].append(evalution5.evaluate(o, b_labels)[1])
m['10'].append(evalution10.evaluate(o, b_labels)[1])
m['15'].append(evalution15.evaluate(o, b_labels)[1])
m['20'].append(evalution20.evaluate(o, b_labels)[1])
print('[{0: 2d}, {1: 4d}]'.format(j * 50, data_obj.test_size))
# print test recall mrr
print('[recall@5 ]:{0:.4f} [mrr@5 ]:{1:.4f}'.format(
np.sum(r['5']) / data_obj.test_size,
np.sum(m['5']) / data_obj.test_size))
print('[recall@10]:{0:.4f} [mrr@10]:{1:.4f}'.format(
np.sum(r['10']) / data_obj.test_size,
np.sum(m['10']) / data_obj.test_size))
print('[recall@15]:{0:.4f} [mrr@15]:{1:.4f}'.format(
np.sum(r['15']) / data_obj.test_size,
np.sum(m['15']) / data_obj.test_size))
print('[recall@20]:{0:.4f} [mrr@20]:{1:.4f}'.format(
np.sum(r['20']) / data_obj.test_size,
np.sum(m['20']) / data_obj.test_size))
def main():
"""
MAIN OHOHOHOHOHO
"""
sentiment_lexicon_dict = get_sentiment_lexicon(SENTIMENT_LEXICON_DIR)
evaluation = Evaluation(DATASET_DIR)
# RandomModel
evaluation.evaluate(RandomModel())
# MajorityModel
evaluation.evaluate(MajorityModel())
# LexiconFeaturesModel
evaluation.evaluate(LexiconFeaturesModel(sentiment_lexicon_dict))
evaluation.evaluate(
LexiconFeaturesModel(sentiment_lexicon_dict,
positive_around_num=[3, 5, 10],
negative_around_num=[3, 5, 10],
normalize_data=True))
evaluation.evaluate(
LexiconFeaturesModel(sentiment_lexicon_dict,
positive_around_num=[3, 5, 10],
negative_around_num=[3],
normalize_data=True))
evaluation.evaluate(
LexiconFeaturesModel(sentiment_lexicon_dict,
positive_around_num=[5],
negative_around_num=[3, 5, 10],
normalize_data=True))
evaluation.evaluate(
LexiconFeaturesModel(sentiment_lexicon_dict,
positive_around_num=[3, 5, 10, 15],
negative_around_num=[3, 5, 10],
normalize_data=False))
evaluation.evaluate(
LexiconFeaturesModel(sentiment_lexicon_dict,
positive_around_num=[3, 15],
negative_around_num=[10, 15],
normalize_data=False))
# BertModel
evaluation.evaluate(
BertModel(n_words_left_right=1,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=2,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=3,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=4,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=5,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=7,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=50,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=150,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=64,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=128,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.1,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.3,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=32,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=64,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=5))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=10))
evaluation.evaluate(
BertModel(n_words_left_right=6,
conv_filters=100,
dense_units=256,
dropout_rate=0.2,
batch_size=128,
epochs=15))
evaluation.evaluate(
DependencyModel(sentiment_lexicon_dict,
positive_around_num=[1, 2, 3, 4, 5],
negative_around_num=[1, 2, 3, 4, 5],
normalize_data=True))
class App:
"""
author: huobaolajiao
"""
def __init__(self, root):
self.labelusr = tk.Label(root, text='学号：')
self.labelusr.grid(row=0, sticky=tk.W)
self.username = tk.StringVar()
tk.Entry(root, textvariable=self.username).grid(row=0, column=1)
self.labelpw = tk.Label(root, text='密码：')
self.labelpw.grid(row=1, sticky=tk.W)
self.password = tk.StringVar()
tk.Entry(root, textvariable=self.password, show='*').grid(row=1,
column=1)
self.labelcode = tk.Label(root, text='验证码：')
self.labelcode.grid(row=2, sticky=tk.W)
self.code = tk.StringVar()
tk.Entry(root, textvariable=self.code).grid(row=2, column=1)
self.button1 = tk.Button(root, text="登陆", command=self.prelogin)
self.button1.grid(row=3, column=0)
self.button2 = tk.Button(root, text="更换验证码", command=self.prechange)
self.button2.grid(row=3, column=2)
self.info = tk.LabelFrame(root, text='信息栏： ')
self.error = tk.StringVar()
self.info.grid(row=4, column=1)
self.Labelerr = tk.Label(self.info,
textvariable=self.error,
wraplength=130,
height=2) # 可调整调试内容文本框高度
self.Labelerr.grid()
self.eva = Evaluation(self.error)
self.labelimg = tk.Label(root)
self.labelimg.grid(row=2, column=2)
self.prechange()
def prelogin(self):
self.thread = threading.Thread(target=self.login)
self.thread.setDaemon(True)
self.thread.start() # 调用evaluation是超长时间任务,界面会假死，所以开个新进程
def login(self):
self.button1.configure(state='disabled')
self.button2.configure(state='disabled')
user = self.username.get()
password = self.password.get()
code = self.code.get()
if self.eva.login(user, password, code): # 传入文本框中三个参数
self.eva.evaluate()
self.change()
self.button1.configure(state='normal')
self.button2.configure(state='normal')
def prechange(self):
self.thread = threading.Thread(target=self.change)
self.thread.setDaemon(True)
self.thread.start()
def change(self):
self.button1.configure(state='disabled')
self.button2.configure(state='disabled')
tk_image = self.eva.get_login_img()
self.labelimg.configure(image=tk_image)
self.labelimg.image = tk_image
self.button1.configure(state='normal')
self.button2.configure(state='normal')
class Model(object):
# 模型名称
name = "abstract" # type: str
# 模型参数K
param = {}
# 简单描述
description = "模型的简单介绍" # type: str
# 使用的特征列表
feature_names = []
train_x = None # type: pd.Dataframe
train_y = None # type: np.ndarray
train_y_pred = None # type: np.ndarray
test_x = None # type: pd.Dataframe
test_y = None # type: np.ndarray
test_y_pred = None # type: np.ndarray
# 评估结果
train_ev = None # type: dict
test_ev = None # type: dict
def __init__(self,
feature: Feature,
evaluation: Evaluation = None,
param=None):
self.feature = feature
self.model = None
# self.train_x = None
# self.train_y = None
# self.test_x = None
# self.test_y = None
self.y_pred = None
self.y_true = None
if evaluation is None:
self.evaluation = Evaluation(model=self)
else:
self.evaluation = evaluation
if isinstance(param, dict):
self.param.update(param)
def select_features(self,
df_x: pd.DataFrame,
feature_list=None) -> pd.DataFrame:
if feature_list is None:
return df_x.filter(regex='^uf_|if_|sf_|kf_', axis=1).copy()
else:
return df_x[feature_list]
def tf_sample(self, df_x: pd.DataFrame, df_y: pd.DataFrame):
"""
调整正负样本比例
:param df_x:
:param df_y:
:return:
"""
se_1 = [i for i in range(len(df_y)) if int(df_y[i]) == 1]
ratio = (1 - df_y.mean()) / df_y.mean()
len_del = len(se_1) * (1 - ratio) * 0
random.shuffle(se_1)
se_1_sub = se_1[:int(len_del)]
df_x = df_x[~df_x.index.isin(se_1_sub)]
df_y = [df_y[i] for i in range(len(df_y)) if i not in se_1_sub]
return df_x, df_y
def fit(self):
raise NotImplemented
def predict(self, x: pd.DataFrame) -> np.ndarray:
raise NotImplemented
def save(self):
raise NotImplemented
def load(self):
raise NotImplemented
def evaluate(self, threshold: float = 0.5):
return self.evaluation.evaluate(y_true=self.y_true,
y_pred=self.y_pred,
threshold=threshold)
def test(self, **kwargs):
"""
评估测试集上的效果
:return:
"""
feature_list = kwargs.get('feature_list', None)
self.test_x = self.select_features(self.feature.features_test,
feature_list)
self.test_y = self.feature.label_test.values
self.test_y_pred = self.predict(self.test_x)
self.test_ev = self.evaluation.evaluate(y_true=self.test_y,
y_pred=self.test_y_pred,
threshold=0.5)
def train(dataset, alpha, A_type, normalize_type, session_type,
pretrained_item_emb, model_type, batch_size, shuffle, item_emb_dim,
hid_dim1, hid_dim2, hid_dim3, lr_emb, lr_gcn, l2_emb, l2_gcn,
epochs):
# init
if dataset == 'LastFM':
# use LastFM dataset
data_obj = LastfmData()
elif dataset == 'Diginetica':
# use Diginetica dataset
data_obj = DigineticaData()
else:
# use yoochoose1_64 dataset
data_obj = YoochooseData(dataset=dataset)
# gpu device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# init A
# A: type=scipy.sparse
A = data_obj.get_decay_adj(
data_obj.d, tail=None,
alpha=alpha) if A_type == 'decay' else data_obj.get_gcn_adj(data_obj.d)
# normalize the adj, type = 'ramdom_walk'(row 1) or type = 'symmetric'
if normalize_type == 'random_walk':
print('----------------------------------')
print('Normalize_type is random_walk:')
A = spmx_1_normalize(A)
print('----------------------------------')
else:
print('----------------------------------')
print('Normalize_type is symmetric:')
A = spmx_sym_normalize(A)
print('----------------------------------')
# transform the adj to a sparse cpu tensor
A = spmx2torch_sparse_tensor(A)
# get cpu tensor: labels
labels = data_obj.get_labels(data_obj.d)
# get cpu tensor: item_idxes
_, _, item_idxes = data_obj.get_indexes()
if session_type == 'session_hot_items':
# get cpu sparse tensor: session adj
session_adj = data_obj.get_session_adj(data_obj.d, alpha=alpha)
else:
# if not use session adj, then session_adj = None
session_adj = None
if session_type == 'session_last_item':
# get cpu LongTensor: session_last_item
session_last_item = data_obj.get_session_last_item(data_obj.d).long()
else:
# if not use session_last_item, then session_last_item = None
session_last_item = None
# get pretrained_item_emb
if pretrained_item_emb == 'True' and alpha != 0.0:
print('----------------------------------')
if dataset == 'yoochoose1_64':
print('Use yoochoose1_64 pretrained item embedding: ' +
'pretrained_emb' + str(alpha) + '.pkl')
pretrained_item_emb = torch.load(
'./yoo1_64_pretrained_item_emb/pretrained_emb' + str(alpha) +
'.pkl')['item_emb.weight']
elif dataset == 'yoochoose1_8':
print('Use yoochoose1_8 pretrained item embedding: ' +
'pretrained_emb' + str(alpha) + '.pkl')
pretrained_item_emb = torch.load(
'./yoo1_8_pretrained_item_emb/pretrained_emb' + str(alpha) +
'.pkl')['item_emb.weight']
elif dataset == 'LastFM':
print('Use LastFM pretrained item embedding: ' + 'pretrained_emb' +
str(alpha) + '.pkl')
pretrained_item_emb = torch.load(
'./lastfm_pretrained_item_emb/pretrained_emb' + str(alpha) +
'.pkl')['item_emb.weight']
else:
print('Use Diginetica pretrained item embedding: ' +
'pretrained_emb' + str(alpha) + '.pkl')
pretrained_item_emb = torch.load(
'./dig_pretrained_item_emb/pretrained_emb' + str(alpha) +
'.pkl')['item_emb.weight']
print('----------------------------------')
else:
print('----------------------------------')
print('Not use pretrained item embedding:')
pretrained_item_emb = None
print('----------------------------------')
# get cpu LongTensor: item_emb_idxes
item_emb_idxes = torch.arange(data_obj.item_size).long()
# transform all tensor to cuda
A = A.to(device)
labels = labels.to(device)
item_idxes = item_idxes.to(device)
item_emb_idxes = item_emb_idxes.to(device)
if session_last_item is not None:
session_last_item = session_last_item.to(device)
if session_adj is not None:
session_adj = session_adj.to(device)
# define the evalution object
evalution5 = Evaluation(k=5)
evalution10 = Evaluation(k=10)
evalution15 = Evaluation(k=15)
evalution20 = Evaluation(k=20)
# define yoochoose data object
trainset = SessionDataset(train_size=data_obj.train_size,
test_size=data_obj.test_size,
train=True,
labels=labels)
trainloader = DataLoader(dataset=trainset,
batch_size=batch_size,
shuffle=shuffle)
testset = SessionDataset(train_size=data_obj.train_size,
test_size=data_obj.test_size,
train=False,
labels=labels)
testloader = DataLoader(dataset=testset,
batch_size=batch_size,
shuffle=False)
# define model, then transform to cuda
if model_type == 'ngcf1_session_hot_items':
# use ngcf1_session_hot_items model:
model = ngcf1_session_hot_items(
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
pretrained_item_emb=pretrained_item_emb)
elif model_type == 'ngcf2_session_hot_items':
# use ngcf2_session_hot_items model:
model = ngcf2_session_hot_items(
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
hid_dim2=hid_dim2,
pretrained_item_emb=pretrained_item_emb)
elif model_type == 'ngcf3_session_hot_items':
# use ngcf3_session_hot_items model:
model = ngcf3_session_hot_items(
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
hid_dim2=hid_dim2,
hid_dim3=hid_dim3,
pretrained_item_emb=pretrained_item_emb)
else:
# use ngcf2_session_last_item model:
model = ngcf2_session_last_item(
item_nums=data_obj.item_size,
item_emb_dim=item_emb_dim,
hid_dim1=hid_dim1,
hid_dim2=hid_dim2,
pretrained_item_emb=pretrained_item_emb)
model.to(device)
# define loss and optim
criterion = nn.CrossEntropyLoss()
if model_type == 'ngcf1_session_hot_items':
# use ngcf1_session_hot_items model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
elif model_type == 'ngcf2_session_hot_items':
# use ngcf2_session_hot_items model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}, {
'params': model.gconv2.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
elif model_type == 'ngcf3_session_hot_items':
# use ngcf3_session_hot_items model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}, {
'params': model.gconv2.parameters()
}, {
'params': model.gconv3.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
else:
# use ngcf2_session_last_item model parameters:
optim_emb = optim.Adagrad([{
'params': model.item_emb.parameters()
}],
lr=lr_emb,
weight_decay=l2_emb)
optim_gcn = optim.Adam([{
'params': model.gconv1.parameters()
}, {
'params': model.gconv2.parameters()
}],
lr=lr_gcn,
weight_decay=l2_gcn)
# figure recall mrr norm
fig_recalls = []
fig_mrrs = []
fig_emb_norms = []
fig_gcn_norms = []
fig_epochs = []
# train epochs
for epoch in range(epochs):
# model training
start = time.time()
# train evalution dict
recall = {'5': [], '10': [], '15': [], '20': []}
mrr = {'5': [], '10': [], '15': [], '20': []}
# test evalution dict
r = {'5': [], '10': [], '15': [], '20': []}
m = {'5': [], '10': [], '15': [], '20': []}
# loss list
losses = []
model.train()
for i, data in enumerate(trainloader):
# zero optim
optim_emb.zero_grad()
optim_gcn.zero_grad()
# batch inputs
batch_idxes, batch_labels = data[0].long().to(
device), data[1].long().to(device)
# predicting
if model_type == 'ngcf1_session_hot_items':
# use ngcf1_session_hot_items model to predict
outs = model(batch_idxes, A, item_idxes, session_adj,
item_emb_idxes)
elif model_type == 'ngcf2_session_hot_items':
# use ngcf2_session_hot_items model to predict
outs = model(batch_idxes, A, item_idxes, session_adj,
item_emb_idxes)
elif model_type == 'ngcf3_session_hot_items':
# use ngcf3_session_hot_items model to predict
outs = model(batch_idxes, A, item_idxes, session_adj,
item_emb_idxes)
else:
# use ngcf2_session_last_item model to predict
outs = model(batch_idxes, A, item_idxes, session_last_item,
item_emb_idxes)
# loss
loss = criterion(outs, batch_labels)
# backward
loss.backward()
# optim step
optim_emb.step()
optim_gcn.step()
# evalution, k=5, 10, 15, 20
recall['5'].append(evalution5.evaluate(outs, batch_labels)[0])
recall['10'].append(evalution10.evaluate(outs, batch_labels)[0])
recall['15'].append(evalution15.evaluate(outs, batch_labels)[0])
recall['20'].append(evalution20.evaluate(outs, batch_labels)[0])
mrr['5'].append(evalution5.evaluate(outs, batch_labels)[1])
mrr['10'].append(evalution10.evaluate(outs, batch_labels)[1])
mrr['15'].append(evalution15.evaluate(outs, batch_labels)[1])
mrr['20'].append(evalution20.evaluate(outs, batch_labels)[1])
# losses
losses.append(loss.item())
# print loss, recall, mrr
if i % 50 == 49:
print('[{0: 2d}, {1:5d}] loss:{2:.4f}'.format(
epoch + 1, i + 1, np.mean(losses)))
print('[recall@5 ]:{0:.4f} [mrr@5 ]:{1:.4f}'.format(
np.mean(recall['5']), np.mean(mrr['5'])))
print('[recall@10]:{0:.4f} [mrr@10]:{1:.4f}'.format(
np.mean(recall['10']), np.mean(mrr['10'])))
print('[recall@15]:{0:.4f} [mrr@15]:{1:.4f}'.format(
np.mean(recall['15']), np.mean(mrr['15'])))
print('[recall@20]:{0:.4f} [mrr@20]:{1:.4f}'.format(
np.mean(recall['20']), np.mean(mrr['20'])))
# print gcn_norm, emb_norm
emb_norm = get_norm(model, 'emb')
gcn_norm = get_norm(model, 'gcn')
fig_emb_norms.append(emb_norm)
fig_gcn_norms.append(gcn_norm)
print('[gcn_norm]:{0:.4f} [emb_norm]:{1:.4f}'.format(
gcn_norm, emb_norm))
# epoch time
print('[epoch time]:{0:.4f}'.format(time.time() - start))
# save model
if epoch % 10 == 9:
torch.save(
model.state_dict(),
'params' + model_type + '-Alpha' + str(alpha) + '_' +
'_lr_emb' + str(lr_emb) + '_l2_emb' + str(l2_emb) + '_lr_gcn' +
str(lr_gcn) + '_l2_gcn' + str(l2_gcn) + '.pkl')
# model eval
model.eval()
with torch.no_grad():
for j, d in enumerate(testloader):
# test batch inputs
b_idxes, b_labels = d[0].long().to(device), d[1].long().to(
device)
# predicting
if model_type == 'ngcf1_session_hot_items':
# use ngcf1_session_hot_items model to predict
o = model(b_idxes, A, item_idxes, session_adj,
item_emb_idxes)
elif model_type == 'ngcf2_session_hot_items':
# use ngcf2_session_hot_items model to predict
o = model(b_idxes, A, item_idxes, session_adj,
item_emb_idxes)
elif model_type == 'ngcf3_session_hot_items':
# use ngcf3_session_hot_items model to predict
o = model(b_idxes, A, item_idxes, session_adj,
item_emb_idxes)
else:
# use ngcf2_session_last_item model to predict
o = model(b_idxes, A, item_idxes, session_last_item,
item_emb_idxes)
# evalution, k=5, 10, 15, 20
r['5'].append(evalution5.evaluate(o, b_labels)[0])
r['10'].append(evalution10.evaluate(o, b_labels)[0])
r['15'].append(evalution15.evaluate(o, b_labels)[0])
r['20'].append(evalution20.evaluate(o, b_labels)[0])
m['5'].append(evalution5.evaluate(o, b_labels)[1])
m['10'].append(evalution10.evaluate(o, b_labels)[1])
m['15'].append(evalution15.evaluate(o, b_labels)[1])
m['20'].append(evalution20.evaluate(o, b_labels)[1])
# print test recall mrr
print('[{0: 2d}]'.format(epoch + 1))
print('[recall@5 ]:{0:.4f} [mrr@5 ]:{1:.4f}'.format(
np.mean(r['5']), np.mean(m['5'])))
print('[recall@10]:{0:.4f} [mrr@10]:{1:.4f}'.format(
np.mean(r['10']), np.mean(m['10'])))
print('[recall@15]:{0:.4f} [mrr@15]:{1:.4f}'.format(
np.mean(r['15']), np.mean(m['15'])))
print('[recall@20]:{0:.4f} [mrr@20]:{1:.4f}'.format(
np.mean(r['20']), np.mean(m['20'])))
# plt recall and mrr and norm
fig_epochs.append(epoch)
fig_recalls.append(np.mean(r['20']))
fig_mrrs.append(np.mean(m['20']))
plt_evalution(fig_epochs,
fig_recalls,
fig_mrrs,
k=20,
alpha=alpha,
lr_emb=lr_emb,
l2_emb=l2_emb,
lr_gcn=lr_gcn,
l2_gcn=l2_gcn,
model_type=model_type)
plt_norm(fig_epochs,
fig_emb_norms,
fig_gcn_norms,
alpha=alpha,
lr_emb=lr_emb,
l2_emb=l2_emb,
lr_gcn=lr_gcn,
l2_gcn=l2_gcn,
model_type=model_type)
class Algoritm:
def __init__(self, repository):
self.__repository = repository
self.__nrOfNodes = int(sqrt(len(repository.getHarta())))
self.__pop = []
self.__fit = []
self.__evalFunc = Evaluation(repository.getHarta(), self.__nrOfNodes)
self.__minFit = 0
self.__nrConsMinFit = 0
self.__lastFit = 0
self.__fitEvol = []
def __initialize(self):
self.__pop.append(Chromozome(self.__nrOfNodes))
self.__pop.append(Chromozome(self.__nrOfNodes))
self.__pop.append(Chromozome(self.__nrOfNodes))
self.__pop.append(Chromozome(self.__nrOfNodes))
def __evaluate(self):
for chromozome in self.__pop:
self.__fit.append(self.__evalFunc.evaluate(chromozome.getRepres()))
chromozome.setFitness(
self.__evalFunc.evaluate(chromozome.getRepres()))
self.__minFit = min(self.__fit)
self.__nrConsMinFit = 1
self.__lastFit = self.__fit[3]
def __selection(self):
fitSum = sum(self.__fit)
proportions = []
roulette = []
aux = 0
for fit in self.__fit:
proportions.append(fit / fitSum)
roulette.append(aux + (fit / fitSum))
aux = aux + (fit / fitSum)
p1 = random.random()
for i in range(4):
if (p1 < roulette[i]):
parent1 = self.__pop[i]
break
parent2 = parent1
while (parent2 == parent1):
p2 = random.random()
for i in range(4):
if (p2 < roulette[i]):
parent2 = self.__pop[i]
break
return parent1, parent2
def __crossover(self, parent1, parent2):
return parent1.crossover(parent2), parent2.crossover(parent1)
def _mutation(self, o1, o2):
return o1.mutation(), o2.mutation()
def __best(self, o1, o2):
if (o1.getFitness() < o2.getFitness()):
return o1
return o2
def __worst(self):
maxFit = max(self.__fit)
for chromo in self.__pop:
if (chromo.getFitness() == maxFit):
return chromo
def __getFinalResult(self):
for i in range(len(self.__fit)):
if (self.__fit[i] == self.__minFit):
return (self.__pop[i])
def __writeToFile(self, result):
reprResult = result.getRepres()
f = (self.__repository.getFileNameIn().split(".txt"))[0]
f = open(f + "_solution.txt", "w")
f.write(str(len(reprResult)))
f.write('\n')
f.write(str(reprResult[0]))
for i in range(1, len(reprResult)):
f.write("," + str(reprResult[i]))
f.write('\n')
f.write(str(self.__fitEvol[0]))
for i in range(1, len(self.__fitEvol)):
f.write("," + str(self.__fitEvol[i]))
f.write('\n')
f.write(str(result.getFitness()))
def execute(self):
#initialize
self.__initialize()
self.__evaluate()
self.__fitEvol.append(self.__minFit)
while (self.__nrConsMinFit < 300):
for i in range(4):
#selection
selection = self.__selection()
parent1 = selection[0]
parent2 = selection[1]
#crossover
crossover = self.__crossover(parent1, parent2)
o1 = crossover[0]
o2 = crossover[1]
#mutation
mutation = self._mutation(o1, o2)
o1 = mutation[0]
o2 = mutation[1]
#evaluation
fit1 = self.__evalFunc.evaluate(o1.getRepres())
o1.setFitness(fit1)
fit2 = self.__evalFunc.evaluate(o2.getRepres())
o2.setFitness(fit2)
#modify generation
b = self.__best(o1, o2)
w = self.__worst()
self.__pop.remove(w)
self.__fit.remove(w.getFitness())
self.__pop.append(b)
self.__fit.append(b.getFitness())
self.__minFit = min(self.__fit)
if (self.__fitEvol[len(self.__fitEvol) - 1] == self.__minFit):
self.__nrConsMinFit += 1
else:
self.__nrConsMinFit = 1
self.__fitEvol.append(self.__minFit)
# self.__lastFit=b.getFitness()
self.__writeToFile(self.__getFinalResult())
h[1][0, j] = hc[1]
else:
h[0, j] = h0_strategy.on_reset(active_users[0][j])
x = x.squeeze().to(setting.device)
t = t.squeeze().to(setting.device)
s = s.squeeze().to(setting.device)
y = y.squeeze().to(setting.device)
y_t = y_t.squeeze().to(setting.device)
y_s = y_s.squeeze().to(setting.device)
active_users = active_users.to(setting.device)
optimizer.zero_grad()
loss, h = trainer.loss(x, t, s, y, y_t, y_s, h, active_users)
loss.backward(retain_graph=True)
losses.append(loss.item())
optimizer.step()
# schedule learning rate:
scheduler.step()
# statistics:
if (e+1) % 1 == 0:
epoch_loss = np.mean(losses)
print(f'Epoch: {e+1}/{setting.epochs}')
print(f'Used learning rate: {scheduler.get_lr()[0]}')
print(f'Avg Loss: {epoch_loss}')
if (e+1) % setting.validate_epoch == 0:
print(f'~~~ Test Set Evaluation (Epoch: {e+1}) ~~~')
evaluation_test.evaluate()
class L(threading.Thread):
totalCount = 0
#Initialize all the components#
def __init__(self, id, nr):
self.domain = Domain()
self.phrasebase = Phrasebase()
self.parsing = Parsing()
self.evaluation = Evaluation(self.domain.getTopics(),
self.domain.getPraise(),
self.domain.getCriticism())
super(L, self).__init__()
self.ui = UI(nr)
self.id = id
L.totalCount += 1
self.displayCount()
self.running = True
def getUI(self):
return self.ui
#main method, organize the whole structure of the dialogue#
def run(self):
#setup
self.parsing.setui(self.ui)
warnings.filterwarnings(module='sklearn*',
action='ignore',
category=DeprecationWarning)
#introductory greeting of the user, general explanations and so on
self.intro()
#getting stories to ask
total_number = 6
stories = self.organizeStories(total_number)
#main loop for asking all stories
for story in stories:
self.askStory(story)
#get the evaluation and tell it to the user
eval = self.evaluation.evaluate()
for e in eval:
self.ui.tell(e)
#say goodbye
self.goodbye()
#just for keeping track of how many lizas there are
def displayCount(self):
print(
"I am the %d. Liza started here since the last restart of the program."
% L.totalCount)
#display a final goodbye message, and then a "system message" stating the liza has disconnected.
def goodbye(self):
self.ui.tell("Goodbye!")
self.ui.info("Liza has disconnected.")
sys.exit()
#For asking if the user wants to take a break
def askbreak(self):
self.ui.tell("Do you want to continue with this?")
answer = self.ui.listen()
if (answer == ""):
self.ui.tell(
"Do you want to continue? If you don't reply, I have to assume that you are gone..."
)
answer = self.ui.listen()
if (answer == ""):
self.ui.tell("Well, okay... I guess we can't continue then.")
self.goodbye()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay, great! So let's return to the questions.")
return True
self.ui.tell("Oh. I am sorry.")
self.goodbye()
#for asking a question and continuing until we finally got an answer
def askForever(self, question):
answer = ""
time = 0
self.ui.tell(question)
self.ui.prompt()
while True:
time = time + 1
answer = self.ui.listen()
if answer == "" and time < 4:
self.ui.tell(self.phrasebase.getReply("waiting"))
self.ui.prompt()
if answer == "" and time >= 4 and time < 7:
self.ui.tell(self.phrasebase.getReply("worried_waiting"))
self.ui.prompt()
if time >= 7 and time < 10:
continue
if time >= 10:
self.ui.tell(
"It seems that you are a bit distracted right now. Or maybe dead. ... ...I hope you are not dead. But because it's been a while since your last answer..."
)
self.ui.prompt()
self.askbreak()
time = 0
self.ui.tell("So my question was: " + question)
if answer != "":
return answer
def askStory(self, story):
#if story type is already explained, go on
#otherwise, explain
if not self.domain.getExplained(story.group):
self.ui.tell(self.phrasebase.getReply("new_topic"))
self.ui.tell(self.domain.groups[story.group])
answer = self.askForever(
self.phrasebase.getReply("want_topic_explanation"))
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(self.domain.getExplanation(story.group))
self.domain.setExplained(story.group)
self.ui.tell("Now let's get to the question!")
if meaning == "no":
self.ui.tell("Ok, then let's get right to the question.")
else:
self.ui.tell("Oh, I really like to explain things.")
self.ui.tell(self.domain.getExplanation(story.group))
self.domain.setExplained(story.group)
self.ui.tell("Now let's get to the question!")
if (len(story.intro) > 0):
answer = self.askForever(story.intro)
meaning = self.parsing.parse(answer)
if "yes" in meaning:
self.ui.tell(story.introyes)
elif "no" in meaning:
self.ui.tell(story.introno)
else:
self.ui.tell(self.phrasebase.getReply("meaninglesses"))
self.ui.tell(story.text)
self.ui.tell(story.question)
answer = self.ui.listenLong()
if answer == "" or answer == None:
print("seems like they don't know the answer...")
self.ui.tell(self.phrasebase.getReply("offer_hint"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
#print(answer)
#print(meaning)
if meaning == "yes":
self.ui.tell(story.hint)
self.ui.prompt()
if meaning == "no":
self.ui.tell("ok!")
meaning = self.parsing.parse(answer)
if not meaning == "correct" or meaning == "incorrect":
answer = self.askForever(
self.phrasebase.getReply("introbla") + story.question)
#print(answer)
meaning = self.parsing.parseQuiz(answer, story)
#print(meaning)
if meaning == "whatquestion":
self.ui.tell("The question was: " + story.question)
# if meaning == "hint":
# self.ui.tell(story.hint)
# answer = askForever(self.phrasebase.getReply("introbla") + story.question)
if meaning == "explain":
self.ui.tell(self.phrasebase.getReply("offer_explanation"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(story.explain)
#explained the answer
#student model: didn't know the answer
return
if meaning == "no":
self.ui.tell("ok!")
answer = self.askForever(
self.phrasebase.getReply("introbla") + story.question)
meaning = self.parsing.parse(answer)
if meaning == "correct":
if (randint(0, 1) > 0):
self.askCalibration(True)
self.ui.tell(
story.answercorrect
) #you could also use self.phrasebase.getReply("correct")
self.evaluation.answer(story, True)
#student model: knew the answer
elif meaning == "incorrect":
if (randint(0, 1) > 0):
self.askCalibration(False)
self.evaluation.answer(story, False)
self.ui.tell(
story.answerincorrect
) #you could also use self.phrasebase.getReply("incorrect")
self.ui.tell(self.phrasebase.getReply("offer_explanation"))
self.ui.prompt()
answer = self.ui.listen()
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell(story.explain)
return
def askCalibration(self, correctness):
self.ui.tell(self.phrasebase.getReply("howsure"))
answer = self.ui.listen()
percent = self.parsing.parsePercent(answer)
self.evaluation.calibrate(correctness, percent)
def organizeStories(self, total):
storylist = []
topic = 0
for i in range(0, total):
topic = topic % len(self.domain.getTopics())
story = self.domain.getStory(topic)
storylist.append(story)
topic = topic + 1
return storylist
def intro(self):
#the bot introduces itself
answer = self.askForever(self.phrasebase.getReply("greetings"))
meaning = self.parsing.parse(answer)
#print(meaning)
if "greet" in meaning or "yes" in meaning:
self.ui.tell("Nice to meet you!")
answer = self.askForever("You are a human, aren't you?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Great! This means you can help me.")
if meaning == "no":
answer = self.askForever(
"Are you sure? What is the sum of two and three?")
meaning = self.parsing.parse(answer)
if meaning == "five":
self.ui.tell(
"See, you solved the captcha. You are sufficiently human for my purposes."
)
else:
self.ui.tell("Very funny. You are definitely human.")
self.ui.tell(
"My programmers want me to teach you how to be rational, make good decisions and judge situations correctly."
)
answer = self.askForever("Do you want to be more rational?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Yeah, that's the spirit!")
if meaning == "no":
answer = self.askForever(
"Why would you think that? Rationality is just the ability to make good decisions. Do you want to be able to make good decisions?"
)
meaning = self.parsing.parse(answer)
if meaning == "no":
self.askbreak()
self.ui.tell(
"I will just try to ask you some questions, and try to explain to you what you could do better. If I do a bad job at explaning, just ask me, ok? I never taught humans before."
)
self.ui.tell(
"So, let's see... the first thing I want you to know is that you don't have to be extremely intelligent to be rational. There are very intelligent people who do things that are not at all reasonable. The key to rational decisions is to know when not to follow your gut feelings, but to stop and actually think about the problem."
)
answer = self.askForever(
"To get used to the whole situation - how about I ask you a test question? Just to make sure I am doing this teaching thing right. "
)
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay, thank you!")
if meaning == "no":
self.ui.tell("I would nevertheless like to ask the test question.")
answer = self.askForever(
"This is my first question: Do people need to follow their gut feelings to make rational decisions?"
)
meaning = self.parsing.parse(answer)
if meaning == "no":
self.ui.tell(
"Amazing! I mean, it was easy, I know, but you did it. Very reasonable of you to say this! Now we can start with the actual teaching."
)
if meaning == "yes":
self.ui.tell(
"Uhm... no. This is a bit awkward. Following you gut feelings means not to think about something, but just go with what feels right. A lot of psychologists have shown that people tend to make a lot of mistakes when they make decisions that way."
)
answer = self.askForever("Do you still want to continue?")
meaning = self.parsing.parse(answer)
if meaning == "yes":
self.ui.tell("Okay! Let's start with the actual teaching!")
else:
self.askbreak()
