def train(epoch, train_obj, gt_obj, i):
model.train()
epoch_loss = 0
m = len(train_obj) // batch_size
#shuffle training set
batch_loss = 0
for idy in range(m):
train_x, train_y = get_batch(train_obj, gt_obj, batch_size, idy, True)
optimizer.zero_grad()
train_x = train_x.to(device)
train_y = train_y.to(device)
loss = criterion(model(train_x), train_y)
epoch_loss += loss.item()
batch_loss += loss.item()
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
if (idy % 10 == 0):
if (idy > 0):
batch_loss /= 10
print(
"===> Epoch[{}], round[{}]({}/{}): Batch Loss: {:.8f}".format(
epoch, i, idy, m, batch_loss))
batch_loss = 0
if (idy == m - 1):
batch_loss /= (m % 100)
print(
"===> Epoch[{}], round[{}]({}/{}): Batch Loss: {:.8f}".format(
epoch, i, idy, m, batch_loss))
print("===> Epoch {} Complete: Avg. Loss: {:.8f}".format(
epoch, epoch_loss / (m)))
training_loss.append(epoch_loss / (m))
def evaluate(segment, n_batches):
loss_lst_velocity = []
loss_lst_heading = []
for iteration in range(0, n_batches):
images, targets, targets_past = get_batch(128, segment,
num_images_back,
num_targets_forward,
num_targets_back)
images = norm(to_var(torch.from_numpy(images)))
targets = to_var(torch.from_numpy(targets))
targets_past = to_var(torch.from_numpy(targets_past))
pred = predictor(images, targets_past)
loss_v = torch.abs(pred - targets)[:, 0::2].mean()
loss_h = torch.abs(pred - targets)[:, 1::2].mean()
loss_lst_velocity.append(loss_v)
loss_lst_heading.append(loss_h)
return (sum(loss_lst_velocity) /
len(loss_lst_velocity)).data.cpu().numpy().tolist(), (
sum(loss_lst_heading) /
len(loss_lst_heading)).data.cpu().numpy().tolist()
def train_model(training_iterations, batch_size, train_data_file):
accuracy_list, entropy_list = [], []
x_data, y_data = load_train_data(train_data_file, train_with_only_known_age_data)
#print("Length of input data is: ", len(x_data))
start_time = time.time()
saver = tf.train.Saver()
for i in range(training_iterations):
x_batch, y_batch = get_batch(x_data, y_data, batch_size)
training_data = {x: x_batch, y_: y_batch}
accrcy, entropy = sess.run([accuracy, cross_entropy], feed_dict=training_data)
#Backpropagation
sess.run(train_step, feed_dict=training_data)
accuracy_list.append(accrcy)
entropy_list.append(entropy)
# Saving checkpoints to load trained model later
directory = "checkpoints/trained_model"
if not os.path.exists(directory): os.makedirs(directory)
saver.save(sess, directory, global_step=checkpoint_every)
# printing the training performance
if i % 100 == 0:
print("Accuracy after %s training steps is: %s" % (i, accrcy))
print("")
print("Training process is done in time: ", time.time() - start_time, "seconds.")
return accuracy_list, entropy_list
def fill_feed_dict(data_set, input_placeholder, output_placeholder):
[input_images, output_images, input_mask, output_mask] = data_loader.get_batch(batch_size = BATCH_SIZE, image_size = IMAGE_SIZE)
input_images.reshape((BATCH_SIZE, -1))
output_images.reshape((BATCH_SIZE, -1))
input_mask.reshape((BATCH_SIZE, -1))
output_mask.reshape((BATCH_SIZE, -1))
input_vec = np.concatenate((input_images, output_images, input_mask), axis = 1)
# Create the feed_dict for the placeholders filled with the next
# `batch size` examples.
feed_dict = {
input_placeholder: input_vec,
output_placeholder: output_mask,
def test_get_batch_B(self):
d = th.LongTensor([[0, 6, 12, 18],
[1, 7, 13, 19],
[2, 8, 14, 20],
[3, 9, 15, 21],
[4, 10, 16, 22],
[5, 11, 17, 23]])
i = 4
timesteps = 2
xe = th.LongTensor([[4, 10, 16, 22]])
ye = th.LongTensor([[5, 11, 17, 23]])
x, y, _ = dl.get_batch(d, i, timesteps)
self.assertEqual(int(th.all(th.eq(xe, x))), 1)
self.assertEqual(int(th.all(th.eq(ye, y))), 1)
def train_model(training_iterations, batch_size, train_data_file):
accuracy_list, cross_entropy_list = [], []
xs_data, ys_data = load_train_data(train_data_file, True)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for i in range(training_iterations):
x_batch, y_batch = get_batch(xs_data, ys_data, batch_size)
training_data = {x: x_batch, y_: y_batch}
accrcy, s_cross = sess.run([accuracy, cross_entropy],
feed_dict=training_data)
#Backpropagation
sess.run(train_step, feed_dict=training_data)
accuracy_list.append(accrcy)
cross_entropy_list.append(s_cross)
return accuracy_list, cross_entropy_list
def run_training():
train_dir = 'C:/datasets/emnist/train/'
logs_summary_dir = './log/summary/train/'
check_point_path = './log/model/'
train, train_labels = data_loader.get_files(train_dir)
train_batch, train_label_batch = data_loader.get_batch(
train, train_labels, IMG_H, IMG_W, BATCH_SIZE, CAPACITY)
train_logits, _ = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
train_loss = model.losses(train_logits, train_label_batch)
train_op = model.training(train_loss, LEARNING_RATE)
train_acc = model.evaluation(train_logits, train_label_batch)
summery_op = tf.summary.merge_all()
with tf.Session() as sess:
train_writer = tf.summary.FileWriter(logs_summary_dir,
graph=sess.graph,
session=sess)
saver = tf.train.Saver(max_to_keep=1)
if os.path.exists(os.path.join(check_point_path, 'checkpoint')):
saver.restore(sess, tf.train.latest_checkpoint(check_point_path))
else:
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
for step in range(MAX_STEPS):
if coord.should_stop(): break
_, tra_loss, tra_acc = sess.run(
[train_op, train_loss, train_acc])
if step % 50 == 0:
print('The training loss and acc respectively: %.2f %.2f' %
(tra_loss, tra_acc))
summary_total = sess.run(summery_op)
train_writer.add_summary(summary_total, global_step=step)
if step % 2000 == 0 or (step + 1) == MAX_STEPS:
saver.save(sess, check_point_path, global_step=step)
except tf.errors.OutOfRangeError:
print('training done!')
finally:
coord.request_stop()
coord.join(threads)
def train(self):
self.epoch += 1
self.model.train()
total_loss = 0.
start_time = time.time()
number_tokens = len(self.corpus.vocab)
hidden = self.model.init_hidden(self.batch_size)
for batch, i in enumerate(
range(0,
self.train_data.size(0) - 1, self.seq_len)):
data, targets = get_batch(self.train_data, i, seq_len=self.seq_len)
# Starting each batch, we detach the hidden state from how it was previously produced.
# If we didn't, the model would try backpropagating all the way to start of the dataset.
self.model.zero_grad()
hidden = repackage_hidden(hidden)
output, hidden = self.model(data, hidden)
loss = self.criterion(output.view(-1, number_tokens),
targets.long())
loss.backward()
# `clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
self.clip_grad)
for p in self.model.parameters():
p.data.add_(
-self.learning_rate,
p.grad.data) # Is this just Stochastic Gradient Descent?
total_loss += loss.item()
if batch % self.log_interval == 0 and batch > 0:
cur_loss = total_loss / self.log_interval
elapsed = time.time() - start_time
print(
'| epoch {:3d} | {:5d}/{:5d} batches | lr {:02.2f} | ms/batch {:5.2f} | '
'loss {:5.2f} | ppl {:8.2f}'.format(
self.epoch, batch,
len(self.train_data) // self.seq_len,
self.learning_rate, elapsed * 1000 / self.log_interval,
cur_loss, math.exp(cur_loss)))
if self.logging:
self.logger.log_train(self.epoch, batch, cur_loss)
total_loss = 0
start_time = time.time()
def train():
config = load_yaml_config("config.yml")
display_step = config["model"]["display_step"]
evaluate_step = config["model"]["evaluate_step"]
save_step = config["model"]["save_step"]
checkpoint_path = config["model"]["checkpoint_path"]
pickle_path = config["data"]["pickle_path"]
pb_path = config["model"]["pb_path"]
model = TodAutoEncoder(config)
print(model.input_x)
print(model.loss)
with open(pickle_path, "rb") as f:
_ = pickle.load(f)
_, sparse_test = pickle.load(f)
card, sparse = zip(*sparse_test)
test = dense_transform(list(sparse))
sess = get_session()
sess.run(tf.global_variables_initializer())
batch_data = get_batch()
for batch in batch_data:
_, loss_train, step = model.step(sess, batch)
if step % display_step == 0:
print("step: %d => loss: %.4f" % (step, loss_train))
if step % evaluate_step == 0:
_, loss_test, _ = model.step(sess, test)
print("{0:-^30}".format("evaluation loss: %.4f" % loss_test))
print("")
if step % save_step == 0:
model.save(sess, checkpoint_path)
model.save(sess, checkpoint_path)
shutil.rmtree(pb_path, ignore_errors=True)
builder = tf.saved_model.builder.SavedModelBuilder(pb_path)
inputs = {'input_x': tf.saved_model.utils.build_tensor_info(model.input_x)}
outputs = {'output': tf.saved_model.utils.build_tensor_info(model.loss)}
signature = tf.saved_model.signature_def_utils.build_signature_def(
inputs=inputs,
outputs=outputs,
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
builder.add_meta_graph_and_variables(sess, [tag_constants.SERVING], {'my_signature': signature})
builder.save()
def test(self):
self.inputs = data_loader.get_batch(self.config)
self.model_setup()
saver = tf.train.Saver()
print("---TESTING THE RESULTS---")
if self._epoch is None:
self._test_single(saver)
elif self._epoch.isdigit():
self._test_single(saver, epoch=int(self._epoch))
elif ',' in self._epoch:
range_str = list(map(int, str(self._epoch).split(',')))
first_epoch, last_epoch = range_str[:2]
step = range_str[2] if len(range_str) == 3 else 1
self._output_dir = os.path.join(self._output_dir, 'test')
for e in range(first_epoch, last_epoch, step):
self._test_single(saver, e)
else:
raise AttributeError(
'Stop testing. Unexpected epoch description parameter.')
print("---TESTING FINISHED---")
def evaluate(model,
corpus,
criterion,
device,
batch_size=25,
seq_len=35,
set='valid'):
# Turn on evaluation mode which disables dropout.
model.eval()
total_loss = 0.
ntokens = len(corpus.vocab)
data_source = batchify(getattr(corpus, set), batch_size, device)
hidden = model.init_hidden(batch_size)
with torch.no_grad():
for i in range(0, data_source.size(0) - 1, seq_len):
data, targets = get_batch(data_source, i, seq_len=seq_len)
output, hidden = model(data, hidden)
hidden = repackage_hidden(hidden)
output_flat = output.view(-1, ntokens)
total_loss += len(data) * criterion(output_flat,
targets.long()).item()
return total_loss / (len(data_source) - 1)
def test_data_generator():
import tensorflow as tf
from data_loader import get_batch
from glob import glob
batches, num_batches, tot_samples = get_batch(
filenames=glob('games_data/*.csv'), batch_size=3)
print(f'>>>>>>>>>>>>>>> batches: {batches}, num_batches: {num_batches}')
# create a iterator of the correct shape and type
iter = tf.data.Iterator.from_structure(batches.output_types,
batches.output_shapes)
xs = iter.get_next()
train_init_op = iter.make_initializer(batches)
print(f'=============== xs: {xs}')
with tf.Session() as sess:
sess.run(train_init_op)
ops = (xs[0], xs[1], xs[2], xs[3])
_board, _from, _to, _res = sess.run(ops)
print(f'shape of board: {_board.shape}')
print(f'from action: {_from}')
print(f'to action: {_to}')
print(f'result: {_res}')
def main(arguments):
# Get the data we need from the checkpoint
model, corpora = load_model_corpora(arguments.checkpoint)
# load the sentences
word2idx = Word2idx(corpora.vocab)
sentences, lengths = tokenize(arguments.text_file, word2idx)
lengths = np.cumsum([0] + lengths[:-1])
if arguments.nonce:
gold = nonce_gold(arguments.gold_file)
else:
# load the number agreement data, which should be tab sepparated.
gold = pd.read_csv(arguments.gold_file, delimiter='\t',
names=['context','right','wrong','attractors'])
# Get the location of the target verbs.
gold['idx'] = gold['context'] + lengths
# Get the predictions.
model.eval()
sentences = batchify(sentences, 1)
hidden = model.init_hidden(1)
input, _ = get_batch(sentences, 0, len(sentences))
output, hidden = model(input, hidden)
results = gold.apply(lambda x: result_(x, output, word2idx), axis=1)
checkpoint = load_checkpoint(arguments.checkpoint)
return results, checkpoint['valid_loss']
def main():
word2int, int2word = get_vocab()
print("vocabulary loaded")
g = Graph(word2int, int2word, is_training=True)
print("Graph loaded")
saver1 = tf.train.Saver()
sess1 = tf.Session()
saver1.restore(sess1, tf.train.latest_checkpoint(hp.model1_path))
saver2 = tf.train.Saver()
sess2 = tf.Session()
saver2.restore(sess2, tf.train.latest_checkpoint(hp.model2_path))
comments_list = [ #'000333.xlsx',
#'000423.xlsx',
#'000651.xlsx',
#'000858.xlsx',
#'000868.xlsx',
#'002607.xlsx',
#'002739.xlsx', File is not a zip file
'300027.xlsx',
#'600518.xlsx', No such file or directory: './data/101/comments/600518.xlsx'
'600519.xlsx'
]
##
results_list = [ #'000333.txt',
#'000423.txt',
#'000651.txt',
#'000858.txt',
#'000868.txt',
#'002607.txt',
#'002739.txt',
'300027.txt',
#'600518.txt',
'600519.txt'
]
"""
comments_list = ['000662.txt',
'002212.txt',
'002298.txt',
'300168.txt',
'600570.txt',
'600571.txt',
'600588.txt',
'600718.txt',
'601519.txt',
'603881.txt',
]
results_list = ['000662.txt',
'002212.txt',
'002298.txt',
'300168.txt',
'600570.txt',
'600571.txt',
'600588.txt',
'600718.txt',
'601519.txt',
'603881.txt',
]
"""
kk = 1
for (comment_dir, result_dir) in zip(comments_list, results_list):
print(kk, comment_dir)
comment_name = hp.emotion_comments_path + comment_dir
preprocessed_data, date_of_comments = read_unlabeled_stock(
comment_name)
print(preprocessed_data[3])
print(date_of_comments[3])
total = int(len(preprocessed_data) / hp.Sbatch_size)
preprocessed_data = preprocessed_data[:total * hp.Sbatch_size]
date_of_comments = date_of_comments[:total * hp.Sbatch_size]
flags1 = []
flags2 = []
batches_unlabeled = get_batch(preprocessed_data, preprocessed_data,
word2int)
j = 1
for batch_x, _ in batches_unlabeled:
if j % 300 == 0:
print('正在预测：{}/{}'.format(j, total))
pre_flag1 = sess1.run(g.preds, feed_dict={g.x: batch_x})
pre_flag2 = sess2.run(g.preds, feed_dict={g.x: batch_x})
flags1.extend(pre_flag1)
flags2.extend(pre_flag2)
j += 1
pos_num = 0
neg_num = 0
none_num = 0
date2sentimentCount = dict()
for (flag1, flag2, day) in zip(flags1, flags2, date_of_comments):
if day not in date2sentimentCount:
date2sentimentCount[day] = [0, 0, 0] # NONE, POS, NEG
if flag1 == 0:
date2sentimentCount[day][0] += 1 # num_NONE + 1
none_num += 1
else:
if flag2 == 1:
date2sentimentCount[day][1] += 1 #num_POS + 1
pos_num += 1
else:
date2sentimentCount[day][2] += 1 # num_NEG + 1
neg_num += 1
log_sentiment_classify.write(
"{}: stock:{} pos {}, neg {}, total {}\n".format(
datetime.datetime.now().isoformat(), result_dir, pos_num,
neg_num, len(flags1)))
print('开始写入啦！')
with open(os.path.join(hp.new_pos_neg_comments_path, result_dir),
'w') as f:
s = sorted(date2sentimentCount.items(), key=lambda x: x[0])
for (day, num) in s:
#print(day, num)
f.write(str(day))
f.write('\t')
f.write(str(num[0])) # NONE
f.write('\t')
f.write(str(num[1])) # 正
f.write('\t')
f.write(str(num[2])) # 负
f.write('\n')
# TODO: Display checked comments
#logger.info("pos neg for %s" % comment_dir)
kk += 1
def train():
tokenizer = pickle.load(open(tokenizer_path, "rb"))
token2index = tokenizer.word_index
if use_word2vec:
embedding = load_word_embedding(vocab_size, token2index)
lstm = Model(num_layers=num_layers,
seq_length=seq_length,
embedding_size=embedding_size,
vocab_size=vocab_size,
rnn_size=rnn_size,
use_bilstm=use_bilstm,
label_size=label_size,
embedding=embedding if use_word2vec else None)
print("{0:-^40}".format("需要训练的参数"))
for var in tf.trainable_variables():
print(var.name, var.shape)
session_conf = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
sess = tf.Session(config=session_conf)
with sess.as_default():
global_step = tf.Variable(0, name="global_step", trainable=False)
decaylearning_rate = tf.train.exponential_decay(
learning_rate, global_step, 100, 0.99)
optimizer = tf.train.AdamOptimizer(
learning_rate=decaylearning_rate).minimize(lstm.loss,
global_step=global_step)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=1)
sess.run(tf.global_variables_initializer())
merged = tf.summary.merge_all()
shutil.rmtree(summary_path, ignore_errors=True)
writer = tf.summary.FileWriter(summary_path, sess.graph)
def train_step(batch, label):
feed_dict = {
lstm.input_x: batch,
lstm.input_y: label,
lstm.dropout_keep_prob: 0.7
}
_, step, loss, accuracy = sess.run(
[optimizer, global_step, lstm.loss, lstm.accuracy],
feed_dict=feed_dict)
return step, loss, accuracy
def dev_step(batch, label):
feed_dict = {
lstm.input_x: batch,
lstm.input_y: label,
lstm.dropout_keep_prob: 1
}
step, loss, accuracy = sess.run(
[global_step, lstm.loss, lstm.accuracy], feed_dict=feed_dict)
print("{0:-^40}".format("evaluate"))
print("step:{}".format(step), "==>", "loss:%.5f" % loss,
"accuracy:%.5f" % accuracy)
batches = get_batch()
x_dev, y_dev = pickle.load(open(test_path, "rb"))
y_dev = np.array(y_dev).reshape(-1, 1)
print("{0:-^40}".format("模型训练"))
for data in batches:
x_train, y_train = zip(*data)
y_train = np.array(y_train).reshape(-1, 1)
step, loss, accuracy = train_step(x_train, y_train)
current_step = tf.train.global_step(sess, global_step)
result = sess.run(merged,
feed_dict={
lstm.input_x: x_train,
lstm.input_y: y_train,
lstm.dropout_keep_prob: 0.5
})
writer.add_summary(result, current_step)
if current_step % 10 == 0:
print("global step:{}".format(step), "==>", "loss:%.5f" % loss,
"accuracy:%.5f" % accuracy)
if current_step % 500 == 0:
dev_step(x_dev, y_dev)
print("")
dev_step(x_dev, y_dev)
saver.save(sess, cktp_path, global_step=current_step)
shutil.rmtree(pb_path, ignore_errors=True)
builder = tf.saved_model.builder.SavedModelBuilder(pb_path)
inputs = {
'input_x':
tf.saved_model.utils.build_tensor_info(lstm.input_x),
'dropout_keep_prob':
tf.saved_model.utils.build_tensor_info(lstm.dropout_keep_prob)
}
outputs = {
'output': tf.saved_model.utils.build_tensor_info(lstm.probs)
}
signature = tf.saved_model.signature_def_utils.build_signature_def(
inputs=inputs,
outputs=outputs,
method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
builder.add_meta_graph_and_variables(sess, [tag_constants.SERVING],
{'my_signature': signature})
builder.save()
# 获取训练集、验证集、测试集中最大句子的长度
max_length = processing.get_max_length(train_x)
# dev_length = processing.get_max_length(dev_x)
# test_length = processing.get_max_length(test_x)
#
# max_length = max(train_length,dev_length,test_length)
# # print(max_length)
train_x_tensor = data_loader.pad(train_x, word2id, "-pad-",max_length)
train_y_tensor = torch.from_numpy(np.array(train_y))
trainloader = data_loader.get_batch(64,train_x_tensor, train_y_tensor)
# model
cnnModel = CNN.CNNlayer(len(word2id),100,2,[3,4,5],output_size=2)
# poolmodel = CNN.CNN(len(word2id),100,2,[3,4],1)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(cnnModel.parameters(),lr=0.01)
train_loss_plot = []
train_acc_plot = []
x_plot = []
for epoch in range(100): # loop over the dataset multiple times
cnnModel.train()
x_plot.append(epoch+1)
running_loss = 0.0
def test(configuration):
"""
test loop to produce images with multiple models
:param configuration:
:return:
"""
encoder = net.get_trained_encoder(configuration)
decoder = net.get_trained_decoder(configuration)
model_path_list = configuration['model_path_list']
content_images_path = configuration['content_images_path']
style_images_path = configuration['style_images_path']
loader = configuration['loader']
image_saving_path = configuration['image_saving_path']
mode_list = configuration['mode_list']
model_list = [0 for _ in range(len(model_path_list))]
for i in range(len(model_list)):
moment_alignment_model = net.get_moment_alignment_model(
configuration,
moment_mode=mode_list[i],
use_list=True,
list_index=i)
checkpoint = torch.load(model_path_list[i], map_location='cpu')
moment_alignment_model.load_state_dict(checkpoint)
model_list[i] = moment_alignment_model
number_content_images = len(os.listdir(content_images_path))
number_style_images = len(os.listdir(style_images_path))
content_image_files = [
'{}/{}'.format(content_images_path,
sorted(os.listdir(content_images_path))[i])
for i in range(number_content_images)
]
style_image_files = [
'{}/{}'.format(style_images_path,
sorted(os.listdir(style_images_path))[i])
for i in range(number_style_images)
]
for i in range(number_content_images):
for j in range(number_style_images):
print('at image {}'.format(i))
with torch.no_grad():
content_image = data_loader.image_loader(
content_image_files[i], loader)
style_image = data_loader.image_loader(style_image_files[j],
loader)
result_images = [0 for _ in range(len(model_list))]
for k in range(len(model_list)):
content_feature_map_batch_loader = data_loader.get_batch(
encoder(content_image)['r41'], 512)
style_feature_map_batch_loader = data_loader.get_batch(
encoder(style_image)['r41'], 512)
content_feature_map_batch = next(
content_feature_map_batch_loader).to(device)
style_feature_map_batch = next(
style_feature_map_batch_loader).to(device)
style_feature_map_batch_moments = utils.compute_moments_batches(
style_feature_map_batch, last_moment=7)
content_feature_map_batch_moments = utils.compute_moments_batches(
content_feature_map_batch, last_moment=7)
result_images[k] = decoder(model_list[k](
content_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments).view(1, 512, 32, 32))
result_images[k] = result_images[k].squeeze(0)
# save all images in one row
u.save_image(
[
data_loader.imnorm(content_image, None),
data_loader.imnorm(style_image, None)
] + result_images,
'{}/moment_alignment_test_image_A_{}_{}.jpeg'.format(
image_saving_path, i, j),
normalize=False,
scale_each=False,
pad_value=1)
# save all images in two rows
u.save_image(
[
data_loader.imnorm(content_image, None),
data_loader.imnorm(style_image, None)
] + [torch.ones(3, 256, 256)
for _ in range(2)] + result_images,
'{}/moment_alignment_test_image_B_{}_{}.jpeg'.format(
image_saving_path, i, j),
normalize=False,
scale_each=False,
pad_value=1,
nrow=4)
# save all result images in one row
u.save_image(
result_images,
'{}/moment_alignment_test_image_C_{}_{}.jpeg'.format(
image_saving_path, i, j),
normalize=False,
scale_each=False,
pad_value=1)
# save all result images in one row + content image
u.save_image(
[data_loader.imnorm(content_image, None)] + result_images,
'{}/moment_alignment_test_image_D_{}_{}.jpeg'.format(
image_saving_path, i, j),
normalize=False,
scale_each=False,
pad_value=1)
# save all result images in one row + style image
u.save_image(
[data_loader.imnorm(style_image, None)] + result_images,
'{}/moment_alignment_test_image_E_{}_{}.jpeg'.format(
image_saving_path, i, j),
normalize=False,
scale_each=False,
pad_value=1)
loss_lst_velocity.append(loss_v)
loss_lst_heading.append(loss_h)
return (sum(loss_lst_velocity) /
len(loss_lst_velocity)).data.cpu().numpy().tolist(), (
sum(loss_lst_heading) /
len(loss_lst_heading)).data.cpu().numpy().tolist()
if __name__ == "__main__":
for iteration in range(0, 2000):
images, targets, targets_past = get_batch(128, "train",
num_images_back,
num_targets_forward,
num_targets_back)
images = norm(to_var(torch.from_numpy(images)))
targets = to_var(torch.from_numpy(targets))
targets_past = to_var(torch.from_numpy(targets_past))
pred = predictor(images, targets_past)
loss = torch.abs(pred - targets).mean()
predictor.zero_grad()
loss.backward()
optim.step()
if iteration % 100 == 0:
import tensorflow as tf
import data_loader
N_CLASSES = 62
IMG_W = 28
IMG_H = 28
BATCH_SIZE = 32
CAPACITY = 4 * BATCH_SIZE
MAX_STEPS = 10000
eval_log_dir = './log/summary/test/'
eval_dir = 'C:/datasets/emnist/test/'
check_point_path = './log/model/'
eva, eva_labels = data_loader.get_files(eval_dir)
eval_batch, eval_label_batch = data_loader.get_batch(eva, eva_labels, IMG_H,
IMG_W, BATCH_SIZE,
CAPACITY)
eval_logits, _ = model.inference(eval_batch,
BATCH_SIZE,
N_CLASSES,
training=False)
eval_acc = model.evaluation(eval_logits, eval_label_batch)
eval_loss = model.losses(eval_logits, eval_label_batch)
summery_op = tf.summary.merge_all()
def run_testing():
TOTAL_ACC_SUM = 0
TOTAL_LOSS_SUM = 0
with tf.Session() as sess:
eval_writer = tf.summary.FileWriter(eval_log_dir,
def test(configuration):
"""
test loop
:param configuration: the config file
:return:
"""
analytical_ada_in_module = net.AdaptiveInstanceNormalization()
encoder = net.get_trained_encoder(configuration)
decoder = net.get_trained_decoder(configuration)
pretrained_model_path = configuration['pretrained_model_path']
print('loading the moment alignment model from {}'.format(pretrained_model_path))
content_images_path = configuration['content_images_path']
style_images_path = configuration['style_images_path']
loader = configuration['loader']
unloader = configuration['unloader']
image_saving_path = configuration['image_saving_path']
moment_mode = configuration['moment_mode']
moment_alignment_model = net.get_moment_alignment_model(configuration, moment_mode)
print(moment_alignment_model)
checkpoint = torch.load(pretrained_model_path, map_location=device)
moment_alignment_model.load_state_dict(checkpoint)
aligned_moment_loss = net.get_loss(configuration, moment_mode=moment_mode, lambda_1=0, lambda_2=10)
number_content_images = len(os.listdir(content_images_path))
number_style_images = len(os.listdir(style_images_path))
content_image_files = ['{}/{}'.format(content_images_path, os.listdir(content_images_path)[i])
for i in range(number_content_images)]
style_image_files = ['{}/{}'.format(style_images_path, os.listdir(style_images_path)[i])
for i in range(number_style_images)]
for i in range(number_style_images):
print("test_image {} at {}".format(i + 1, style_image_files[i]))
for i in range(number_content_images):
print("test_image {} at {}".format(i + 1, content_image_files[i]))
for j in range(number_content_images):
for i in range(number_style_images):
style_image = data_loader.image_loader(style_image_files[i], loader)
content_image = data_loader.image_loader(content_image_files[j], loader)
with torch.no_grad():
content_feature_maps = encoder(content_image)['r41']
style_feature_maps = encoder(style_image)['r41']
content_feature_map_batch_loader = data_loader.get_batch(content_feature_maps, 512)
style_feature_map_batch_loader = data_loader.get_batch(style_feature_maps, 512)
content_feature_map_batch = next(content_feature_map_batch_loader).to(device)
style_feature_map_batch = next(style_feature_map_batch_loader).to(device)
if use_MA_module:
style_feature_map_batch_moments = u.compute_moments_batches(style_feature_map_batch, last_moment=7)
content_feature_map_batch_moments = u.compute_moments_batches(content_feature_map_batch, last_moment=7)
out = moment_alignment_model(content_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments,
is_test=True)
out_feature_map_batch_moments = u.compute_moments_batches(out, last_moment=7)
print_some_moments(style_feature_map_batch_moments, content_feature_map_batch_moments, out_feature_map_batch_moments)
loss, moment_loss, reconstruction_loss = aligned_moment_loss(content_feature_map_batch,
style_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments,
out,
is_test=True)
print('loss: {}, moment_loss: {}, reconstruction_loss:{}'.format(
loss.item(), moment_loss.item(), reconstruction_loss.item()))
else:
analytical_feature_maps = analytical_ada_in_module(content_feature_map_batch, style_feature_map_batch)
out = analytical_feature_maps
utils.save_image([data_loader.imnorm(content_image, unloader),
data_loader.imnorm(style_image, unloader),
data_loader.imnorm(decoder(out.view(1, 512, 32, 32)), None)],
'{}/A_image_{}_{}.jpeg'.format(image_saving_path, i,j), normalize=False)
utils.save_image([data_loader.imnorm(decoder(out.view(1, 512, 32, 32)), None)],
'{}/B_image_{}_{}.jpeg'.format(image_saving_path, i, j), normalize=False)
def train(self):
self.inputs = data_loader.get_batch(self.config)
self.model_setup()
self.compute_losses()
init = (tf.global_variables_initializer(),
tf.local_variables_initializer())
saver = tf.train.Saver(max_to_keep=21)
max_images = self.config['n_imgs']
tf_config = tf.ConfigProto(
gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.5),
device_count={'GPU': 1})
with tf.Session(config=tf_config) as sess:
sess.run(init)
if self._to_restore:
chkpt_fname = tf.train.latest_checkpoint(self._checkpoint_dir)
saver.restore(sess, chkpt_fname)
writer = tf.summary.FileWriter(self._output_dir)
os.makedirs(self._output_dir, exist_ok=True)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
# Training Loop
start_step = sess.run(tf.train.get_global_step())
print('Starting at epoch =', start_step)
pr_bar = tqdm(
range(start_step, self._max_step),
bar_format='{desc}|{bar}|{percentage:3.0f}% ETA: {remaining}')
for epoch in pr_bar:
pr_bar.set_description('Epoch %d/%d' % (epoch, self._max_step))
if epoch % 10 == 0:
saver.save(sess,
os.path.join(self._checkpoint_dir, "cyclegan"),
global_step=epoch)
self.save_images(sess, epoch, self._output_dir)
# Dealing with the learning rate as per the epoch number
if epoch >= self._max_step:
break
elif epoch < 100:
curr_lr = self._base_lr
else:
curr_lr = self._base_lr - \
self._base_lr * (epoch - 100) / 100
for i in range(0, max_images):
inputs = sess.run(self.inputs)
in_a = np.expand_dims(inputs[0], 0)
in_b = np.expand_dims(inputs[1], 0)
# Optimizing the G_A network
_, fake_B_temp, summary_str = sess.run(
[
self.g_A_trainer, self.fake_images_b,
self.g_A_loss_summ
],
feed_dict={
self.input_a: in_a,
self.input_b: in_b,
self.learning_rate: curr_lr
})
writer.add_summary(summary_str, epoch * max_images + i)
fake_B_temp1 = self.fake_image_pool(
self.num_fake_inputs, fake_B_temp, self.fake_images_B)
# Optimizing the D_B network
_, summary_str = sess.run(
[self.d_B_trainer, self.d_B_loss_summ],
feed_dict={
self.input_a: in_a,
self.input_b: in_b,
self.learning_rate: curr_lr,
self.fake_pool_B: fake_B_temp1
})
writer.add_summary(summary_str, epoch * max_images + i)
# Optimizing the G_B network
_, fake_A_temp, summary_str = sess.run(
[
self.g_B_trainer, self.fake_images_a,
self.g_B_loss_summ
],
feed_dict={
self.input_a: in_a,
self.input_b: in_b,
self.learning_rate: curr_lr
})
writer.add_summary(summary_str, epoch * max_images + i)
fake_A_temp1 = self.fake_image_pool(
self.num_fake_inputs, fake_A_temp, self.fake_images_A)
# Optimizing the D_A network
_, summary_str = sess.run(
[self.d_A_trainer, self.d_A_loss_summ],
feed_dict={
self.input_a: in_a,
self.input_b: in_b,
self.learning_rate: curr_lr,
self.fake_pool_A: fake_A_temp1
})
writer.add_summary(summary_str, epoch * max_images + i)
writer.flush()
self.num_fake_inputs += 1
sess.run(tf.assign(self.global_step, epoch + 1))
epoch = sess.run(tf.train.get_global_step())
saver.save(sess,
os.path.join(self._checkpoint_dir, "cyclegan"),
global_step=epoch)
self.save_images(sess, epoch, self._output_dir)
total_t = pr_bar.last_print_t - pr_bar.start_t
ave_time_per_iter = total_t / pr_bar.total
pr_bar.close()
total_str = 'Total time: %10.2f h, average time per iteration: %10.2f sec'
print(total_str % (total_t / 3600.0, ave_time_per_iter))
coord.request_stop()
coord.join(threads)
writer.add_graph(sess.graph)
for index in range(var_count):
var = trainable_vars[index]
var_grad = var_grad_list[index]
update.append(var.assign(var - learning_rate * var_grad))
#========
n_epoch = 50
batch_size = 150
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
for epoch in range(n_epoch):
n_batch = X_train.shape[0] // batch_size
for batch in range(n_batch):
X_batch = get_batch(X_train, batch, batch_size)
Y_batch = get_batch(y_train, batch, batch_size)
sess.run(update, feed_dict={
X: X_batch,
Y: Y_batch
}) # here we run the update, it contains all of
# the assignment operations for each variables
train_loss, train_acc = sess.run([loss, accuracy],
feed_dict={
X: X_train,
Y: y_train
})
test_loss, test_acc = sess.run([loss, accuracy],
feed_dict={
X: X_test,
Y: y_test
def main():
[a, b, c, d] = data_loader.get_batch(batch_size = 1, image_size = 5)
def test(configuration):
"""
test the moment alignment solution (for 2 moments) in comparison
to the analytical solution that can be computed for mean and std
:param configuration: the config file
:return:
"""
encoder = net.get_trained_encoder(configuration)
decoder = net.get_trained_decoder(configuration)
analytical_ada_in_module = net.AdaptiveInstanceNormalization()
pretrained_model_path = configuration['pretrained_model_path']
content_images_path = configuration['content_images_path']
style_images_path = configuration['style_images_path']
loader = configuration['loader']
unloader = configuration['unloader']
image_test_saving_path = configuration['image_saving_path']
moment_mode = configuration['moment_mode']
print('loading the moment alignment model from {}'.format(
pretrained_model_path))
moment_alignment_model = net.get_moment_alignment_model(
configuration, moment_mode)
print(moment_alignment_model)
checkpoint = torch.load(pretrained_model_path, map_location=device)
moment_alignment_model.load_state_dict(checkpoint)
number_content_images = len(os.listdir(content_images_path))
number_style_images = len(os.listdir(style_images_path))
content_image_files = [
'{}/{}'.format(content_images_path,
os.listdir(content_images_path)[i])
for i in range(number_content_images)
]
style_image_files = [
'{}/{}'.format(style_images_path,
os.listdir(style_images_path)[i])
for i in range(number_style_images)
]
for i in range(number_style_images):
print("test_image {} at {}".format(i + 1, style_image_files[i]))
for i in range(number_content_images):
print("test_image {} at {}".format(i + 1, content_image_files[i]))
iterations = 0
mean_percentages = [0, 0, 0, 0, 0, 0, 0]
for j in range(number_content_images):
for i in range(number_style_images):
style_image = data_loader.image_loader(style_image_files[i],
loader)
content_image = data_loader.image_loader(content_image_files[j],
loader)
with torch.no_grad():
content_feature_maps = encoder(content_image)['r41']
style_feature_maps = encoder(style_image)['r41']
content_feature_map_batch_loader = data_loader.get_batch(
content_feature_maps, 512)
style_feature_map_batch_loader = data_loader.get_batch(
style_feature_maps, 512)
content_feature_map_batch = next(
content_feature_map_batch_loader).to(device)
style_feature_map_batch = next(
style_feature_map_batch_loader).to(device)
style_feature_map_batch_moments = u.compute_moments_batches(
style_feature_map_batch)
content_feature_map_batch_moments = u.compute_moments_batches(
content_feature_map_batch)
out = moment_alignment_model(
content_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments)
result_feature_maps = out
analytical_feature_maps = analytical_ada_in_module(
content_feature_map_batch, style_feature_map_batch)
a_0, a_001, a_001_l, a_01, a_01_l, a_1, a_1_l = \
get_distance(analytical_feature_maps, result_feature_maps)
iterations += 1
mean_percentages[0] += a_0
mean_percentages[1] += a_001
mean_percentages[2] += a_001_l
mean_percentages[3] += a_01
mean_percentages[4] += a_01_l
mean_percentages[5] += a_1
mean_percentages[6] += a_1_l
# u.imshow(decoder(analytical_feature_maps.view(1, 512, 32, 32)), transforms.ToPILImage())
utils.save_image([
data_loader.imnorm(content_image, unloader),
data_loader.imnorm(style_image, unloader),
data_loader.imnorm(
decoder(result_feature_maps.view(1, 512, 32, 32)),
None),
data_loader.imnorm(
decoder(analytical_feature_maps.view(1, 512, 32, 32)),
None)
],
'{}/A_image_{}_{}.jpeg'.format(
image_test_saving_path, i, j),
normalize=False,
pad_value=1)
utils.save_image([
data_loader.imnorm(content_image, unloader),
data_loader.imnorm(
decoder(result_feature_maps.view(1, 512, 32, 32)),
None),
data_loader.imnorm(
decoder(analytical_feature_maps.view(1, 512, 32, 32)),
None)
],
'{}/B_image_{}_{}.jpeg'.format(
image_test_saving_path, i, j),
normalize=False,
pad_value=1)
utils.save_image([
data_loader.imnorm(style_image, unloader),
data_loader.imnorm(
decoder(result_feature_maps.view(1, 512, 32, 32)),
None),
data_loader.imnorm(
decoder(analytical_feature_maps.view(1, 512, 32, 32)),
None)
],
'{}/C_image_{}_{}.jpeg'.format(
image_test_saving_path, i, j),
normalize=False,
pad_value=1)
utils.save_image([
data_loader.imnorm(
decoder(result_feature_maps.view(1, 512, 32, 32)),
None),
data_loader.imnorm(
decoder(analytical_feature_maps.view(1, 512, 32, 32)),
None)
],
'{}/D_image_{}_{}.jpeg'.format(
image_test_saving_path, i, j),
normalize=False,
pad_value=1)
print('averaging percentages')
mean_percentages = [
mean_percentages[i] / iterations for i in range(len(mean_percentages))
]
print(mean_percentages)
word2int, int2word = get_vocab(words)
g = Graph(word2int, int2word, is_training=False)
saver = tf.train.Saver()
sess = tf.Session()
#sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 开始训练
if train == 0:
lr_list = []
logger.info("开始训练 ... ")
sess.run(tf.global_variables_initializer())
step = 1
for i in range(hp.Snum_epochs):
# 训练数据生成器
batches_train = get_batch(comments_train, labels_train, word2int)
# 随模型进行训练 降低学习率
acc = []
loss = []
for batch_x, batch_y in batches_train:
lr = hp.Sfactor * (hp.Shidden_units**(-0.5) * min(
step**(-0.5), step * hp.Swarmup**(-1.5)))
lr_list.append(lr)
sess.run(tf.assign(g.learning_rate, lr))
print('lr', lr)
feed = {g.x: batch_x, g.y: batch_y}
batch_loss, batch_accuracy, _ = sess.run(
[g.loss, g.accuracy, g.optimizer], feed_dict=feed)
logger.info(
"{}: epoch {}, step {}, loss {:g}, acc {:g}".format(
try:
current_phase_saver.restore(sess, params.save_path)
except:
print("Couldn't load current phase")
print("Error:", sys.exc_info()[0])
prev_phase_saver.restore(sess, params.save_path)
except:
print("Couldn't load previous phase")
print("Error:", sys.exc_info()[0])
print("COULD NOT RESTORE MODEL. TRAINING FROM SCATCH")
running_loss = 0
iterations = 0
while True:
try:
start_time = time.time()
next_batch = get_batch()
# tdt, tdf, tdl, kdl, pl, irl, il = sess.run([train_disc_true, train_disc_false, train_disc_loss, trick_disc_loss, pixel_loss, id_regen_loss, id_loss],
# feed_dict={X: next_batch, training:False})
# print(tdt, tdf, tdl, kdl, pl, irl, il)
# tdt, tdf, tdl, kdl, pl, irl, il = sess.run([train_disc_true, train_disc_false, train_disc_loss, trick_disc_loss, pixel_loss, id_regen_loss, id_loss],
# feed_dict={X: next_batch, training:True})
# print(tdt, tdf, tdl, kdl, pl, irl, il)
# print(tdl + kdl + pl + irl + il)
#l, _, pl = sess.run([loss, update_op, pixel_loss], feed_dict={X: next_batch, training:True})
runners = [
encoder_loss, decoder_loss, discriminator_loss, encoder_update,
decoder_update, discriminator_update, id_kl_loss, pose_kl_loss,
pixel_loss, id_regen_loss, id_loss, trick_disc_loss,
train_disc_true, train_disc_false
]
def validate(number_of_validation, criterion, encoder, moment_alignment_model,
val_data_loader, feature_map_batch_size, writer):
"""
the validaton loop
:param number_of_validation: the number of the current validation (for data saving)
:param criterion: the loss criterion
:param encoder: the encoder network
:param moment_alignment_model: the moment alignment model
:param val_data_loader: the dataloader for the validation dataset
:param feature_map_batch_size: the batch size
:param writer: the (loss) writer
:return:
"""
print('validating model ...')
iteration = 0
total_validation_loss = 0
while True:
try:
data = val_data_loader.__next__()
except StopIteration:
break
except:
print('something wrong happened with the data loader')
continue
# get the content_image batch
content_image = data.get('coco').get('image')
content_image = content_image.to(device)
# get the style_image batch
style_image = data.get('painter_by_numbers').get('image')
style_image = style_image.to(device)
with torch.no_grad():
style_feature_maps = encoder(style_image)['r41'].to(device)
content_feature_maps = encoder(content_image)['r41'].to(device)
content_feature_map_batch_loader = data_loader.get_batch(
content_feature_maps, feature_map_batch_size)
style_feature_map_batch_loader = data_loader.get_batch(
style_feature_maps, feature_map_batch_size)
while True:
try:
content_feature_map_batch = next(
content_feature_map_batch_loader).to(device)
style_feature_map_batch = next(
style_feature_map_batch_loader).to(device)
iteration += 1
except StopIteration:
break
except:
print('something wrong happened with the data loader')
continue
style_feature_map_batch_moments = utils.compute_moments_batches(
style_feature_map_batch)
content_feature_map_batch_moments = utils.compute_moments_batches(
content_feature_map_batch)
out = moment_alignment_model(
content_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments)
loss, moment_loss, reconstruction_loss = criterion(
content_feature_map_batch, style_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments, out)
total_validation_loss += loss
writer.write_row([
number_of_validation * 100 * 512,
loss.item(),
moment_loss.item(),
reconstruction_loss.item()
])
# if iteration % 2000 == 0:
# print('validation loss: {:4f}'.format(loss.item()))
# writer.add_scalar('data/validation_loss', loss.item(),
# number_of_validation * 100 * 512 + iteration)
# writer.add_scalar('data/validation_moment_loss', moment_loss.item(),
# number_of_validation * 100 * 512 + iteration)
# writer.add_scalar('data/validation_reconstruction_loss', reconstruction_loss.item(),
# number_of_validation * 100 * 512 + iteration)
writer.add_scalar('data/mean_validation_loss',
total_validation_loss / iteration, number_of_validation)
return total_validation_loss / iteration
def train(configuration):
"""
this is the main training loop
:param configuration: the config file
:return:
"""
epochs = configuration['epochs']
print('going to train for {} epochs'.format(epochs))
step_printing_interval = configuration['step_printing_interval']
print('writing to console every {} steps'.format(step_printing_interval))
image_saving_interval = configuration['image_saving_interval']
print('writing to console every {} steps'.format(step_printing_interval))
epoch_saving_interval = configuration['epoch_saving_interval']
print('saving the model every {} epochs'.format(epoch_saving_interval))
validation_interval = configuration['validation_interval']
print('validating the model every {} epochs'.format(validation_interval))
image_saving_path = configuration['image_saving_path']
print('saving images to {}'.format(image_saving_path))
loader = configuration['loader']
model_saving_path = configuration['model_saving_path']
print('saving models to {}'.format(model_saving_path))
# tensorboardX_path = configuration['tensorboardX_path']
# writer = SummaryWriter(logdir='{}/runs'.format(tensorboardX_path))
# print('saving tensorboardX logs to {}'.format(tensorboardX_path))
loss_writer = LossWriter(os.path.join(
configuration['folder_structure'].get_parent_folder(), './loss/loss'),
buffer_size=100)
loss_writer.write_header(columns=[
'epoch', 'all_training_iteration', 'loss', 'moment_loss',
'reconstruction_loss'
])
validation_loss_writer = LossWriter(
os.path.join(configuration['folder_structure'].get_parent_folder(),
'./loss/loss'))
validation_loss_writer.write_header(columns=[
'validation_iteration', 'loss', 'moment_loss', 'reconstruction_loss'
])
# batch_size is the number of images to sample
batch_size = 1
feature_map_batch_size = int(configuration['feature_map_batch_size'])
print('training in batches of {} feature maps'.format(
feature_map_batch_size))
coco_data_path_train = configuration['coco_data_path_train']
painter_by_numbers_data_path_train = configuration[
'painter_by_numbers_data_path_train']
print('using {} and {} for training'.format(
coco_data_path_train, painter_by_numbers_data_path_train))
coco_data_path_val = configuration['coco_data_path_val']
painter_by_numbers_data_path_val = configuration[
'painter_by_numbers_data_path_val']
print('using {} and {} for validation'.format(
coco_data_path_val, painter_by_numbers_data_path_val))
train_dataloader = data_loader.get_concat_dataloader(
coco_data_path_train,
painter_by_numbers_data_path_train,
batch_size,
loader=loader)
print('got train dataloader')
val_dataloader = data_loader.get_concat_dataloader(
coco_data_path_val,
painter_by_numbers_data_path_val,
batch_size,
loader=loader)
print('got val dataloader')
lambda_1 = configuration['lambda_1']
print('lambda 1: {}'.format(lambda_1))
lambda_2 = configuration['lambda_2']
print('lambda 2: {}'.format(lambda_2))
loss_moment_mode = configuration['moment_mode']
net_moment_mode = configuration['moment_mode']
print('loss is sum of the first {} moments'.format(loss_moment_mode))
print('net accepts {} in-channels'.format(net_moment_mode))
unloader = configuration['unloader']
print('got the unloader')
do_validation = configuration['do_validation']
print('doing validation: {}'.format(do_validation))
moment_alignment_model = net.get_moment_alignment_model(
configuration, moment_mode=loss_moment_mode)
print('got model')
print(moment_alignment_model)
decoder = net.get_trained_decoder(configuration)
print('got decoder')
print(decoder)
print('params that require grad')
for name, param in moment_alignment_model.named_parameters():
if param.requires_grad:
print(name)
criterion = net.get_loss(configuration,
moment_mode=loss_moment_mode,
lambda_1=lambda_1,
lambda_2=lambda_2)
print('got moment loss module')
print(criterion)
encoder = net.get_trained_encoder(configuration)
print('got encoder')
print(encoder)
try:
optimizer = optim.Adam(moment_alignment_model.parameters(),
lr=configuration['lr'])
except:
optimizer = optim.Adam(moment_alignment_model.module.parameters(),
lr=configuration['lr'])
print('got optimizer')
schedule = QuadraticSchedule(timesteps=10000000,
initial=configuration['lr'],
final=configuration['lr'] / 10.)
print('got schedule')
print('making iterable from train dataloader')
train_data_loader = iter(train_dataloader)
print('train data loader iterable')
outer_training_iteration = -1
all_training_iteration = 0
number_of_validation = 0
current_validation_loss = float('inf')
for epoch in range(1, epochs):
print('epoch: {}'.format(epoch))
# this is the outer training loop (sampling images)
print('training model ...')
while True:
try:
data = train_data_loader.__next__()
outer_training_iteration += 1
except StopIteration:
print('got to the end of the dataloader (StopIteration)')
train_data_loader = iter(train_dataloader)
break
except:
print('something went wrong with the dataloader, continuing')
continue
if do_validation:
# validate the model every validation_interval iterations
if outer_training_iteration % validation_interval == 0:
print('making iterable from val dataloader')
val_data_loader = iter(val_dataloader)
print('val data loader iterable')
validation_loss = validate(number_of_validation, criterion,
encoder, moment_alignment_model,
val_data_loader,
feature_map_batch_size,
validation_loss_writer)
number_of_validation += 1
if validation_loss < current_validation_loss:
utils.save_current_best_model(
epoch, moment_alignment_model,
configuration['model_saving_path'])
print('got a better model')
current_validation_loss = validation_loss
print('set the new validation loss to the current one')
else:
print('this model is actually worse than the best one')
# get the content_image batch
content_image = data.get('coco').get('image')
content_image = content_image.to(device)
# get the style_image batch
style_image = data.get('painter_by_numbers').get('image')
style_image = style_image.to(device)
style_feature_maps = encoder(style_image)['r41'].to(device)
content_feature_maps = encoder(content_image)['r41'].to(device)
result_feature_maps = torch.zeros(1, 1, 32, 32)
content_feature_map_batch_loader = data_loader.get_batch(
content_feature_maps, feature_map_batch_size)
style_feature_map_batch_loader = data_loader.get_batch(
style_feature_maps, feature_map_batch_size)
# this is the inner training loop (feature maps)
while True:
try:
content_feature_map_batch = next(
content_feature_map_batch_loader).to(device)
style_feature_map_batch = next(
style_feature_map_batch_loader).to(device)
all_training_iteration += 1
except StopIteration:
break
except:
continue
do_print = all_training_iteration % step_printing_interval == 0
optimizer.zero_grad()
style_feature_map_batch_moments = utils.compute_moments_batches(
style_feature_map_batch, last_moment=net_moment_mode)
content_feature_map_batch_moments = utils.compute_moments_batches(
content_feature_map_batch, last_moment=net_moment_mode)
out = moment_alignment_model(
content_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments)
loss, moment_loss, reconstruction_loss = criterion(
content_feature_map_batch,
style_feature_map_batch,
content_feature_map_batch_moments,
style_feature_map_batch_moments,
out,
last_moment=loss_moment_mode)
if do_print:
set_lr(optimizer,
lr=schedule.get(all_training_iteration /
step_printing_interval))
loss_writer.write_row([
epoch, all_training_iteration,
loss.item(),
moment_loss.item(),
reconstruction_loss.item()
])
# backprop
loss.backward()
optimizer.step()
result_feature_maps = torch.cat(
[result_feature_maps,
out.cpu().view(1, -1, 32, 32)], 1)
# if do_print:
# print('loss: {:4f}'.format(loss.item()))
#
# writer.add_scalar('data/training_loss', loss.item(), all_training_iteration)
# writer.add_scalar('data/training_moment_loss', moment_loss.item(), all_training_iteration)
# writer.add_scalar('data/training_reconstruction_loss', reconstruction_loss.item(),
# all_training_iteration)
result_feature_maps = result_feature_maps[:, 1:513, :, :]
result_img = decoder(result_feature_maps.to(device))
if outer_training_iteration % image_saving_interval == 0:
u.save_image([
data_loader.imnorm(content_image, unloader),
data_loader.imnorm(style_image, unloader),
data_loader.imnorm(result_img, None)
],
'{}/image_{}_{}__{}_{}.jpeg'.format(
image_saving_path, epoch,
outer_training_iteration / epoch, lambda_1,
lambda_2),
normalize=False)
# save every epoch_saving_interval the current model
if outer_training_iteration % image_saving_interval == 0:
utils.save_current_model(lambda_1, lambda_2,
moment_alignment_model.state_dict(),
optimizer.state_dict(),
configuration['model_saving_path'])
# TEST
def test_step(x_batch, y_batch):
feed_dict = {
model.input_x: x_batch,
model.input_y: y_batch,
model.dropout_keep_prob: config.DROPOUT_PROB
}
step, summaries, loss, accuracy = sess.run(
[global_step, dev_summary_op, model.loss, model.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
logger.info("{}: step {}, loss {:g}, acc {:g}".format(
time_str, step, loss, accuracy))
batches = data_loader.get_batch(list(zip(x_train, y_train)),
config.BATCH_SIZE, config.NUM_EPOCHS)
#TRAIN FOR EACH BATCH
for batch in batches:
x_batch, y_batch = zip(*batch)
train_step(x_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % config.EVALUATE_EVERY == 0:
logger.info("\nEvaluation:")
dev_step(x_dev, y_dev, writer=dev_summary_writer)
logger.info("")
if current_step % config.CHECKPOINT_EVERY == 0:
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
logger.info("Saved model checkpoint to {}\n".format(path))
