def check_bounds(self):
min_x = 0
min_y = 0
max_x = 1000 - self.image.width
max_y = config.upper_y_bound - self.image.height
if self.is_ball:
if self.x < min_x:
util.score(self, 1)
elif self.x > max_x:
util.score(self, 2)
if self.y < min_y:
self.v_y = self.v_y * -1
self.y = min_y
elif self.y > max_y:
self.v_y = self.v_y * -1
self.y = max_y
else:
if self.x < min_x:
self.x = min_x
elif self.x > max_x:
self.x = max_x
if self.y < min_y:
self.y = min_y
elif self.y > max_y:
self.y = max_y
def teamScores(self):
# player who called gameType
playerTeam = {
"players": [self.gameType["player"]],
"breakdown": [], # ["bonus", amount]
"cardsWon": [],
}
# and his (potential) teammate
if "with" in self.gameType and self.gameType["with"] != -1:
playerTeam["players"].append(self.gameType["with"])
# opposing team: everyone else
opposingTeam = {
"players": [
i for i in range(len(self.players))
if i not in playerTeam["players"]
],
"breakdown": [],
"cardsWon": [],
}
self.info("Teams: " + str(playerTeam["players"]) + " vs " +
str(opposingTeam["players"]))
# cards won by either team
for i, p in enumerate(self.players):
if i in playerTeam["players"]:
playerTeam["breakdown"] += [[
"player_" + p["name"],
score(p["cardsWon"])
]]
playerTeam["cardsWon"] += p["cardsWon"]
else:
opposingTeam["breakdown"] += [[
"player_" + p["name"],
score(p["cardsWon"])
]]
opposingTeam["cardsWon"] += p["cardsWon"]
# add talon cards
talonFlat = self.talon
if type(talonFlat[0]) == list:
talonFlat = [c for pack in self.talon for c in pack]
if "king" in self.gameType and len(playerTeam) == 1:
if self.gameType["king"] in self.players[playerTeam[0]]["cardsWon"]:
# if player played alone and won the called king, add talon to his card pile
playerTeam["breakdown"] += [["Talon", score(talonFlat)]]
playerTeam["cardsWon"] += talonFlat
else:
# in every other case, add it to opposing team
opposingTeam["breakdown"] += [["Talon", score(talonFlat)]]
opposingTeam["cardsWon"] += talonFlat
# handle other contracts
addBonus([playerTeam, opposingTeam], self.players)
return [playerTeam, opposingTeam]
def test(theta, data, alphabet, print_tags, print_score):
predictions = predict(theta, data, alphabet)
if print_tags:
for word in predictions:
print ''.join(word)
if print_score:
print score(predictions, data)
def test(theta, data, alphabet, print_tags, print_score): predictions = predict(theta, data, alphabet) if print_tags: for word in predictions: print ''.join(word) if print_score: print score(predictions, data)
def normalScores(self):
return [{
"players": [i],
"cardsWon": p["cardsWon"],
"breakdown": [["player_" + p["name"],
score(p["cardsWon"])]],
} for i, p in enumerate(self.players)]
def from_seqrecord(cls, sr, featuretype='CDS', name=None):
if not name:
name = sr.name
CDS = [f for f in sr.features if f.type == featuretype]
_data = pd.DataFrame(np.zeros((len(CDS), 64), dtype=int),
columns = util.list_codons())
_second_order = pd.DataFrame(np.zeros((64,64), dtype=int),
index = util.list_codons(),
columns = util.list_codons())
_scores = pd.DataFrame(np.zeros((len(CDS), 2)),
columns = ['first', 'second',])
_seqs = [util._extract(sr, cds) for cds in CDS]
for i,seq in enumerate(_seqs):
_data.loc[i,:] = util.get_bias(seq)
util.add_second_order(_second_order, seq)
#calculate scores
_nd = util.normalise(_data.sum(0))
_nso= util.so_normalise(_second_order)
for i,seq in enumerate(_seqs):
_scores.at[i,'first'] = util.score(_nd, seq)
_scores.at[i,'second'] = util.so_score(_nso, seq)
return cls(name, _data, _second_order, _scores, _nd, _nso)
def test():
from args import conf
parser = argparse.ArgumentParser()
parser.add_argument('--baseline', required=True)
args = parser.parse_args()
# set random seed
random.seed(conf.seed)
torch.manual_seed(conf.seed)
if conf.cuda:
torch.cuda.manual_seed(conf.seed)
train, dev_x, dev_y, embedding, conf = load_data(conf)
checkpoint = torch.load(args.baseline)
# opt = checkpoint['config']
model = DocReaderModel(vars(conf), embedding, checkpoint['state_dict'])
model.cuda()
dev_batches = BatchGen(
dev_x, batch_size=conf.batch_size,
pos_size=conf.pos_size, ner_size=conf.ner_size,
gpu=conf.cuda, evaluation=True)
predictions = []
for batch in dev_batches:
predictions.extend(model.predict(batch))
em, f1 = score(predictions, dev_y)
print(em, f1)
def optimize(self, f, maximize=True, pmap=map):
@functools.wraps(f)
def evaluate(d):
return f(**d)
if maximize:
fit = 1.0
else:
fit = -1.0
pop = [self.generate() for _ in range(self.num_particles)]
best = None
for g in range(self.num_generations):
fitnesses = pmap(evaluate, list(map(self.particle2dict, pop)))
for part, fitness in zip(pop, fitnesses):
part.fitness = fit * util.score(fitness)
if not part.best or part.best_fitness < part.fitness:
part.best = part.position
part.best_fitness = part.fitness
if not best or best.fitness < part.fitness:
best = part.clone()
for part in pop:
self.updateParticle(part, best, self.phi1, self.phi2)
return dict([(k, v)
for k, v in zip(self.bounds.keys(), best.position)]), None
def predict(trainx, trainy, testx):
scorer = skmet.make_scorer(util.score)
#best_score = np.Inf
#for degree in range(5):
#polynomial_features = skpre.PolynomialFeatures(degree)
#transx = polynomial_features.fit_transform(trainx)
#for alphaLoc in np.linspace(100*(degree-1),100*(degree+1),num=101):
#regressor = sklin.Ridge(alpha=alphaLoc)
#scores = skcv.cross_val_score(regressor, transx, trainy, scoring=scorer, cv=5)
#print('C-V score for degree=',degree,'and alpha=',alphaLoc,'is', np.mean(scores), '+/-',np.std(scores))
#if np.mean(scores)<best_score:
#best_score = np.mean(scores)
#best_std = np.std(scores)
#best_degree = degree
#best_alpha = alphaLoc
#print('C-V score for degree=',degree,'and alpha=',best_alpha,'is', best_score, '+/-',best_std)
##print(regressor.alphas)
##print(' alpha=',regressor.alpha_,'was used.')
##clf = sklin.RidgeCV( scoring=scorer, alphas=np.linspace(0, 5), normalize=False, cv=10)
#polynomial_features = skpre.PolynomialFeatures(best_degree)
polynomial_features = skpre.PolynomialFeatures(3)
transx = polynomial_features.fit_transform(trainx)
transx_test = polynomial_features.fit_transform(testx)
#regressor = sklin.Ridge(alpha=best_alpha)
regressor = sklin.Ridge(alpha=260)
regressor.fit(transx,trainy)
testy = regressor.predict(transx_test)
print("On the training set, RMSE of the model is ",util.score(trainy,regressor.predict(transx)))
# print("The used degree is ", best_degree)
return testy
def klopScores(self):
assert self.gameType["name"] == "klop"
return [{
"players": [i],
"cardsWon": p["cardsWon"],
"breakdown": [["klop", -score(p["cardsWon"])]],
} for i, p in enumerate(self.players)]
def solve(input_path):
f = open(input_path)
player1, player2 = util.parse(f)
winner_number = util.play_part2_game(player1, player2, 0)
winner = player1
if winner_number == 2:
winner = player2
return util.score(winner)
def on_epoch_end(self, callback_data, model, epoch):
preds = model.get_outputs(self.eval_set)[:, 1]
idx_file = os.path.join(
self.data_dir,
'eval-' + str(self.subj) + '-' + str(0) + '-index.csv')
labels = np.loadtxt(idx_file, delimiter=',', skiprows=1, usecols=[1])
logger.display('Eval AUC for subject %d epoch %d: %.4f\n' %
(self.subj, epoch, score(labels, preds)))
def solve(input_path):
f = open(input_path)
player1, player2 = util.parse(f)
while (player1 and player2):
util.play_round(player1, player2)
winner = player1
if player2:
winner = player2
return util.score(winner)
def evaluate(self, input_df, output_df):
print(' Setting up data')
input_df, numeric_input_df, output_df = self.setup_data(
input_df, output_df)
self.setup_additional_output_data(input_df)
print(' Fitting model')
i = self.input_scaler.transform(numeric_input_df.values)
ref_output = output_df.values
o = self.model.predict(i)
#test_output = self.output_scaler.inverse_transform(o[0])
test_output = self.output_scaler.inverse_transform(o)
print(' Evaluating model')
return test_output, score(input_df, ref_output, test_output)
def evaluate(self, input_df, output_df):
if self.verbose:
print(' Setting up data')
input_df, numeric_input_df, output_df = self.setup_data(
input_df, output_df)
if self.verbose:
print(' Fitting model')
ref_output = output_df.values.flatten(
) if self.flatten_output else output_df.values.reshape(
(len(output_df), 1))
test_output = self.model.predict(numeric_input_df.values)
if self.verbose:
print(' Evaluating model')
return test_output, score(input_df, ref_output, test_output)
def predict(trainx, trainy, testx):
scorer = skmet.make_scorer(util.score)
best_score = np.Inf
for alphaLoc in np.linspace(0,100,101):
regressor = sklin.Ridge(alpha=alphaLoc,fit_intercept=True)
scores = skcv.cross_val_score(regressor, trainx, trainy, scoring=scorer, cv=10)
if np.mean(scores)<best_score:
best_score = np.mean(scores)
best_alpha = alphaLoc;
print('C-V score for alpha=',alphaLoc,'is', np.mean(scores), '+/-', np.std(scores))
#clf = sklin.RidgeCV( scoring=scorer, alphas=np.linspace(0, 5), normalize=False, cv=10)
regressor = sklin.Ridge(alpha=best_alpha)
regressor.fit(trainx,trainy)
testy = regressor.predict(testx)
print("On the training set, RMSE of the model is ",util.score(trainy,regressor.predict(trainx)))
print("The used alpha is ", regressor.alpha)
return testy
def addfinalScore(self, s):
if self.gameType["name"] == "klop":
for team in s:
team["finalScore"] = sumScores(team)
return s
for team in s:
if self.gameType["player"] in team["players"]:
# player's team
if score(team["cardsWon"]) > 0:
# completed the game
team["finalScore"] = valueOfGameType(
self.gameType) + contractBonus(team)
else:
# did not complete the game
team["finalScore"] = -valueOfGameType(self.gameType)
else:
# opposing team
team["finalScore"] = 0
# TODO: radlc multiplier
return s
predictions = map(Prediction.parse, args.predicted)
assert len(golden) == len(golden_loc)
#assert len(golden) == len(predictions)
if len(predictions) < len(golden):
n = len(predictions)
golden = golden[:n]
golden_loc = golden_loc[:n]
print "Generating sentences with removed word"
removed = map(tokenize_words, golden)
removed = [
remove_word(words, loc) for words, loc in izip(removed, golden_loc)
]
orig = [' '.join(words) for words in removed]
s = score(golden, orig)
print "Score if no predictions are inserted: %s" % s
best = None
best_score = s
loc_thresholds = np.linspace(0, 1, 21)
word_thresholds = np.linspace(0, 1, 21)
loss_surface = np.zeros((len(loc_thresholds), len(word_thresholds)))
for i, loc_threshold in enumerate(loc_thresholds):
for j, word_threshold in enumerate(word_thresholds):
print "loc_threshold=%s, word_threshold=%s:" \
% (loc_threshold, word_threshold)
predicted = []
for words, p in izip(removed, predictions):
if p.location_posterior > loc_threshold:
if p.word_posterior > word_threshold: # insert predicted word
def predict(trainx, trainy, testx):
clf.fit(trainx,trainy)
testy = clf.predict(testx)
print("On the training set, RMSE of the model is ",util.score(trainy,clf.predict(trainx)))
return testy
import util
import numpy as np
data_path = "../game_data"
data = util.load_data(data_path)
raw_sensitivities = []
raw_specificities = []
filtered_sensitivities = []
filtered_specificities = []
for sample in data:
print((data[sample]))
gold_circles = util.get_gold(data[sample]["out_path"])
if gold_circles is not None:
raw_score = util.score(gold_circles, data[sample]["raw-circles"])
raw_sensitivities.append(raw_score[0])
raw_specificities.append(raw_score[1])
try:
filtered_score = util.score(gold_circles,
data[sample]["filtered-circles"])
filtered_sensitivities.append(filtered_score[0])
filtered_specificities.append(filtered_score[1])
except ZeroDivisionError as e:
print(sample, "does not have filtered circles")
print(("raw sensitivity mean {} std {}".format(np.mean(raw_sensitivities),
np.std(raw_sensitivities))))
print(("raw specificity mean {} std {}".format(np.mean(raw_specificities),
def main():
from args import args
# parser = argparse.ArgumentParser()
# parser.add_argument('--model', required=True)
# parser.add_argument('--train', required=True)
# parser.add_argument('--dev', required=True)
# args.load_model_dir = parser.parse_args().model
# args.ent_train_dir = parser.parse_args().train
# args.ent_dev_dir = parser.parse_args().dev
args.load_model_dir = '/scratch0/shifeng/rawr/drqa/original.pt'
args.ent_train_dir = 'results/20180217T172242.135276/train.pkl'
args.ent_dev_dir = 'pkls/original.rawr.dev.pkl'
args.other_train_dir = 'results/targeted_train_all.pkl'
out_dir = prepare_output_dir(args, '/scratch0/shifeng/rawr/drqa/')
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
fh = logging.FileHandler(os.path.join(out_dir, 'output.log'))
fh.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
log.addHandler(fh)
log.addHandler(ch)
log.info('===== {} ====='.format(out_dir))
with open(os.path.join(out_dir, 'args.pkl'), 'wb') as f:
pickle.dump(args, f)
random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
log.info('loading regular data from {}'.format(args.data_file))
train_reg, dev_reg, dev_y, embedding, opt = load_data(args)
log.info('{} regular training examples'.format(len(train_reg)))
log.info('{} regular dev examples'.format(len(dev_reg)))
# log.info(opt)
''' load data for regularization '''
log.info('loading entropy training data from {}'.format(args.ent_train_dir))
with open(args.ent_train_dir, 'rb') as f:
train_ent = pickle.load(f)
if isinstance(train_ent, dict) and 'reduced' in train_ent:
train_ent = train_ent['reduced']
if isinstance(train_ent[0][0], list):
train_ent = list(itertools.chain(*train_ent))
log.info('loading targeted training data from {}'.format(args.other_train_dir))
with open(args.other_train_dir, 'rb') as f:
other_train_ent = pickle.load(f)
if isinstance(other_train_ent, dict) and 'reduced' in train_ent:
other_train_ent = other_train_ent['reduced']
if isinstance(other_train_ent[0][0], list):
other_train_ent = list(itertools.chain(*other_train_ent))
train_ent += other_train_ent
if args.filter_long > 0:
train_ent = [x for x in train_ent if len(x[5]) < args.filter_long]
log.info('loading entropy dev data from {}'.format(args.ent_train_dir))
with open(args.ent_dev_dir, 'rb') as f:
dev_ent = pickle.load(f)['reduced']
if isinstance(dev_ent[0], list):
# dev_ent = list(itertools.chain(*dev_ent))
dev_ent = [x[0] for x in dev_ent]
# if args.filter_long > 0:
# dev_ent = [x for x in dev_ent if len(x[5]) > args.filter_long]
log.info('{} entropy training examples'.format(len(train_ent)))
log.info('{} entropy dev examples'.format(len(dev_ent)))
log.info('loading model from {}'.format(args.load_model_dir))
checkpoint = torch.load(args.load_model_dir)
# opt = checkpoint['config']
state_dict = checkpoint['state_dict']
model = DocReaderModel(vars(opt), embedding, state_dict)
model.cuda()
''' initial evaluation '''
dev_reg_batches = BatchGen(
dev_reg, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size,
evaluation=True, gpu=args.cuda)
dev_ent_batches = BatchGen(
dev_ent, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size,
evaluation=True, gpu=args.cuda)
predictions = []
for batch in dev_reg_batches:
predictions.extend(model.predict(batch))
em, f1 = score(predictions, dev_y)
ents, predictions_r = [], []
for batch in dev_ent_batches:
p, _, ss, se, _, _ = model.predict(batch, get_all=True)
ss = ss.cpu().numpy()
se = se.cpu().numpy()
ents.append(scipy.stats.entropy(ss.T).sum() + \
scipy.stats.entropy(se.T).sum())
predictions_r.extend(p)
ent = sum(ents) / len(ents)
em_r, f1_r = score(predictions_r, dev_y)
log.info("[dev EM: {:.5f} F1: {:.5f} Ent: {:.5f}]".format(em, f1, ent))
log.info("[dev EMR: {:.5f} F1R: {:.5f}]".format(em_r, f1_r))
best_f1_score = f1
''' interleaved training '''
train_ent_batches = BatchGen(
train_ent, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size, gpu=args.cuda)
len_train_ent_batches = len(train_ent_batches)
train_ent_batches = iter(train_ent_batches)
n_reg = 0
n_ent = 0
for epoch in range(args.epochs):
log.warning('Epoch {}'.format(epoch))
train_reg_batches = BatchGen(
train_reg, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size, gpu=args.cuda)
start = datetime.now()
for i_reg, reg_batch in enumerate(train_reg_batches):
model.update(reg_batch)
n_reg += 1
if n_reg > args.start_ent:
if i_reg % args.n_reg_per_ent == 0:
for j in range(args.n_ent_per_reg):
try:
model.update_entropy(next(train_ent_batches),
gamma=args.gamma)
n_ent += 1
except StopIteration:
n_ent = 0
train_ent_batches = iter(BatchGen(
train_ent, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size,
gpu=args.cuda))
if n_reg % args.n_report == 0:
log.info('epoch [{:2}] batch [{}, {}] loss[{:.5f}] entropy[{:.5f}]'.format(
epoch, i_reg, n_ent, model.train_loss.avg,
-model.entropy_loss.avg / args.gamma))
# if n_reg % args.n_eval == 0:
dev_reg_batches = BatchGen(
dev_reg, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size,
evaluation=True, gpu=args.cuda)
dev_ent_batches = BatchGen(
dev_ent, batch_size=args.batch_size,
pos_size=args.pos_size, ner_size=args.ner_size,
evaluation=True, gpu=args.cuda)
''' regular evaluation '''
predictions = []
for batch in dev_reg_batches:
predictions.extend(model.predict(batch))
em, f1 = score(predictions, dev_y)
''' entropy evaluation '''
ents, predictions_r = [], []
for batch in dev_ent_batches:
p, _, ss, se, _, _ = model.predict(batch, get_all=True)
ss = ss.cpu().numpy()
se = se.cpu().numpy()
ents.append(scipy.stats.entropy(ss.T).sum() + \
scipy.stats.entropy(se.T).sum())
predictions_r.extend(p)
ent = sum(ents) / len(ents)
em_r, f1_r = score(predictions_r, dev_y)
log.info("dev EM: {:.5f} F1: {:.5f} Ent: {:.5f}".format(em, f1, ent))
log.info("[dev EMR: {:.5f} F1R: {:.5f}]".format(em_r, f1_r))
''' save best model '''
if f1 > best_f1_score:
best_f1_score = f1
model_file = os.path.join(out_dir, 'best_model.pt')
model.save(model_file, epoch)
log.info('[save best model F1: {:.5f}]'.format(best_f1_score))
''' save models '''
model_file = os.path.join(
out_dir, 'checkpoint_epoch_{}.pt'.format(epoch))
model.save(model_file, epoch)
log.info("[save model {}]".format(model_file))
golden_loc = np.asarray(map(int, args.i_removed))
print "Loading predictions"
predictions = map(Prediction.parse, args.predicted)
assert len(golden) == len(golden_loc)
#assert len(golden) == len(predictions)
if len(predictions) < len(golden):
n = len(predictions)
golden = golden[:n]
golden_loc = golden_loc[:n]
print "Generating sentences with removed word"
removed = map(tokenize_words, golden)
removed = [remove_word(words, loc) for words, loc in izip(removed, golden_loc)]
orig = [' '.join(words) for words in removed]
s = score(golden, orig)
print "Score if no predictions are inserted: %s" % s
best = None
best_score = s
loc_thresholds = np.linspace(0, 1, 21)
word_thresholds = np.linspace(0, 1, 21)
loss_surface = np.zeros((len(loc_thresholds), len(word_thresholds)))
for i, loc_threshold in enumerate(loc_thresholds):
for j, word_threshold in enumerate(word_thresholds):
print "loc_threshold=%s, word_threshold=%s:" \
% (loc_threshold, word_threshold)
predicted = []
for words, p in izip(removed, predictions):
if p.location_posterior > loc_threshold:
if p.word_posterior > word_threshold: # insert predicted word
for i, bs in enumerate(BATCH_SIZE):
print("\n ({0} of {1})".format(i + 1, number_of_exp))
config = wv.Config(batch_size=bs)
attrs = vars(config)
config_info = ["%s: %s" % item for item in attrs.items()]
info.append(config_info)
my_model = wv.SkipGramModel(config)
embeddings = wv.run_training(my_model,
my_data,
verbose=False,
visualization=False,
debug=False)
score, report = util.score(index2word,
word2index,
embeddings,
eval_path,
verbose=False,
raw=True)
results.append(score)
print("Score = {}".format(score))
for result in report:
print(result)
BATCH_SIZE = list(BATCH_SIZE)
best_result = max(list(zip(results, BATCH_SIZE, info)))
result_string = """In an experiment with {0} batch sizes
the best size is {1} with score = {2}.
\n INFO = {3}""".format(number_of_exp, best_result[1], best_result[0],
best_result[2])
file = open("batch_size.txt", "w")
# input feature batch, output label batch
ypred = []
for x in X:
ypred.append(single_pred(tree, x))
assert (len(ypred) == len(X)), "output length should be same as input rows"
return ypred
if __name__ == "__main__":
X, y, name = iris['data'], iris['target'], iris['target_names']
# sklearn implementation
clf = DecisionTreeClassifier(criterion='entropy')
clf.fit(X, y)
ypred = clf.predict(X)
acc = score(ypred, y)
print(f'sklearn implementation: acc={acc}')
# self implementation
root = subtree(X, y)
if mode == 'dev':
traverse = [root]
i = 0
while (i < len(traverse)):
if (traverse[i] is None):
i += 1
continue
node = traverse[i]
print(node.cut, '->')
traverse.append(node.left)
def score(self, seq):
return util.score(self._normed, seq)
def individualScores(players):
return [score(p["cardsWon"]) for p in players]
def main():
from args import conf
parser = argparse.ArgumentParser()
parser.add_argument('--resume', default=False)
parser.add_argument('--resume-options', default=False)
args = parser.parse_args()
# set random seed
random.seed(conf.seed)
torch.manual_seed(conf.seed)
if conf.cuda:
torch.cuda.manual_seed(conf.seed)
# setup logger
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
fh = logging.FileHandler('main.log')
fh.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.INFO)
formatter = logging.Formatter(
fmt='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
log.addHandler(fh)
log.addHandler(ch)
train, dev, dev_y, embedding, conf = load_data(conf)
log.info(conf)
log.info('[Data loaded.]')
if args.resume:
log.info('[loading previous model...]')
checkpoint = torch.load(args.resume)
if args.resume_options:
conf = checkpoint['config']
state_dict = checkpoint['state_dict']
model = DocReaderModel(vars(conf), embedding, state_dict)
epoch_0 = checkpoint['epoch'] + 1
for i in range(checkpoint['epoch']):
random.shuffle(list(range(len(train)))) # synchronize random seed
if conf.reduce_lr:
for param_group in model.optimizer.param_groups:
param_group['lr'] *= conf.lr_decay
log.info('[learning rate reduced by {}]'.format(conf.lr_decay))
else:
model = DocReaderModel(vars(conf), embedding)
epoch_0 = 1
if conf.cuda:
model.cuda()
if args.resume:
batches = BatchGen(
dev, batch_size=conf.batch_size,
pos_size=conf.pos_size, ner_size=conf.ner_size,
gpu=conf.cuda, evaluation=True)
predictions = []
for batch in batches:
predictions.extend(model.predict(batch))
em, f1 = score(predictions, dev_y)
log.info("[dev EM: {} F1: {}]".format(em, f1))
best_val_score = f1
else:
best_val_score = 0.0
for epoch in range(epoch_0, epoch_0 + conf.epochs):
log.warning('Epoch {}'.format(epoch))
# train
batches = BatchGen(
train, batch_size=conf.batch_size,
pos_size=conf.pos_size, ner_size=conf.ner_size,
gpu=conf.cuda)
start = datetime.now()
for i, batch in enumerate(batches):
model.update(batch)
if i % conf.log_per_updates == 0:
log.info('epoch [{0:2}] updates[{1:6}] \
train loss[{2:.5f}] remaining[{3}]'.format(
epoch, model.updates, model.train_loss.avg,
str((datetime.now() - start) / (i + 1) * (len(batches) - i - 1)).split('.')[0]))
# eval
if epoch % conf.eval_per_epoch == 0:
batches = BatchGen(
dev, batch_size=conf.batch_size,
pos_size=conf.pos_size, ner_size=conf.ner_size,
gpu=conf.cuda, evaluation=True)
predictions = []
for batch in batches:
predictions.extend(model.predict(batch))
em, f1 = score(predictions, dev_y)
log.warning("dev EM: {} F1: {}".format(em, f1))
# save
if not conf.save_last_only or epoch == epoch_0 + conf.epochs - 1:
model_file = 'results/baseline_epoch_{}.pt'.format(epoch)
model.save(model_file, epoch)
if f1 > best_val_score:
best_val_score = f1
copyfile(
model_file,
os.path.join('results/baseline.pt'))
log.info('[new best model saved.]')
def contractBonus(team):
return sumScores(team) - score(team["cardsWon"])
