def train():
model.train()
total_loss = 0
start_time = time.time()
# vis.line(Y=train_data[0],X=torch.arange(0,720))
for batch_idx, start_idx in enumerate(
range(0, train_data.size(1), args.window_len)):
"""use sliding window to get per batch data and feed in net"""
if start_idx + args.seq_len >= train_data.size(
1): # target的offset为1 所以取得等号不能执行之下逻辑
continue # 边界条件再斟酌一下
"""data:n*seq_len target:n*seq_len """
data, target = get_batch(train_data, start_idx, args)
optimizer.zero_grad()
"""output:n_batch*seqlen*emb_size"""
output = model(data)
final_output = output.contiguous().view(-1, n_cates)
final_target = target.contiguous().view(-1).to(torch.int64)
loss = criterion(final_output, final_target)
loss.backward()
# writer.add_scalar("train_loss",loss.detach().numpy(),batch_idx)
if args.clip > 0:
torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
optimizer.step()
total_loss += loss.data
"""batch_idx 0到44 45=720/16"""
if batch_idx % args.log_interval == 0 and batch_idx > 0:
cur_loss = total_loss / args.log_interval
elapsed = time.time() - start_time
print(
'| {:3d}/{:3d} batches | lr {:02.5f} | ms/batch {:5.5f} | loss {:5.2f} | ppl {:8.2f} |'
.format(batch_idx,
train_data.size(1) // args.window_len, lr,
elapsed * 1000 / args.log_interval, cur_loss,
math.exp(cur_loss)))
total_loss = 0
start_time = time.time()
def evaluate(data_source, type):
model.eval()
total_loss = 0
total_data_len = 0
epoch_final_output = torch.FloatTensor([])
epoch_final_target = torch.LongTensor([])
for batch_idx, start_idx in enumerate(
range(0, data_source.size(1), args.window_len)):
"""use sliding window to get per batch data and feed in net"""
if start_idx + args.seq_len >= train_data.size(
1): # target的offset为1 所以取得等号不能执行之下逻辑
continue # 边界条件再斟酌一下
"""data:n*seq_len target:n """
data, target = get_batch(data_source, start_idx, args)
"""output:n_batch*seqlen*n_cates"""
output = model(data)
final_output = output.contiguous().view(-1, n_cates) # n_cates
final_target = target.contiguous().view(-1)
loss = criterion(final_output, final_target)
epoch_final_output = torch.cat(
[epoch_final_output, final_output[:args.window_len]], dim=0)
epoch_final_target = torch.cat(
[epoch_final_target, final_target[:args.window_len]], dim=0)
# writer.add_scalar(type+"_loss",loss.detach().numpy(),batch_idx)
"""就是加权算loss"""
total_loss += args.window_len * loss.data
total_data_len += args.window_len
predict_values = torch.max(epoch_final_output, 1)[1]
target_values = epoch_final_target
val_len = target_values.size(0)
# vis.line(Y=predict_values)
# vis.line(Y=target_values)
vis.line(Y=torch.stack([predict_values, target_values], dim=1),
X=torch.arange(val_len),
opts=dict(legend=["预测值", "真实值"], xtrickstep=1, ytrickstep=1))
return total_loss / total_data_len
y_ = tf.reshape(deconv8, [-1, Out_Width * Out_Height])
# loss function
loss = tf.reduce_sum(tf.square(y_ - y_reshape))
train = tf.train.AdamOptimizer(lr).minimize(loss)
data = dataload.load_data(is_training)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.initialize_all_variables())
for step in range(TRAIN_STEP):
images, depths = dataload.get_batch(data, BATCH_SIZE)
# print(depths[0])
# print(sess.run(conv8, feed_dict={x:images, y:depths}))
# print("image:", images[8])
if is_training:
if step % 1 == 0:
loss_value = sess.run(loss, feed_dict={x: images, y: depths})
print(step, loss_value)
if step % 900 == 0 and step != 0:
y_value = sess.run(y_, feed_dict={x: images})
saver.save(sess, "weights/weights" + str(step) + ".ckpt")
# print("conv5_4", np.resize(y_value, [BATCH_SIZE, 112, 112])[0])
sess.run(train, feed_dict={x: images, y: depths})
else:
def __init__(self, mode="train"):
"""
Initialize the class based off of the given mode
:param mode: the mode to load the model based on
"""
print("Loading your model...")
# Initialize values used in class
self.mode = mode
self.global_step = None
self.mel_loss = None
self.mel_loss = None
self.mag_loss = None
self.learning_rate = None
self.optimizer = None
self.merged = None
self.gradients = None
self.clipped = None
self.gvs = None
self.opt_train = None
# If is_training
if mode == "train":
self.is_training = True
else:
self.is_training = False
print("Loading inputs...")
# Load inputs
if self.is_training:
self.txt, self.mels, self.mags, self.file_names, self.num_batch = get_batch(
)
elif mode == "synthesize":
self.txt = tf.placeholder(tf.int32, shape=(None, None))
self.mels = tf.placeholder(tf.float32,
shape=(None, None,
N_MELS * REDUCTION_FACTOR))
else: # eval
self.txt = tf.placeholder(tf.int32, shape=(None, None))
self.mels = tf.placeholder(tf.float32,
shape=(None, None,
N_MELS * REDUCTION_FACTOR))
self.mags = tf.placeholder(tf.float32,
shape=(None, None, 1 + N_FFT // 2))
self.file_names = tf.placeholder(tf.string, shape=(None, ))
# decoder inputs
self.decoder_inputs = tf.concat(
(tf.zeros_like(self.mels[:, :1, :]), self.mels[:, :-1, :]), 1)
self.decoder_inputs = self.decoder_inputs[:, :, -N_MELS:]
# Networks
with tf.variable_scope("Networks"):
print("Loading the encoder...")
# encoder
self.memory = encoder(self.txt, is_training=self.is_training)
print("Loading the decoder...")
# decoder
self.mel_hat, self.alignments = decoder(
self.decoder_inputs, self.memory, is_training=self.is_training)
print("Loading the post CBHG module...")
# CBHG Module
self.mags_hat = cbhg_helper(self.mel_hat,
N_MELS,
is_training=self.is_training,
post=True)
print("Audio out")
# audio
self.audio_out = tf.py_func(spectrogram2wav, [self.mags_hat[0]],
tf.float32)
# Training and evaluation
if mode in ("train", "eval"):
print("Generating Loss...")
# Loss
self.loss = self.get_loss()
print("Getting the optimizer ready...")
# Training Scheme
self.optimize()
print("Setting up your summary...")
self.summarize()
def train(train_num, model, criterion, optimizer, epoch):
"""
Run one train epoch
"""
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top2 = AverageMeter()
top3 = AverageMeter()
# switch to train mode
model.train()
end = time.time()
iters = train_num // args.batch_size
for iter in range(iters):
# measure data loading time
data_time.update(time.time() - end)
input, label, mlabel, clabel = get_batch(args.batch_size)
input = torch.FloatTensor(input)
label = torch.FloatTensor(label)
mlabel = torch.FloatTensor(mlabel)
clabel = torch.FloatTensor(clabel)
if args.cpu == False:
input = input.cuda(async=True)
label = label.cuda(async=True)
mlabel = mlabel.cuda(async=True)
clabel = clabel.cuda(async=True)
if args.half:
input = input.half()
# compute output conB_Fea,conM_Fea,conD_Fea clabel,mlabel,label
out, out2, out3 = model(input)
loss = criterion(out, out2, out3, label, mlabel, clabel)
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
out = out.float()
out2 = out2.float()
out3 = out3.float()
loss = loss.float()
# measure accuracy and record loss
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if iter % args.print_freq == 0:
prec1 = accuracy(out.data, clabel, 1)
prec2 = accuracy(out2.data, mlabel, 2)
prec3 = accuracy(out3.data, label, 3)
losses.update(loss.item(), input.size(0))
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1:.3f}\t'
'Prec@2 {top2:.3f}\t'
'Prec@3 {top3:.3f}'.format(epoch,
iter,
iters,
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=prec1,
top2=prec2,
top3=prec3))
def train(train_num, model, criterion, optimizer, epoch):
"""
Run one train epoch
"""
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top2 = AverageMeter()
top3 = AverageMeter()
top4 = AverageMeter()
top5 = AverageMeter()
top6 = AverageMeter()
top7 = AverageMeter()
top8 = AverageMeter()
top9 = AverageMeter()
top10 = AverageMeter()
sum_value = 0
# switch to train mode
model.train()
f = open("process_autolearn_womean1.txt","a+");
end = time.time()
iters2 = train_num // args.batch_size
iters = iters2
for iter in range(1500):#iters//2
# measure data loading time
data_time.update(time.time() - end)
inputt, labelt, mlabelt, clabelt = get_batch(args.batch_size)
inputp, labelp, mlabelp, clabelp = get_batch(args.batch_size)
inputt = torch.FloatTensor(inputt);
inputp = torch.FloatTensor(inputp)
labelt = torch.FloatTensor(labelt);
labelp = torch.FloatTensor(labelp)
mlabelt = torch.FloatTensor(mlabelt);
mlabelp = torch.FloatTensor(mlabelp)
clabelt = torch.FloatTensor(clabelt);
clabelp = torch.FloatTensor(clabelp)
if args.cpu == False:
inputt = inputt.cuda(async=True)
labelt = labelt.cuda(async=True)
mlabelt = mlabelt.cuda(async=True)
clabelt = clabelt.cuda(async=True)
inputp = inputp.cuda(async=True)
labelp = labelp.cuda(async=True)
mlabelp = mlabelp.cuda(async=True)
clabelp = clabelp.cuda(async=True)
if args.half:
inputt = inputt.half()
inputp = inputp.half()
# compute output
outt, outt2, outt3, outp, outp2, outp3, att_t, att_p = model(inputt, inputp)
noise = torch.mean(abs(att_t-att_p))
att_t = torch.mean(abs(att_t))
att_p = torch.mean(abs(att_p))
#noise1 = (att_p- att_t)
#noi = torch.mean(torch.clamp(inputt +noise1+128.,0,255)-inputt);print(noi)
loss1 = criterion(outt, outt2, outt3, labelp, mlabelp, clabelp)
loss2 = criterion(outp, outp2, outp3, labelt, mlabelt, clabelt)
loss = loss1 + loss2 + 0.4 * (att_t + att_p)
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
outt = outt.float()
outt2 = outt2.float()
outt3 = outt3.float()
outp = outp.float()
outp2 = outp2.float()
outp3 = outp3.float()
loss = loss.float()
# measure accuracy and record loss
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
sum_value += noise
if iter % args.print_freq == 0:
prec1 = accuracy(outp.data, clabelt, 1)
top1.update(prec1.item(), inputt.size(0))
prec2 = accuracy(outp2.data, mlabelt, 2)
top2.update(prec2.item(), inputt.size(0))
prec3 = accuracy(outp3.data[:,:19], labelt[:,:19], 2)
top3.update(prec3.item(), inputt.size(0))
prec4 = accuracy(outt.data, clabelp, 1)
top4.update(prec4.item(), inputt.size(0))
prec5 = accuracy(outt2.data, mlabelp, 2)
top5.update(prec5.item(), inputt.size(0))
prec6 = accuracy(outt3.data[:,:19], labelp[:,:19], 2)
top6.update(prec6.item(), inputt.size(0))
losses.update(loss.item(), inputt.size(0))
prec7 = accuracy(outp3.data[:, :19], outp2[:, :19], 2)
prec8 = accuracy(outp3.data[:, :14], outp[:, :14], 1)
top7.update(prec7.item(), inputt.size(0))
top8.update(prec8.item(), inputt.size(0))
prec9 = accuracy(outt3.data[:, :19], outt2[:, :19], 2)
prec10 = accuracy(outt3.data[:, :14], outt[:, :14], 1)
top9.update(prec9.item(), inputt.size(0))
top10.update(prec10.item(), inputt.size(0))
losses.update(loss.item(), inputt.size(0))
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1:.3f}\t'
'Prec@2 {top2:.3f}\t'
'Prec@3 {top3:.3f}\n'
'Prec@4 {top4:.3f}\t'
'Prec@5 {top5:.3f}\t'
'Prec@6 {top6:.3f}\t'
'Prec@7 {top7:.3f}\t'
'Prec@8 {top8:.3f}\t'
'Prec@9 {top9:.3f}\t'
'Prec@10 {top10:.3f}'.format(
epoch, iter, iters, batch_time=batch_time,
data_time=data_time, loss=losses, top1=prec1, top2=prec2, top3=prec3,
top4=prec4, top5=prec5, top6=prec6,top7=prec7, top8=prec8, top9=prec9, top10=prec10
))
f.write('TR{top1.avg:.3f}'.format(top1=top1))
f.write('TR{top2.avg:.3f}'.format(top2=top2))
f.write('TR{top3.avg:.3f}'.format(top3=top3))
f.write('TR{top4.avg:.3f}'.format(top4=top4))
f.write('TR{top5.avg:.3f}'.format(top5=top5))
f.write('TR{top6.avg:.3f}'.format(top6=top6))
f.write('TR{top7.avg:.3f}'.format(top7=top7))
f.write('TR{top8.avg:.3f}'.format(top8=top8))
f.write('TR{top9.avg:.3f}'.format(top9=top9))
f.write('TR{top10.avg:.3f}'.format(top10=top10))
f.write('TR{losses.avg:.3f}\n'.format(losses=losses))
