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))