def forward(self, x, target=None): # backbone _, _, C_5 = self.backbone(x) # _, _, C_5 = backbone(images) # head C_5 = self.SPP(C_5) C_5 = self.SAM(C_5) C_5 = self.conv_set(C_5) """ SPP = SPP.cuda() SAM = SAM.cuda() conv_set = conv_set.cuda() C_5 = SPP(C_5) C_5 = SAM(C_5) C_5 = conv_set(C_5) """ # pred prediction = self.pred(C_5) # prediction = pred(C_5) prediction = prediction.view(C_5.size(0), 1 + self.num_classes + 4, -1).permute(0, 2, 1) # prediction = prediction.view(C_5.size(0), 1 + 20 + 4, -1).permute(0, 2, 1) B, HW, C = prediction.size() # Divide prediction to obj_pred, txtytwth_pred and cls_pred # [B, H*W, 1] conf_pred = prediction[:, :, :1] # [B, H*W, num_cls] cls_pred = prediction[:, :, 1 : 1 + self.num_classes] # cls_pred = prediction[:, :, 1: 1 + 20] # [B, H*W, 4] txtytwth_pred = prediction[:, :, 1 + self.num_classes:] # txtytwth_pred = prediction[:, :, 1 + 20:] # test if not self.trainable: with torch.no_grad(): # batch size = 1 all_conf = torch.sigmoid(conf_pred)[0] # 0 is because that these is only 1 batch. all_bbox = torch.clamp((self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) all_class = (torch.softmax(cls_pred[0, :, :], 1) * all_conf) # separate box pred and class conf all_conf = all_conf.to('cpu').numpy() all_class = all_class.to('cpu').numpy() all_bbox = all_bbox.to('cpu').numpy() bboxes, scores, cls_inds = self.postprocess(all_bbox, all_class) return bboxes, scores, cls_inds else: conf_loss, cls_loss, txtytwth_loss, total_loss = tools.loss(pred_conf=conf_pred, pred_cls=cls_pred, pred_txtytwth=txtytwth_pred, label=target) return conf_loss, cls_loss, txtytwth_loss, total_loss
def train_running(): with tf.name_scope('input'): train_batch, train_label_batch, _ = input_data.get_batch(train_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_batch, val_label_batch, _ = input_data.get_batch(val_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) model = models.model(x, N_CLASSES) model.AlexNet() logits = model.fc3 loss = tools.loss(logits, y_) acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, LEARNING_RATE) with tf.Session() as sess: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={x: tra_images, y_: tra_labels}) if step % 50 == 0: print('Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={x: tra_images, y_: tra_labels}) train_writer.add_summary(summary_str, step) # if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, acc], feed_dict={x: val_images, y_: val_labels}) print('** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={x: val_images, y_: val_labels}) val_writer.add_summary(summary_str, step) # if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def run(batch_size=300, learning_rate=0.01): #region create network data, label = CifarInput.read_cifar10( r"C:\Projects\Programming\CsDiscount\cifar-10-binary", True, batch_size, True) logit = CapsNet.CapsNet(data, batch_size) reconstruction = tools.decoder(logit) reconstruction_p = tf.placeholder(dtype=tf.float32, shape=[batch_size, 32, 32, 3]) print("Network Created") #endregion #region create optimizer global_step = tf.Variable(0, trainable=False, name="global_step") loss = tools.loss(logit, label, data, reconstruction_p, batch_size) accuracy = tools.accuracy(logit, label) train_op = tools.optimize(loss, learning_rate, global_step) print("Optimizer Created") #endregion #region create sessions, queues and savers sess = tf.Session() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) init = tf.global_variables_initializer() saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() train_summary_writer = tf.summary.FileWriter(train_log_dir) sess.run(init) print("Sessions, Queues and Savers Created") #endregion for x in range(1000): print(x) reconstruction_run = sess.run(reconstruction) sess.run(train_op, feed_dict={reconstruction_p: reconstruction_run}) if x % 5 == 0: mainwindow.newimg(reconstruction_run[0]) if x % 100 == 0: print(sess.run(accuracy)) checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, save_path=checkpoint_path, global_step=x)
def forward(self, x, target=None): # backbone _, _, C_5 = self.backbone(x) # pred prediction = self.pred(C_5) # 把[B, C, H, W]的预测变成了[B, HxW, C] prediction = prediction.view(C_5.size(0), 1 + self.num_classes + 4, -1).permute(0, 2, 1) B, HW, C = prediction.size() # [B, H*W, 1] conf_pred = prediction[:, :, :1] # [B, H*W, num_cls] cls_pred = prediction[:, :, 1: 1 + self.num_classes] # [B, H*W, 4] txtytwth_pred = prediction[:, :, 1 + self.num_classes:] # test if not self.trainable: with torch.no_grad(): # bacth size = 1 all_conf = torch.sigmoid(conf_pred)[0] # 所有值要在0~1之间 all_bbox = torch.clamp((self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) all_class = (torch.softmax(cls_pred[0, :, :], 1) * all_conf) # separate box pred and class conf all_conf = all_conf.to('cpu').numpy() all_class = all_class.to('cpu').numpy() all_bbox = all_bbox.to('cpu').numpy() bboxes, scores, cls_inds = self.postprocess(all_bbox, all_class) return bboxes, scores, cls_inds else: conf_loss, cls_loss, txtytwth_loss, total_loss = tools.loss() return conf_loss, cls_loss, txtytwth_loss, total_loss
def forward(self, x, target=None): # backbone C4, C5 = self.backbone(x) # head C5 = self.convsets_1(C5) # route from 16th layer in darknet C4 = self.reorg(self.route_layer(C4)) # route concatenate C5 = torch.cat([C4, C5], dim=1) C5 = self.convsets_2(C5) prediction = self.pred_(C5) B, abC, H, W = prediction.size() # [B, anchor_n * C, N, M] -> [B, N, M, anchor_n * C] -> [B, N*M, anchor_n*C] prediction = prediction.permute(0, 2, 3, 1).contiguous().view(B, H*W, abC) # Divide prediction to obj_pred, xywh_pred and cls_pred # [B, H*W*anchor_n, 1] conf_pred = prediction[:, :, :1 * self.anchor_number].contiguous().view(B, H*W*self.anchor_number, 1) # [B, H*W, anchor_n, num_cls] cls_pred = prediction[:, :, 1 * self.anchor_number : (1 + self.num_classes) * self.anchor_number].contiguous().view(B, H*W*self.anchor_number, self.num_classes) # [B, H*W, anchor_n, 4] txtytwth_pred = prediction[:, :, (1 + self.num_classes) * self.anchor_number:].contiguous() # test if not self.trainable: txtytwth_pred = txtytwth_pred.view(B, H*W, self.anchor_number, 4) with torch.no_grad(): # batch size = 1 all_obj = torch.sigmoid(conf_pred)[0] # 0 is because that these is only 1 batch. all_bbox = torch.clamp((self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) all_class = (torch.softmax(cls_pred[0, :, :], 1) * all_obj) # separate box pred and class conf all_obj = all_obj.to('cpu').numpy() all_class = all_class.to('cpu').numpy() all_bbox = all_bbox.to('cpu').numpy() bboxes, scores, cls_inds = self.postprocess(all_bbox, all_class) return bboxes, scores, cls_inds else: txtytwth_pred = txtytwth_pred.view(B, H*W, self.anchor_number, 4) # decode bbox, and remember to cancel its grad since we set iou as the label of objectness. with torch.no_grad(): x1y1x2y2_pred = (self.decode_boxes(txtytwth_pred) / self.scale_torch).view(-1, 4) txtytwth_pred = txtytwth_pred.view(B, H*W*self.anchor_number, 4) x1y1x2y2_gt = target[:, :, 7:].view(-1, 4) # compute iou iou = tools.iou_score(x1y1x2y2_pred, x1y1x2y2_gt).view(B, H*W*self.anchor_number, 1) # print(iou.min(), iou.max()) # we set iou between pred bbox and gt bbox as conf label. # [obj, cls, txtytwth, x1y1x2y2] -> [conf, obj, cls, txtytwth] target = torch.cat([iou, target[:, :, :7]], dim=2) conf_loss, cls_loss, txtytwth_loss, total_loss = tools.loss(pred_conf=conf_pred, pred_cls=cls_pred, pred_txtytwth=txtytwth_pred, label=target, num_classes=self.num_classes) return conf_loss, cls_loss, txtytwth_loss, total_loss
def loss(xs, xt, ys): def mean_sigmoid_cross_entropy_with_logits(logit, truth): ''' truth: 0. or 1. ''' return tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logit, labels=truth * tf.ones_like(logit))) #source domain with tf.variable_scope("Encoder"): z_mu, z_lv, y_predict = Encoder(xs, z_dim=256,n_class=10) z = tools.GaussianSampleLayer(z_mu, z_lv) # direct sample z_direct = tf.random_normal(shape=tf.shape(z_mu)) with tf.variable_scope("Generator"): xz = Generator(z_direct) with tf.variable_scope("Discriminator"): logit_fake_xz,_ = Discriminator(xz) # with tf.variable_scope("Generator", reuse=True): xh = Generator(z) with tf.variable_scope("Discriminator", reuse=True): logit_true, x_through_D = Discriminator(xs, reuse=True) with tf.variable_scope("Discriminator", reuse=True): logit_fake, xh_through_D = Discriminator(xh, reuse=True) # target domain with tf.variable_scope("Encoder", reuse=True): z_mu_t,_, yt_predict = Encoder(xt, z_dim=256,n_class=10) with tf.variable_scope("Generator", reuse=True): xh_t = Generator(z_mu_t, reuse=True) with tf.variable_scope("Discriminator", reuse=True): logit_fake_t, _ = Discriminator(xh_t, reuse=True) loss = dict() loss['D_real'] = \ mean_sigmoid_cross_entropy_with_logits(logit_true, 1.) loss['D_fake'] = 0.5 * ( mean_sigmoid_cross_entropy_with_logits(logit_fake, 0.) +\ mean_sigmoid_cross_entropy_with_logits(logit_fake_xz, 0.)) loss['G_fake'] = 0.5 * ( mean_sigmoid_cross_entropy_with_logits(logit_fake, 1.) +\ mean_sigmoid_cross_entropy_with_logits(logit_fake_xz, 1.)) loss['KL(z)'] = tf.reduce_mean( tools.GaussianKLD( z_mu, z_lv, tf.zeros_like(z_mu), tf.zeros_like(z_lv))) loss['Dis'] = - tf.reduce_mean( tools.GaussianLogDensity( x_through_D, xh_through_D, tf.zeros_like(xh_through_D))) ys = tf.cast(ys, tf.float32) y_predict= tf.cast(y_predict, tf.float32) loss['C_predict'] = tools.loss(ys,y_predict ) loss['MMD'] = tf.abs(tf.reduce_mean(tf.abs(z_mu-z_mu_t))) loss['D_fake_t'] = mean_sigmoid_cross_entropy_with_logits(logit_fake_t, 0.) return loss, yt_predict
def mytrain(): # pre_trained_weights = './VGG16_pretrain/vgg16.npy' data_dir = '/content/data/' train_log_dir = './logs2/train/' val_log_dir = './logs2/val/' with tf.name_scope('input'): train_image_batch, train_label_batch = input_data.read_cifar10( data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) logits = VGG.Myvgg(train_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, train_label_batch) accuracy = tools.accuracy(logits, train_label_batch) my_global_step = tf.Variable(0, trainable=False, name='global_step') train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(dtype=tf.int32, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load pretrain weights # tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) train_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break train_images, train_labels = sess.run( [train_image_batch, train_label_batch]) #print(train_images.shape,train_labels) _, train_loss, train_accuracy = sess.run( [train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels }) if step % 128 == 0 or (step + 1) == MAX_STEP: print("Step: %d, loss: %.8f, accuracy: %.4f%%" % (step, train_loss, train_accuracy)) summary_str = sess.run(summary_op) train_summary_writer.add_summary(summary_str, step) if step % 128 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_accuracy = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print("** Step: %d, loss: %.8f, test_accuracy: %.4f%%" % (step, val_loss, val_accuracy)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, save_path=checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limited reached') finally: coord.request_stop() coord.join(threads) sess.close()
def test(test_dir, checkpoint_dir='./checkpoint/'): import json # predict the result test_images = os.listdir(test_dir) features = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) labels = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) # one_hot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=80) # train_step, cross_entropy, logits, keep_prob = network.inference(features, one_hot_labels) resnet = ResNet.ResNet() _, logits = resnet.build(features, N_CLASSES, last_layer_type="softmax") loss = tools.loss(logits, labels) accuracy = tools.accuracy(logits, labels) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) values, indices = tf.nn.top_k(logits, 3) keep_prob = tf.placeholder(tf.float32) with tf.Session() as sess: saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: print('Restore the model from checkpoint %s' % ckpt.model_checkpoint_path) # Restores from checkpoint saver.restore(sess, ckpt.model_checkpoint_path) start_step = int( ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]) else: raise Exception('no checkpoint find') result = [] test_imglist = [] for test_image in test_images: test_imgpath = os.path.join(test_dir, test_image) test_imglist.append(test_imgpath) image = tf.cast(test_imglist, tf.string) # make a input queue input_queue = tf.train.slice_input_producer([image]) image_contents = tf.read_file(input_queue[0]) image = tf.image.decode_jpeg(image_contents, channels=3) ################################################# # data agumentation should go to here ################################################# image = tf.image.resize_image_with_crop_or_pad(image, IMG_W, IMG_H) image = tf.image.per_image_standardization(image) # image_batch, label_batch = tf.train.batch([image, label], # batch_size=batch_size, # num_threads=64, # capacity=capacipy) image_batch = tf.train.shuffle_batch([image], batch_size=1, num_threads=64, capacity=CAPACITY, min_after_dequeue=200) image_batch = tf.cast(image_batch, tf.float32) img = sess.run([image_batch]) for i in range(len(img)): x = img[i] temp_dict = {} # x = scene_input.img_resize(os.path.join(test_dir, test_image), IMG_W) predictions = np.squeeze(sess.run(indices, feed_dict={ features: np.expand_dims(x, axis=0), keep_prob: 1 }), axis=0) temp_dict['image_id'] = test_image temp_dict['label_id'] = predictions.tolist() result.append(temp_dict) print('image %s is %d,%d,%d' % (test_image, predictions[0], predictions[1], predictions[2])) with open('submit.json', 'w') as f: json.dump(result, f) print('write result json, num is %d' % len(result))
with tf.name_scope('weight4'): weight4 = tools.variable_with_weight_loss(shape=[384, 192], stddev=0.04, w1=0.004) with tf.name_scope('bias4'): bias4 = tf.Variable(tf.constant(0.1, shape=[192])) local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4) with tf.name_scope('inference'): with tf.name_scope('weight5'): weight5 = tools.variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, w1=0.0) with tf.name_scope('bias5'): bias5 = tf.Variable(tf.constant(0.0, shape=[10])) logits = tf.add(tf.matmul(local4, weight5), bias5) with tf.name_scope('loss_func'): #求出全部的loss loss = tools.loss(logits, label_holder) tf.summary.scalar('loss', loss) with tf.name_scope('train_step'): #调用优化方法Adam,这里学习率是直接设定的自行可以decay尝试一下 # train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=step) train_op = tf.train.AdamOptimizer(1e-3).minimize(loss, global_step=step) top_k_op = tf.nn.in_top_k(logits, label_holder, 1) #创建会话 sess = tf.InteractiveSession() #变量初始化 tf.global_variables_initializer().run() #合并全部的summary merged = tf.summary.merge_all() #将日志文件写入LOG_DIR中
def train(net, device): global cfg, hr # set GPU use_focal = False if args.use_focal == 1: print("Let's use focal loss for objectness !!!") use_focal = True if args.multi_scale == 1: print('Let us use the multi-scale trick.') ms_inds = range(len(cfg['multi_scale'])) dataset = COCODataset(data_dir=data_dir, img_size=608, transform=SSDAugmentation([608, 608], MEANS), debug=args.debug) else: dataset = COCODataset(data_dir=data_dir, img_size=cfg['min_dim'][0], transform=SSDAugmentation(cfg['min_dim'], MEANS), debug=args.debug) print("Setting Arguments.. : ", args) print("----------------------------------------------------------") print('Loading the MSCOCO dataset...') print('Training model on:', dataset.name) print('The dataset size:', len(dataset)) print('The obj weight : ', args.obj) print('The noobj weight : ', args.noobj) print("----------------------------------------------------------") input_size = cfg['min_dim'] num_classes = args.num_classes batch_size = args.batch_size save_folder = args.save_folder if not os.path.exists(save_folder): os.mkdir(save_folder) # using tfboard from tensorboardX import SummaryWriter c_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) log_path = 'log/yolo_v2/coco/' + c_time if not os.path.exists(log_path): os.mkdir(log_path) if not os.path.exists(log_path): os.mkdir(log_path) writer = SummaryWriter(log_path) if args.high_resolution == 1: hr = True print('Let us train yolo-v2 on the MSCOCO dataset ......') model = net model.to(device).train() dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, collate_fn=detection_collate, num_workers=args.n_cpu) evaluator = COCOAPIEvaluator(data_dir=data_dir, img_size=cfg['min_dim'], device=device, transform=BaseTransform( cfg['min_dim'], MEANS)) # optimizer setup # optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, # dampening=0, weight_decay=args.weight_decay) # optimizer = optim.Adam(model.parameters()) lr = args.lr optimizer = optim.RMSprop(model.parameters(), lr=args.lr) step_index = 0 epoch_size = len(dataset) // args.batch_size # each part of loss weight obj_w = 1.0 cla_w = 1.0 box_w = 2.0 # start training loop iteration = 0 for epoch in range(cfg['max_epoch']): batch_iterator = iter(dataloader) # No WarmUp strategy or WarmUp tage has finished. if epoch in cfg['lr_epoch']: step_index += 1 lr = adjust_learning_rate(optimizer, args.gamma, step_index) # COCO evaluation if (epoch + 1) % args.eval_epoch == 0: model.trainable = False ap50_95, ap50 = evaluator.evaluate(model) print('ap50 : ', ap50) print('ap90_95 : ', ap50_95) model.trainable = True model.train() writer.add_scalar('val/COCOAP50', ap50, epoch + 1) writer.add_scalar('val/COCOAP50_95', ap50_95, epoch + 1) # subdivision loop optimizer.zero_grad() for images, targets in batch_iterator: iteration += 1 # multi-scale trick if iteration % 10 == 0 and args.multi_scale == 1: ms_ind = random.sample(ms_inds, 1)[0] input_size = cfg['multi_scale'][int(ms_ind)] # multi scale if args.multi_scale == 1: images = torch.nn.functional.interpolate(images, size=input_size, mode='bilinear', align_corners=True) targets = [label.tolist() for label in targets] if args.version == 'yolo_v2': targets = tools.gt_creator(input_size, yolo_net.stride, args.num_classes, targets, name='COCO') elif args.version == 'yolo_v3': targets = tools.multi_gt_creator(input_size, yolo_net.stride, args.num_classes, targets, name='COCO') targets = torch.tensor(targets).float().to(device) t0 = time.time() out = model(images.to(device)) obj_loss, class_loss, box_loss = tools.loss( out, targets, num_classes=args.num_classes, use_focal=use_focal, obj=args.obj, noobj=args.noobj) total_loss = obj_w * obj_loss + cla_w * class_loss + box_w * box_loss # viz loss writer.add_scalar('object loss', obj_loss.item(), iteration) writer.add_scalar('class loss', class_loss.item(), iteration) writer.add_scalar('local loss', box_loss.item(), iteration) writer.add_scalar('total loss', total_loss.item(), iteration) # backprop total_loss.backward() optimizer.step() t1 = time.time() if iteration % 10 == 0: print('timer: %.4f sec.' % (t1 - t0)) # print(obj_loss.item(), class_loss.item(), box_loss.item()) print('Epoch[%d / %d]' % (epoch+1, cfg['max_epoch']) + ' || iter ' + repr(iteration) + \ ' || Loss: %.4f ||' % (total_loss.item()) + ' || lr: %.8f ||' % (lr) + ' || input size: %d ||' % input_size[0], end=' ') if (epoch + 1) % 10 == 0: print('Saving state, epoch:', epoch + 1) torch.save( yolo_net.state_dict(), save_folder + '/' + args.version + '_' + repr(epoch + 1) + '.pth')
def train(): ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH) train_tfrecords = TFRECORDS_PATH + 'train2.tfrecords' val_tfrecords = TFRECORDS_PATH + 'val.tfrecords' train_image_batch, train_label_batch = input_data.get_batch( train_tfrecords, BATCH_SIZE) val_image_batch, val_label_batch = input_data.get_batch( val_tfrecords, BATCH_SIZE) x = tf.placeholder(tf.float32, [BATCH_SIZE, WIDTH, HEIGHT, CHANNEL], name='x-input') y_ = tf.placeholder(tf.float32, [BATCH_SIZE, NUM_CLASSES], name='y-input') if ckpt and ckpt.model_checkpoint_path: num_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] num_step = int(num_step) print(num_step) global_step = tf.Variable(num_step, trainable=False) else: global_step = tf.Variable(0, trainable=False) regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE) y = model.inference(x, NUM_CLASSES, regularizer=regularizer) train_loss = tools.loss(logits=y, labels=y_) train_acc = tools.accuracy(logits=y, labels=y_) train_op = tools.optimizer(train_loss, LEARNING_RATE, global_step=global_step) saver = tf.train.Saver() with tf.Session() as sess: if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) else: tf.global_variables_initializer().run() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(LOG_TRAIN_PATH, sess.graph) val_writer = tf.summary.FileWriter(LOG_VAL_PATH, sess.graph) try: for i in range(TRAINING_STEPS): if coord.should_stop(): break xs, ys = sess.run([train_image_batch, train_label_batch]) _, loss_value, acc_value, step = sess.run( [train_op, train_loss, train_acc, global_step], feed_dict={ x: xs, y_: ys }) if i % 1 == 0: print( "After %d training step(s), loss on training batch is %g, accuracy is %g" % (step, loss_value, acc_value)) if i % 1 == 0: summary_str = sess.run(summary_op, feed_dict={ x: xs, y_: ys }) train_writer.add_summary(summary_str, step) if i % 5 == 0: val_xs, val_ys = sess.run( [val_image_batch, val_label_batch]) val_loss_value, val_acc_value = sess.run( [train_loss, train_acc], feed_dict={ x: val_xs, y_: val_ys }) print( "After %d training step(s), valuation loss is %g, accuracy is %g" % (step, val_loss_value, val_acc_value)) summary_str = sess.run(summary_op, feed_dict={ x: val_xs, y_: val_ys }) val_writer.add_summary(summary_str, step) if i % 10 == 0 or step + 1 == TRAINING_STEPS: saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train(): pre_trained_weights = '/home/xiaoyi/data/LED/VGG16_pretrained/vgg16.npy' large_dir = '/home/xiaoyi/data/LED/data/train/train_large_crop/' small_dir = '/home/xiaoyi/data/LED/data/train/train_small_crop/' val_large_dir = '/home/xiaoyi/data/LED/test/test_large/' val_small_dir = '/home/xiaoyi/data/LED/test/test_small/' train_log_dir = '/home/xiaoyi/data/LED/logs1/train/' val_log_dir = '/home/xiaoyi/data/LED/logs1/val/' with tf.name_scope('input'): train, train_laebl = input_data.get_files(large_dir, small_dir) train_batch, train_label_batch = input_data.get_batch( train, train_laebl, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val, val_label = input_data.get_files(val_large_dir, val_small_dir) val_batch, val_label_batch = input_data.get_batch( val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) logits = VGG.VGG16N(train_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, train_label_batch) accuracy = tools.accuracy(logits, train_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d,loss:%.4f,accuracy:%.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print('** Step %d,val loss = %.2f,val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
outputs = tools.FC_layer('fc6', outputs, out_nodes=1024, activaction_function=tf.nn.relu) outputs = tools.batch_norm(outputs) outputs = tools.FC_layer('fc7', outputs, out_nodes=1024, activaction_function=tf.nn.relu) outputs = tools.batch_norm(outputs) logits = tools.FC_layer('fc8', outputs, out_nodes=10, activaction_function=tf.nn.softmax) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) sess = tf.Session() sess.run(tf.global_variables_initializer()) summary_op = tf.summary.merge_all() tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) for step in range(MAX_STEP): batch_xs, batch_ys = mnist.train.next_batch(100) #采用minbatch自助放回采样 _train_r, _train_acc, _train_loss = sess.run( [train_op, accuracy, loss], feed_dict={ x: batch_xs,
def train(net, device): global cfg, hr # set GPU use_focal = False if args.use_focal: print("Let's use focal loss for objectness !!!") use_focal = True if args.multi_scale: print('Let us use the multi-scale trick.') ms_inds = range(len(cfg['multi_scale'])) dataset = COCODataset( data_dir=data_dir, img_size=608, transform=SSDAugmentation([608, 608], mean=(0.406, 0.456, 0.485), std=(0.225, 0.224, 0.229)), debug=args.debug) else: dataset = COCODataset( data_dir=data_dir, img_size=cfg['min_dim'][0], transform=SSDAugmentation(cfg['min_dim'], mean=(0.406, 0.456, 0.485), std=(0.225, 0.224, 0.229)), debug=args.debug) print("Setting Arguments.. : ", args) print("----------------------------------------------------------") print('Loading the MSCOCO dataset...') print('Training model on:', dataset.name) print('The dataset size:', len(dataset)) print('The obj weight : ', args.obj) print('The noobj weight : ', args.noobj) print("----------------------------------------------------------") input_size = cfg['min_dim'] num_classes = args.num_classes batch_size = args.batch_size os.makedirs(args.save_folder + args.version, exist_ok=True) # using tfboard from tensorboardX import SummaryWriter c_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())) log_path = 'log/coco/' + c_time os.makedirs(log_path, exist_ok=True) writer = SummaryWriter(log_path) if args.high_resolution == 1: hr = True print('Let us train yolo-v2 on the MSCOCO dataset ......') model = net model.to(device).train() dataloader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=True, collate_fn=detection_collate, num_workers=args.n_cpu) evaluator = COCOAPIEvaluator( data_dir=data_dir, img_size=cfg['min_dim'], device=device, transform=BaseTransform(cfg['min_dim'], MEANS) ) # optimizer setup lr = args.lr # optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum, # weight_decay=args.weight_decay) # optimizer = optim.Adam(model.parameters()) optimizer = optim.RMSprop(model.parameters(), lr=args.lr) step_index = 0 epoch_size = len(dataset) // args.batch_size # each part of loss weight obj_w = 1.0 cla_w = 1.0 box_w = 1.0 # start training loop iteration = 0 t0 = time.time() for epoch in range(cfg['max_epoch']): batch_iterator = iter(dataloader) # use cos lr if args.cos and epoch > 20 and epoch <= cfg['max_epoch'] - 20: # use cos lr lr = cos_lr(optimizer, epoch, cfg['max_epoch']) elif args.cos and epoch > cfg['max_epoch'] - 20: lr = 0.00001 for param_group in optimizer.param_groups: param_group['lr'] = lr # use step lr else: if epoch in cfg['lr_epoch']: step_index += 1 lr = adjust_learning_rate(optimizer, args.gamma, step_index) # COCO evaluation if (epoch + 1) % args.eval_epoch == 0: model.trainable = False ap50_95, ap50 = evaluator.evaluate(model) print('ap50 : ', ap50) print('ap50_95 : ', ap50_95) model.trainable = True model.train() writer.add_scalar('val/COCOAP50', ap50, epoch + 1) writer.add_scalar('val/COCOAP50_95', ap50_95, epoch + 1) # subdivision loop for images, targets in batch_iterator: # WarmUp strategy for learning rate if not args.no_warm_up == 'yes': if epoch < args.wp_epoch: lr = warmup_strategy(optimizer, epoch_size, iteration) iteration += 1 # multi-scale trick if iteration % 10 == 0 and args.multi_scale: ms_ind = random.sample(ms_inds, 1)[0] input_size = cfg['multi_scale'][int(ms_ind)] # multi scale if args.multi_scale: images = torch.nn.functional.interpolate(images, size=input_size, mode='bilinear', align_corners=True) targets = [label.tolist() for label in targets] if args.version == 'yolo_v2' or args.version == 'tiny_yolo_v2': targets = tools.gt_creator(input_size, yolo_net.stride, targets, name='COCO') elif args.version == 'yolo_v3' or args.version == 'tiny_yolo_v3': targets = tools.multi_gt_creator(input_size, yolo_net.stride, targets, name='COCO') targets = torch.tensor(targets).float().to(device) out = model(images.to(device)) optimizer.zero_grad() obj_loss, class_loss, box_loss = tools.loss(out, targets, num_classes=args.num_classes, use_focal=use_focal, obj=args.obj, noobj=args.noobj) total_loss = obj_w * obj_loss + cla_w * class_loss + box_w * box_loss # viz loss writer.add_scalar('object loss', obj_loss.item(), iteration) writer.add_scalar('class loss', class_loss.item(), iteration) writer.add_scalar('local loss', box_loss.item(), iteration) writer.add_scalar('total loss', total_loss.item(), iteration) # backprop total_loss.backward() optimizer.step() if iteration % 10 == 0: t1 = time.time() print('[Epoch %d/%d][Iter %d][lr %.8f]' '[Loss: obj %.2f || cls %.2f || bbox %.2f || total %.2f || imgsize %d || time: %.2f]' % (epoch+1, cfg['max_epoch'], iteration, lr, obj_loss.item(), class_loss.item(), box_loss.item(), total_loss.item(), input_size[0], t1-t0), flush=True) t0 = time.time() if (epoch + 1) % 10 == 0: print('Saving state, epoch:', epoch + 1) torch.save(yolo_net.state_dict(), os.path.join(args.save_folder + args.version, args.version + '_' + repr(epoch + 1) + '.pth') )
def train_aid(): pre_trained_weights = r'/media/jsl/ubuntu/pretrain_weight/vgg16.npy' data_train_dir = os.path.join(config.aid_data_root_path, 'train') data_test_dir = os.path.join(config.aid_data_root_path, 'val') train_log_dir = os.path.join(config.aid_log_root_path, 'train') val_log_dir = os.path.join(config.aid_log_root_path, 'val') with tf.name_scope('input'): image_train_list, label_train_list = get_files(data_train_dir) image_val_list, label_val_list = get_files(data_test_dir) image_batch, label_batch = get_batch(image_train_list, label_train_list, config.aid_img_weight, config.aid_img_height, BATCH_SIZE, CAPACITY) val_image_batch, val_label_batch = get_batch(image_val_list, label_val_list, config.aid_img_weight, config.aid_img_height, BATCH_SIZE, CAPACITY) x = tf.placeholder( tf.float32, shape=[BATCH_SIZE, config.aid_img_weight, config.aid_img_height, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, config.aid_n_class]) logits = VGG.VGG16N(x, config.aid_n_class, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) start_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(time.time())) print('start_time:', start_time) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([image_batch, label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close() end_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(time.time())) print('end_time:', end_time)
def forward(self, x, target=None): # backbone c3, c4, c5 = self.backbone(x) # FPN, 多尺度特征融合 p5 = self.conv_set_3(c5) p5_up = F.interpolate(self.conv_1x1_3(p5), scale_factor=2.0, mode='bilinear', align_corners=True) p4 = torch.cat([c4, p5_up], 1) p4 = self.conv_set_2(p4) p4_up = F.interpolate(self.conv_1x1_2(p4), scale_factor=2.0, mode='bilinear', align_corners=True) p3 = torch.cat([c3, p4_up], 1) p3 = self.conv_set_1(p3) # head # s = 32, 预测大物体 p5 = self.extra_conv_3(p5) pred_3 = self.pred_3(p5) # s = 16, 预测中物体 p4 = self.extra_conv_2(p4) pred_2 = self.pred_2(p4) # s = 8, 预测小物体 p3 = self.extra_conv_1(p3) pred_1 = self.pred_1(p3) preds = [pred_1, pred_2, pred_3] total_conf_pred = [] total_cls_pred = [] total_txtytwth_pred = [] B = HW = 0 for pred in preds: B_, abC_, H_, W_ = pred.size() # 对pred 的size做一些view调整,便于后续的处理 # [B, anchor_n * C, H, W] -> [B, H, W, anchor_n * C] -> [B, H*W, anchor_n*C] pred = pred.permute(0, 2, 3, 1).contiguous().view(B_, H_ * W_, abC_) # 从pred中分离出objectness预测、类别class预测、bbox的txtytwth预测 # [B, H*W*anchor_n, 1] conf_pred = pred[:, :, :1 * self.num_anchors].contiguous().view( B_, H_ * W_ * self.num_anchors, 1) # [B, H*W*anchor_n, num_cls] cls_pred = pred[:, :, 1 * self.num_anchors:(1 + self.num_classes) * self.num_anchors].contiguous().view( B_, H_ * W_ * self.num_anchors, self.num_classes) # [B, H*W*anchor_n, 4] txtytwth_pred = pred[:, :, (1 + self.num_classes) * self.num_anchors:].contiguous() total_conf_pred.append(conf_pred) total_cls_pred.append(cls_pred) total_txtytwth_pred.append(txtytwth_pred) B = B_ HW += H_ * W_ # 将所有结果沿着H*W这个维度拼接 conf_pred = torch.cat(total_conf_pred, dim=1) cls_pred = torch.cat(total_cls_pred, dim=1) txtytwth_pred = torch.cat(total_txtytwth_pred, dim=1) # train if self.trainable: txtytwth_pred = txtytwth_pred.view(B, HW, self.num_anchors, 4) # 从txtytwth预测中解算出x1y1x2y2坐标 x1y1x2y2_pred = (self.decode_boxes(txtytwth_pred) / self.input_size).view(-1, 4) x1y1x2y2_gt = target[:, :, 7:].view(-1, 4) # 计算pred box与gt box之间的IoU iou_pred = tools.iou_score(x1y1x2y2_pred, x1y1x2y2_gt).view(B, -1, 1) # gt conf,这一操作是保证iou不会回传梯度 with torch.no_grad(): gt_conf = iou_pred.clone() # 我们讲pred box与gt box之间的iou作为objectness的学习目标. # [obj, cls, txtytwth, scale_weight, x1y1x2y2] -> [conf, obj, cls, txtytwth, scale_weight] target = torch.cat([gt_conf, target[:, :, :7]], dim=2) txtytwth_pred = txtytwth_pred.view(B, -1, 4) # 计算loss conf_loss, cls_loss, bbox_loss, iou_loss = tools.loss( pred_conf=conf_pred, pred_cls=cls_pred, pred_txtytwth=txtytwth_pred, pred_iou=iou_pred, label=target) return conf_loss, cls_loss, bbox_loss, iou_loss # test else: txtytwth_pred = txtytwth_pred.view(B, HW, self.num_anchors, 4) with torch.no_grad(): # batch size = 1 # 测试时,笔者默认batch是1, # 因此,我们不需要用batch这个维度,用[0]将其取走。 # [B, H*W*num_anchor, 1] -> [H*W*num_anchor, 1] conf_pred = torch.sigmoid(conf_pred)[0] # [B, H*W*num_anchor, 4] -> [H*W*num_anchor, 4] bboxes = torch.clamp( (self.decode_boxes(txtytwth_pred) / self.input_size)[0], 0., 1.) # [B, H*W*num_anchor, C] -> [H*W*num_anchor, C], scores = torch.softmax(cls_pred[0, :, :], dim=1) * conf_pred # 将预测放在cpu处理上,以便进行后处理 scores = scores.to('cpu').numpy() bboxes = bboxes.to('cpu').numpy() # 后处理 bboxes, scores, cls_inds = self.postprocess(bboxes, scores) return bboxes, scores, cls_inds
def test_dataset(): test_img_path = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny' test_rs_img(test_img_path) class_folder = 'tenniscourt' class_folder_path = r'/home/vincent/Desktop/jsl thesis/GradTest_vinny/UCM/dataset_rotated/validation/' + class_folder test_img_list, test_label_list = get_one_class_files(class_folder_path) # test_img_batch, test_label_batch = get_one_class_batch_new(test_img_list, test_label_list, # config.img_Width, # config.img_Height, # config.test_batch_size, 256) path_batch, image_batch, label_batch = get_one_class_batch_new( test_img_list, test_label_list, config.test_batch_size, 256) x = tf.placeholder( tf.float32, shape=[config.test_batch_size, config.img_Width, config.img_Height, 3]) y_ = tf.placeholder(tf.int16, shape=[config.test_batch_size, config.n_class]) logits = VGG.VGG16N(x, config.n_class, False) predict = tf.argmax(logits, 1) true_label = tf.argmax(label_batch, 1) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) saver = tf.train.Saver() ckpt = tf.train.get_checkpoint_state(config.checkpoint_path) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] print('step: ', global_step) i = 0 with tf.Session() as sess: i = 0 saver.restore(sess, ckpt.model_checkpoint_path) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) try: while not coord.should_stop() and i < 1: path_test, img_test, label_test = sess.run( [path_batch, image_batch, label_batch]) true_label_test = sess.run(true_label) acc, pred_test = sess.run([accuracy, predict], feed_dict={ x: img_test, y_: label_test }) str_acc = class_folder + str(acc) + '\r\n' print(acc) i += 1 for index in range(len(pred_test)): if true_label_test[index] != pred_test[index]: str_acc += path_test[index].decode( 'utf-8' ) + ':' + config.get_class_name_by_index( pred_test[index]) + '\r\n' except tf.errors.OutOfRangeError: print('done!') finally: coord.request_stop() coord.join(threads) with open(class_folder + '.txt', 'w') as fp: fp.write(str_acc)
def train(): with tf.name_scope('input'): train, train_label, val, val_label = input_train_val_split.get_files( train_dir, RATIO) tra_image_batch, tra_label_batch = input_train_val_split.get_batch( train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_image_batch, val_label_batch = input_train_val_split.get_batch( val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) tools.load_with_skip(pre_trained_weights, sess, ['fc8']) print("load weights done") coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 2 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: tra_images, y_: tra_labels }) tra_summary_writer.add_summary(summary_str, step) if step % 4 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) _, summary_str = sess.run([train_op, summary_op], feed_dict={ x: val_images, y_: val_labels }) val_summary_writer.add_summary(summary_str, step) if step % 8 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def forward(self, x, target=None): # backbone c2, c3, c4, c5 = self.backbone(x) B = c2.size(0) # FPN deconv c5 = self.smooth5(c5) c4 = self.smooth4(c4 + self.deconv5(c5)) c3 = self.smooth3(c3 + self.deconv4(c4)) c2 = self.smooth2(c2 + self.deconv3(c3)) # head conf_pred = self.conf_pred(c2) txty_pred = self.txty_pred(c2) twth_pred = self.twth_pred(c2) # train if self.trainable: # [B, H*W, num_classes] conf_pred = conf_pred.permute(0, 2, 3, 1).contiguous().view(B, -1, 1) # [B, H*W, 2] txty_pred = txty_pred.permute(0, 2, 3, 1).contiguous().view(B, -1, 2) # [B, H*W, 2] twth_pred = twth_pred.permute(0, 2, 3, 1).contiguous().view(B, -1, 2) # [B, H*W, 4] txtytwth_pred = torch.cat([txty_pred, twth_pred], dim=2) # compute loss conf_loss, txtytwth_loss, total_loss = tools.loss( pred_conf=conf_pred, pred_txtytwth=txtytwth_pred, label=target, version='CenterYOLAF') return conf_loss, txtytwth_loss, total_loss # test else: with torch.no_grad(): txtytwth_pred = torch.cat([txty_pred, twth_pred], dim=1) # decode conf_pred = torch.sigmoid(conf_pred[:, :1, :, :]) txtytwth_pred = txtytwth_pred.permute(0, 2, 3, 1).contiguous().view( B, -1, 4) # simple nms hmax = F.max_pool2d(conf_pred, 5, stride=1, padding=2) keep = (hmax == conf_pred).float() conf_pred *= keep # threshold conf_pred *= (conf_pred >= self.conf_thresh).float() # [B, C, H, W] -> [H, W] score = conf_pred[0, 0, :, :] # top K topk_scores, topk_inds = torch.topk(score.view(-1), self.topk) # decode bbox all_bbox = torch.clamp( (self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) all_bbox = all_bbox[topk_inds] # separate box pred and class conf scores = topk_scores.cpu().numpy() bboxes = all_bbox.cpu().numpy() return bboxes, scores
def train(): step = 0 #step bs = 128 #batch size pre_trained_weights = main_dir + 'vgg16.npy' #vgg16 weight train_log_dir = main_dir + 'trainloggm1rss/tlog' #train log path val_log_dir = main_dir + 'trainloggm1rss/vlog' # val log path train_data_dir = main_dir + 'ymodellog' # save model path # rd=main_dir+'modellog' #train data tra_filename = np.load(main_dir + "sf_filename.npy") tra_label = np.load(main_dir + "sf_label.npy") tra_vector = np.load(main_dir + "sf_vector.npy") tra_4 = np.load(main_dir + "sf_4.npy") #val data val_filename = np.load(main_dir + "sf_gm1vfilename.npy") val_label = np.load(main_dir + "sf_gm1vlabel.npy") val_vector = np.load(main_dir + "sf_gm1vvector.npy") val_4 = np.load(main_dir + "sf_gm1v4.npy") with tf.Graph().as_default() as g: tra_image_p = tf.placeholder(tra_filename.dtype, tra_filename.shape) tra_label_p = tf.placeholder(tra_label.dtype, tra_label.shape) tra_vector_p = tf.placeholder(tra_vector.dtype, tra_vector.shape) tra_4_p = tf.placeholder(tra_4.dtype, tra_4.shape) tdataset = tf.contrib.data.Dataset.from_tensor_slices( (tra_image_p, tra_label_p, tra_vector_p, tra_4_p)) tdataset = tdataset.map(pre_function, num_threads=64) tdataset = tdataset.shuffle(1024 * 16) tdataset = tdataset.repeat() #重复 tdataset = tdataset.batch(bs) tra_iterator = tdataset.make_initializable_iterator() val_image_p = tf.placeholder(val_filename.dtype, val_filename.shape) val_label_p = tf.placeholder(val_label.dtype, val_label.shape) val_vector_p = tf.placeholder(val_vector.dtype, val_vector.shape) val_4_p = tf.placeholder(val_4.dtype, val_4.shape) vdataset = tf.contrib.data.Dataset.from_tensor_slices( (val_image_p, val_label_p, val_vector_p, val_4_p)) vdataset = vdataset.map(pre_function) vdataset = vdataset.repeat() #重复 vdataset = vdataset.batch(bs) val_iterator = vdataset.make_initializable_iterator() # Generate placeholders for the images and labels. x = tf.placeholder(tf.float32, shape=[bs, 224, 224, 3]) v = tf.placeholder(tf.float32, shape=[bs, 280]) y_ = tf.placeholder(tf.int32, shape=[bs, 2]) #?? s_ = tf.placeholder(tf.float32, shape=[bs, 4]) #?? BN_istrain = tf.placeholder(tf.bool) # Build a Graph that computes predictions from the inference model. logits = VGG16N.VGG16N(x, N_CLASSES, v, BN_istrain) # Add to the Graph the Ops for loss calculation. loss, mean_summary, total_loss_summary, loss_averages_op = tools.loss( logits, y_, s_) # Add to the Graph the Ops that calculate and apply gradients. my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, my_global_step, loss_averages_op) # Add the Op to compare the logits to the labels during evaluation. accuracy, accuracy_summary = tools.accuracy(logits, y_) # Build the summary Tensor based on the TF collection of Summaries. summary = tf.summary.merge( [mean_summary, accuracy_summary, total_loss_summary]) # Add the variable initializer Op. saver = tf.train.Saver(max_to_keep=100) init = tf.global_variables_initializer() # Create a saver for writing training checkpoints. # Create a session for running Ops on the Graph. sess = tf.Session() # Instantiate a SummaryWriter to output summaries and the Graph. tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) # And then after everything is built: # Run the Op to initialize the variables. sess.run(init) tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) # sess.run(tra_iterator.initializer, feed_dict={tra_image_p: tra_filename,tra_label_p: tra_label,tra_vector_p: tra_vector}) sess.run(val_iterator.initializer, feed_dict={ val_image_p: val_filename, val_label_p: val_label, val_vector_p: val_vector, val_4_p: val_4 }) tra_next = tra_iterator.get_next() val_next = val_iterator.get_next() print("Reading checkpoints...") for epoch in range(num_epoch): shuu.shu() tra_filename = np.load(main_dir + "gm1sf_filename.npy") tra_label = np.load(main_dir + "gm1sf_label.npy") tra_vector = np.load(main_dir + "gm1sf_vector.npy") tra_4 = np.load(main_dir + "gm1sf_4.npy") sess.run(tra_iterator.initializer, feed_dict={ tra_image_p: tra_filename, tra_label_p: tra_label, tra_vector_p: tra_vector, tra_4_p: tra_4 }) while True: try: for step in range(MAX_STEP): tra_all = sess.run(tra_next) tra_i = tra_all[0] tra_l = tra_all[1] tra_v = tra_all[2] tra_f = tra_all[3] summary_str, _, tra_loss, tra_acc = sess.run( [summary, train_op, loss, accuracy], feed_dict={ x: tra_i, y_: tra_l, v: tra_v, s_: tra_f, BN_istrain: True }) if step % 20 == 0 or (step + 1) == MAX_STEP: tra_summary_writer.add_summary(summary_str, step) # print ('Step: %d, loss: %.4f' % (step, tra_loss)) if step % 20 == 0 or (step + 1) == MAX_STEP: val_all = sess.run(val_next) val_i = val_all[0] val_l = val_all[1] val_v = val_all[2] val_f = val_all[3] val_loss, val_acc = sess.run( [loss, accuracy], feed_dict={ x: val_i, y_: val_l, v: val_v, s_: val_f, BN_istrain: False }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary, feed_dict={ x: val_i, y_: val_l, v: val_v, s_: val_f, BN_istrain: False }) val_summary_writer.add_summary(summary_str, step) # if step == 99: # Record execution stats # run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) # run_metadata = tf.RunMetadata() # summary_str, _= sess.run([summary,train_op], # feed_dict={x:tra_i, y_:tra_l, v:tra_v, BN_istrain:True},options=run_options,run_metadata=run_metadata) # tra_summary_writer.add_run_metadata(run_metadata, 'step%d' % step) # tra_summary_writer.add_summary(summary_str, step) # print('Adding run metadata for', step) if step % 10000 == 0: checkpoint_path = os.path.join( train_data_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: break sess.close()
def validate2(): val_tfrecords = TFRECORDS_PATH + 'test5.tfrecords' val_image_batch, val_label_batch = input_data.get_batch(val_tfrecords, BATCH_SIZE, num_epochs=1) x = tf.placeholder(tf.float32, [BATCH_SIZE, WIDTH, HEIGHT, CHANNEL], name='x-input') y_ = tf.placeholder(tf.float32, [BATCH_SIZE, NUM_CLASSES], name='y-input') y = model.inference2(x, NUM_CLASSES, evaluate=False) predict_y = tf.argmax(y, 1) val_loss = tools.loss(logits=y, labels=y_) val_acc = tools.accuracy(logits=y, labels=y_) saver = tf.train.Saver() with tf.Session() as sess: sess.run([ tf.global_variables_initializer(), tf.local_variables_initializer() ]) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) ckpt = tf.train.get_checkpoint_state(MODEL2_SAVE_PATH) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) global_step = ckpt.model_checkpoint_path.split('/')[-1].split( '-')[-1] global_score = 0. num_step = 0 try: for i in range(TRAINING_STEPS): if coord.should_stop(): break val_xs, val_ys = sess.run( [val_image_batch, val_label_batch]) yy, loss_value, acc_value = sess.run( [predict_y, val_loss, val_acc], feed_dict={ x: val_xs, y_: val_ys }) global_score += acc_value num_step += 1 if i % 5 == 0: print( "in the %dth batch: After %s training step(s), validation accuracy = %g" % (i, global_step, acc_value)) # plot_images(val_xs, val_ys) except tf.errors.OutOfRangeError: print("global accuracy = %g" % (global_score / num_step)) print('Done testing -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def forward(self, x, target=None): # backbone c3, c4, c5 = self.backbone(x) # neck c5 = self.spp(c5) # FPN + PAN # head c6 = self.head_conv_0(c5) c7 = self.head_upsample_0(c6) # s32->s16 c8 = torch.cat([c7, c4], dim=1) c9 = self.head_csp_0(c8) # P3/8 c10 = self.head_conv_1(c9) c11 = self.head_upsample_1(c10) # s16->s8 c12 = torch.cat([c11, c3], dim=1) c13 = self.head_csp_1(c12) # to det # p4/16 c14 = self.head_conv_2(c13) c15 = torch.cat([c14, c10], dim=1) c16 = self.head_csp_2(c15) # to det # p5/32 c17 = self.head_conv_3(c16) c18 = torch.cat([c17, c6], dim=1) c19 = self.head_csp_3(c18) # to det # det pred_s = self.head_det_1(c13) pred_m = self.head_det_2(c16) pred_l = self.head_det_3(c19) preds = [pred_s, pred_m, pred_l] total_conf_pred = [] total_cls_pred = [] total_txtytwth_pred = [] B = HW = 0 for pred in preds: B_, abC_, H_, W_ = pred.size() # [B, anchor_n * C, H, W] -> [B, H, W, anchor_n * C] -> [B, H*W, anchor_n*C] pred = pred.permute(0, 2, 3, 1).contiguous().view(B_, H_ * W_, abC_) # Divide prediction to obj_pred, xywh_pred and cls_pred # [B, H*W*anchor_n, 1] conf_pred = pred[:, :, :1 * self.num_anchors].contiguous().view( B_, H_ * W_ * self.num_anchors, 1) # [B, H*W*anchor_n, num_cls] cls_pred = pred[:, :, 1 * self.num_anchors:(1 + self.num_classes) * self.num_anchors].contiguous().view( B_, H_ * W_ * self.num_anchors, self.num_classes) # [B, H*W*anchor_n, 4] txtytwth_pred = pred[:, :, (1 + self.num_classes) * self.num_anchors:].contiguous() total_conf_pred.append(conf_pred) total_cls_pred.append(cls_pred) total_txtytwth_pred.append(txtytwth_pred) B = B_ HW += H_ * W_ conf_pred = torch.cat(total_conf_pred, dim=1) cls_pred = torch.cat(total_cls_pred, dim=1) txtytwth_pred = torch.cat(total_txtytwth_pred, dim=1) # train if self.trainable: txtytwth_pred = txtytwth_pred.view(B, HW, self.num_anchors, 4) # 从txtytwth预测中解算出x1y1x2y2坐标 x1y1x2y2_pred = (self.decode_boxes(txtytwth_pred) / self.input_size).view(-1, 4) x1y1x2y2_gt = target[:, :, 7:].view(-1, 4) # 计算pred box与gt box之间的IoU iou_pred = tools.iou_score(x1y1x2y2_pred, x1y1x2y2_gt).view(B, -1, 1) # gt conf,这一操作是保证iou不会回传梯度 with torch.no_grad(): gt_conf = iou_pred.clone() # 我们讲pred box与gt box之间的iou作为objectness的学习目标. # [obj, cls, txtytwth, scale_weight, x1y1x2y2] -> [conf, obj, cls, txtytwth, scale_weight] target = torch.cat([gt_conf, target[:, :, :7]], dim=2) txtytwth_pred = txtytwth_pred.view(B, -1, 4) # 计算loss conf_loss, cls_loss, bbox_loss, iou_loss = tools.loss( pred_conf=conf_pred, pred_cls=cls_pred, pred_txtytwth=txtytwth_pred, pred_iou=iou_pred, label=target) return conf_loss, cls_loss, bbox_loss, iou_loss # test else: txtytwth_pred = txtytwth_pred.view(B, HW, self.num_anchors, 4) with torch.no_grad(): # batch size = 1 # 测试时,笔者默认batch是1, # 因此,我们不需要用batch这个维度,用[0]将其取走。 # [B, H*W*num_anchor, 1] -> [H*W*num_anchor, 1] conf_pred = torch.sigmoid(conf_pred)[0] # [B, H*W*num_anchor, 4] -> [H*W*num_anchor, 4] bboxes = torch.clamp( (self.decode_boxes(txtytwth_pred) / self.input_size)[0], 0., 1.) # [B, H*W*num_anchor, C] -> [H*W*num_anchor, C], scores = torch.softmax(cls_pred[0, :, :], dim=1) * conf_pred # 将预测放在cpu处理上,以便进行后处理 scores = scores.to('cpu').numpy() bboxes = bboxes.to('cpu').numpy() # 后处理 bboxes, scores, cls_inds = self.postprocess(bboxes, scores) return bboxes, scores, cls_inds
def forward(self, x, target=None): # backbone c2, c3, c4, c5 = self.backbone(x) B = c5.size(0) # bottom-up p5 = self.spp(c5) p4 = self.deconv5(p5) p3 = self.deconv4(p4) p2 = self.deconv3(p3) # head cls_pred = self.cls_pred(p2) txty_pred = self.txty_pred(p2) twth_pred = self.twth_pred(p2) # train if self.trainable: # [B, H*W, num_classes] cls_pred = cls_pred.permute(0, 2, 3, 1).contiguous().view( B, -1, self.num_classes) # [B, H*W, 2] txty_pred = txty_pred.permute(0, 2, 3, 1).contiguous().view(B, -1, 2) # [B, H*W, 2] twth_pred = twth_pred.permute(0, 2, 3, 1).contiguous().view(B, -1, 2) # compute loss cls_loss, txty_loss, twth_loss, total_loss = tools.loss( pred_cls=cls_pred, pred_txty=txty_pred, pred_twth=twth_pred, label=target, num_classes=self.num_classes) return cls_loss, txty_loss, twth_loss, total_loss # test else: with torch.no_grad(): # batch_size = 1 cls_pred = torch.sigmoid(cls_pred) # simple nms hmax_1 = F.max_pool2d(cls_pred, kernel_size=3, padding=1, stride=1) hmax_2 = F.max_pool2d(cls_pred, kernel_size=5, padding=2, stride=1) hmax = torch.max(hmax_1, hmax_2) keep = (hmax == cls_pred).float() cls_pred *= keep # decode box txtytwth_pred = torch.cat([txty_pred, twth_pred], dim=1).permute(0, 2, 3, 1).contiguous().view( B, -1, 4) # [B, H*W, 4] -> [H*W, 4] bbox_pred = torch.clamp( (self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) # topk topk_scores, topk_inds, topk_clses = self._topk(cls_pred) topk_scores = topk_scores[0].cpu().numpy() topk_ind = topk_clses[0].cpu().numpy() topk_bbox_pred = bbox_pred[topk_inds[0]].cpu().numpy() if self.use_nms: # nms keep = np.zeros(len(topk_bbox_pred), dtype=np.int) for i in range(self.num_classes): inds = np.where(topk_ind == i)[0] if len(inds) == 0: continue c_bboxes = topk_bbox_pred[inds] c_scores = topk_scores[inds] c_keep = self.nms(c_bboxes, c_scores) keep[inds[c_keep]] = 1 keep = np.where(keep > 0) topk_bbox_pred = topk_bbox_pred[keep] topk_scores = topk_scores[keep] topk_ind = topk_ind[keep] return topk_bbox_pred, topk_scores, topk_ind
def train_running(): with tf.Graph().as_default(): with tf.name_scope('input'): mnist = input_data.read_data_sets('../MNIST_data/', one_hot=True) x = tf.placeholder(tf.float32, shape=[None, 784]) x_reshape = tf.reshape(x, [-1, 28, 28, 1]) y_ = tf.placeholder(tf.float32, [None, num_classes]) keep_prob = tf.placeholder(tf.float32) model = models.Model(x_reshape, num_classes) model.lenet5() logits = model.logits loss = tools.loss(logits, y_) regular_loss = tf.add_n(tf.get_collection('loss')) loss = loss + 1e-4 * regular_loss acc = tools.accuracy(logits, y_) train_op = tools.optimize(loss, learning_rate) with tf.Session() as sess: saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) start_time = time.time() print('Training Start...') for step in np.arange(max_step): tra_images, tra_labels = mnist.train.next_batch(batch_size) _, tra_loss, tra_acc = sess.run([train_op, loss, acc], feed_dict={ x: tra_images, y_: tra_labels, keep_prob: 0.5 }) if step % 50 == 0: print( 'Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op, feed_dict={ x: tra_images, y_: tra_labels, keep_prob: 0.5 }) train_writer.add_summary(summary_str, step) # # if step % 200 == 0 or (step + 1) == max_step: val_loss, val_acc = sess.run( [loss, acc], feed_dict={ x: mnist.validation.images, y_: mnist.validation.labels, keep_prob: 1.0 }) print( '** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op, feed_dict={ x: mnist.validation.images, y_: mnist.validation.labels, keep_prob: 1.0 }) val_writer.add_summary(summary_str, step) # if step % 2000 == 0 or (step + 1) == max_step: checkpoint_path = os.path.join(model_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step + 1) end_time = time.time() time_dif = end_time - start_time print('Training end...') print('Time usage: ' + str(timedelta(seconds=int(round(time_dif))))) print('Testing...') test_acc = sess.run(acc, feed_dict={ x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0 }) print('Test accuarcy: %.2f%%' % test_acc)
def train(): # pre_trained_weights1 = './/vgg16.npy' pre_trained_weights = './/vgg-face.mat' data_dir = '/home/hadoop/Desktop/My-TensorFlow-tutorials-master/VGG face segmentation recognition/data/segmentation/training/' train_log_dir = './/logss/train_shuffle/' val_log_dir = './/logss/va_shuffle/' # image_batch, label_batch = notMNIST_input.read_and_decode(tfrecords_file,BATCH_SIZE) image, label = notMNIST_input.get_file(data_dir) # image_batch,label_batch=notMNIST_input.get_batch(image, label, IMG_W, IMG_H, BATCH_SIZE, capacity) X = np.array(image) Y = np.array(label) kf = KFold(n_splits=10, shuffle=False) total_acc = 0 for train, test in kf.split(X, Y): tf.reset_default_graph() image_batch, label_batch = notMNIST_input.get_batch(X[train], Y[train], IMG_W, IMG_H, BATCH_SIZE, capacity, shuffle=True) image_batch_validate, label_batch_validate = notMNIST_input.get_batch( X[test], Y[test], IMG_W, IMG_H, BATCH_SIZE, capacity, shuffle=False) # print("dddd") ## print("train_index: , test_index:", (X[train],Y[train],X[test],Y[test])) print("X[train]/n", len(X[train])) print("Y[train]/n", len(Y[train])) print("X[test]", len(X[test])) print("Y[test]", len(Y[test])) #cast (1.8,3.4)float32 to (1,3)int64 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3], name='place_x') y_ = tf.placeholder(tf.int64, shape=[ BATCH_SIZE, ], name='place_y') logits = VGG.VGG16N(x, N_CLASSES, IS_PRETRAIN) print("****logits shape is ", logits.shape) loss = tools.loss(logits, y_) print("label_batch is ", y_.shape) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) #learning_rate = tf.train.exponential_decay(starter_learning_rate, my_global_step, # 2200, 0.96, staircase=True) train_op = tools.optimize(loss, starter_learning_rate, my_global_step) # train_op_vali = tools.optimize(loss_vali, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) merged_summaries = tf.summary.merge_all() coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir) max_acc = 0 total_time = 0 try: for step in np.arange(MAX_STEP): if coord.should_stop(): break start_time = time.time() # with tf.Session() as sess: # for train, test in kf.split(X,Y): # image_batch,label_batch=notMNIST_input.get_batch(X[train], Y[train], IMG_W, IMG_H, BATCH_SIZE, capacity) # image_batch_validate, label_batch_validate=notMNIST_input.get_batch(X[test], Y[test], IMG_W, IMG_H, BATCH_SIZE, capacity) # label_batch = tf.cast(label_batch,dtype=tf.int64) x_train_a, y_train_a = sess.run([image_batch, label_batch]) x_test_a, y_test_a = sess.run( [image_batch_validate, label_batch_validate]) # _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy]) # tra_images,tra_labels = sess.run([image_batch, label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: x_train_a, y_: y_train_a }) if step % 10 == 0 or (step + 1) == MAX_STEP: feed_dict = {x: x_train_a, y_: y_train_a} summary_str = sess.run(summary_op, feed_dict=feed_dict) tra_summary_writer.add_summary(summary_str, step) time_elapsed = time.time() - start_time print( 'Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)' % (step, tra_loss, tra_acc * 100, time_elapsed)) total_time = total_time + time_elapsed if step % 50 == 0: print('total time is :%.2f' % (total_time)) if step % 200 == 0 or (step + 1) == MAX_STEP: val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: x_test_a, y_: y_test_a }) feed_dict = {x: x_test_a, y_: y_test_a} summary_str = sess.run(summary_op, feed_dict=feed_dict) val_summary_writer.add_summary(summary_str, step) # if cur_val_loss > max_acc: # max_acc = cur_val_loss # best_step = step # checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') # saver.save(sess, checkpoint_path, global_step=step) # val_summary_writer.add_summary(summary, step) # print("Model updated and saved in file: %s" % checkpoint_path) # print ('*************step %5d: loss %.5f, acc %.5f --- loss val %0.5f, acc val %.5f************'%(best_step,tra_loss, tra_acc, cur_val_loss, cur_val_eval)) # print( '************validate result:Step:%d , loss: %.2f, accuracy: %.2f%%(%.2f sec/step)' % (step, val_loss, val_acc * 100, time_elapsed)) if val_acc > max_acc: max_acc = val_acc checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if max_acc > total_acc: total_acc = max_acc checkpoint_path = os.path.join(val_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): pre_trained_weights = './/vgg16_pretrain//vgg16.npy' data_dir = './/data//cifar-10-batches-bin//' train_log_dir = './/logs//train//' val_log_dir = './/logs//val//' with tf.name_scope('input'): tra_image_batch, tra_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=True, batch_size=BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10( data_dir=data_dir, is_train=False, batch_size=BATCH_SIZE, shuffle=False) logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, tra_label_batch) accuracy = tools.accuracy(logits, tra_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run( [tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) if step % 50 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): pre_trained_weights = './vgg16_pretrain/vgg16.npy' train_data_dir = './data/train/scene_train_images_20170904/' train_label_json = './data/train/scene_train_annotations_20170904.json' val_data_dir = './data/val/scene_validation_images_20170908/' val_label_json = './data/val/scene_validation_annotations_20170908.json' train_log_dir = './logs/train/' val_log_dir = './logs/val/' with tf.name_scope('input'): tra_images, tra_labels = input_data.get_files(train_label_json, train_data_dir) tra_image_batch, tra_label_batch = input_data.get_batch( tra_images, tra_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY, N_CLASSES) val_images, val_labels = input_data.get_files(val_label_json, val_data_dir) val_image_batch, val_label_batch = input_data.get_batch( val_images, val_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY, N_CLASSES) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) keep_prob = tf.placeholder(tf.float32) # %% logits = VGG.VGG16N(x, N_CLASSES, keep_prob, IS_PRETRAIN) # #%% # import ResNet # resnet = ResNet.ResNet() # _, logits = resnet.build(x, N_CLASSES, last_layer_type="softmax") # #%% # import InceptionV4 # inception = InceptionV4.InceptionModel(x, [BATCH_SIZE, IMG_W, IMG_H, 3], [BATCH_SIZE, N_CLASSES], keep_prob, # ckpt_path='train_model/model', model_path='saved_model/model') # logits = inception.define_model() # print('shape{}'.format(logits.shape)) loss = tools.loss(logits, y_) accuracy = tools.accuracy(logits, y_) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) saver = tf.train.Saver(tf.global_variables()) # summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers # tools.load_with_skip(pre_trained_weights, sess, ['fc6', 'fc7', 'fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) # tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) # val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break train_images, train_labels = sess.run( [tra_image_batch, tra_label_batch]) # print(str(train_images.get_shape())) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: train_images, y_: train_labels, keep_prob: 0.2 }) if step % 50 == 0 or (step + 1) == MAX_STEP: # _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], # feed_dict={x: train_images, y_: train_labels}) print('Step: %d, loss: %.3f, accuracy: %.3f%%' % (step, tra_loss, tra_acc)) # summary_str = sess.run(summary_op) # tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: validation_images, validation_labels = sess.run( [val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: validation_images, y_: validation_labels, keep_prob: 1 }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) # summary_str = sess.run(summary_op) # val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): data_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/JPG/trainval/' train_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/train/' val_log_dir = '/home/xinlong/Tensorflow_workspace/canjian_AlexNet/log/val/' with tf.name_scope('input'): train, train_label, val, val_label = input_trainval.get_files(data_dir, 0.2) train_batch, train_label_batch = input_trainval.get_batch(train, train_label, IMG_H, IMG_W, BATCH_SIZE, CAPACITY) val_batch, val_label_batch = input_trainval.get_batch(val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_H, IMG_W, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) logits = model_structure.AlexNet(x, 5) loss = tools.loss('loss', y_, logits) accuracy = tools.accuracy('accuracy', y_, logits) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize('optimize', loss, LEARNING_RATE, my_global_step) #?? saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir,sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images, tra_labels = sess.run([train_batch, train_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy],feed_dict={x:tra_images, y_:tra_labels}) if step % 10 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f' %(step, tra_loss, tra_acc)) #summary_str = sess.run(summary_op) #tra_summary_writer.add_summary(summary_str, step) checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) if step % 20 == 0 or (step + 1) == MAX_STEP: valid_images, valid_labels = sess.run([val_batch, val_label_batch]) valid_loss, valid_acc = sess.run([loss, accuracy], feed_dict={x:valid_images, y_:valid_labels}) print( '** step: %d, loss: %.4f, accuracy: %.4f' %(step, valid_loss, valid_acc)) #summary_str = sess.run(summary_op) #val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.error.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)
def train(): print('loding data............') #导入数据 with tf.name_scope('input'): train, train_label, test, test_label = Process.get_data( train_path, test_path) train_batch, train_label_batch = Process.get_batch( train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) test_batch, test_label_batch = Process.get_batch( test, test_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) print('loding batch_data complete.......') #创建placeholder作为输入和标签 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASS]) #定义模型 logits = vgg.VGG16N(x, N_CLASS, IS_PRETRAIN) #定义损失 loss = tools.loss(logits, y_) #计算准确率 accuracy = tools.accuracy(logits, y_) #全局步骤 my_global_step = tf.Variable(0, name='global_step', trainable=False) #梯度下降 train_op = tools.optimize(loss, learning_rate, my_global_step) #保存训练步骤 saver = tf.train.Saver(tf.global_variables()) #summary_op = tf.summary.merge_all() #全局变量初始操作 init = tf.global_variables_initializer() #创建sess sess = tf.Session() #全局变量操作 sess.run(init) #启动coord coord = tf.train.Coordinator() #启动队列 threads = tf.train.start_queue_runners(sess=sess, coord=coord) #一些tensorboard的可视化操作,由于会出现问题,我先注释掉了 # tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) # val_summary_writer = tf.summary.FileWriter(test_log_dir, sess.graph) print('all init has been done! start training') try: for step in np.arange(MAX_STEP): print('step + ' + str(step) + 'is now') if coord.should_stop(): break #从队列中取batch tra_images, tra_labels = sess.run([train_batch, train_label_batch]) #计算损失和准确率 _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={ x: tra_images, y_: tra_labels }) #如果到达10步的倍数,打印在现在的batch_size上的训练准确率 if step % 10 == 0 or (step + 1) == MAX_STEP: print('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) # summary_str = sess.run(summary_op) # tra_summary_writer.add_summary(summary_str, step) #如果步骤达到200的倍数,输入一些训练数据查看在训练集上的准确率 if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run( [test_batch, test_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={ x: val_images, y_: val_labels }) print( '** Step %d, val loss = %.2f, val accuracy = %.2f%% **' % (step, val_loss, val_acc)) # summary_str = sess.run(summary_op) # val_summary_writer.add_summary(summary_str, step) #如果步骤达到了2000步,保存当前点的数据 if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def train(): pre_trained_weights = './/vgg16_pretrain//vgg16.npy' data_dir = './/data//cifar-10-batches-bin//' train_log_dir = './/logs//train//' val_log_dir = './/logs//val//' with tf.name_scope('input'): tra_image_batch, tra_label_batch = input_data.read_cifar10(data_dir=data_dir, is_train=True, batch_size= BATCH_SIZE, shuffle=True) val_image_batch, val_label_batch = input_data.read_cifar10(data_dir=data_dir, is_train=False, batch_size= BATCH_SIZE, shuffle=False) logits = VGG.VGG16N(tra_image_batch, N_CLASSES, IS_PRETRAIN) loss = tools.loss(logits, tra_label_batch) accuracy = tools.accuracy(logits, tra_label_batch) my_global_step = tf.Variable(0, name='global_step', trainable=False) train_op = tools.optimize(loss, learning_rate, my_global_step) x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int16, shape=[BATCH_SIZE, N_CLASSES]) saver = tf.train.Saver(tf.global_variables()) summary_op = tf.summary.merge_all() init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # load the parameter file, assign the parameters, skip the specific layers tools.load_with_skip(pre_trained_weights, sess, ['fc6','fc7','fc8']) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) tra_summary_writer = tf.summary.FileWriter(train_log_dir, sess.graph) val_summary_writer = tf.summary.FileWriter(val_log_dir, sess.graph) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break tra_images,tra_labels = sess.run([tra_image_batch, tra_label_batch]) _, tra_loss, tra_acc = sess.run([train_op, loss, accuracy], feed_dict={x:tra_images, y_:tra_labels}) if step % 50 == 0 or (step + 1) == MAX_STEP: print ('Step: %d, loss: %.4f, accuracy: %.4f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) tra_summary_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: val_images, val_labels = sess.run([val_image_batch, val_label_batch]) val_loss, val_acc = sess.run([loss, accuracy], feed_dict={x:val_images,y_:val_labels}) print('** Step %d, val loss = %.2f, val accuracy = %.2f%% **' %(step, val_loss, val_acc)) summary_str = sess.run(summary_op) val_summary_writer.add_summary(summary_str, step) if step % 2000 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(train_log_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def forward(self, x, target=None): # backbone C_4, C_5 = self.backbone(x) # detection head # multi scale feature map fusion C_5 = self.conv_set_2(C_5) C_5_up = F.interpolate(self.conv_1x1_2(C_5), scale_factor=2.0, mode='bilinear', align_corners=True) C_4 = torch.cat([C_4, C_5_up], dim=1) C_4 = self.conv_set_1(C_4) # head # s = 32 C_5 = self.extra_conv_2(C_5) pred_2 = self.pred_2(C_5) # s = 16 pred_1 = self.pred_1(C_4) preds = [pred_1, pred_2] total_conf_pred = [] total_cls_pred = [] total_txtytwth_pred = [] B = HW = 0 for pred in preds: B_, abC_, H_, W_ = pred.size() # [B, anchor_n * C, H, W] -> [B, H, W, anchor_n * C] -> [B, H*W, anchor_n*C] pred = pred.permute(0, 2, 3, 1).contiguous().view(B_, H_ * W_, abC_) # Divide prediction to obj_pred, xywh_pred and cls_pred # [B, H*W*anchor_n, 1] conf_pred = pred[:, :, :1 * self.anchor_number].contiguous().view( B_, H_ * W_ * self.anchor_number, 1) # [B, H*W*anchor_n, num_cls] cls_pred = pred[:, :, 1 * self.anchor_number:(1 + self.num_classes) * self.anchor_number].contiguous().view( B_, H_ * W_ * self.anchor_number, self.num_classes) # [B, H*W*anchor_n, 4] txtytwth_pred = pred[:, :, (1 + self.num_classes) * self.anchor_number:].contiguous() total_conf_pred.append(conf_pred) total_cls_pred.append(cls_pred) total_txtytwth_pred.append(txtytwth_pred) B = B_ HW += H_ * W_ conf_pred = torch.cat(total_conf_pred, 1) cls_pred = torch.cat(total_cls_pred, 1) txtytwth_pred = torch.cat(total_txtytwth_pred, 1) # test if not self.trainable: txtytwth_pred = txtytwth_pred.view(B, HW, self.anchor_number, 4) with torch.no_grad(): # batch size = 1 all_obj = torch.sigmoid(conf_pred)[ 0] # 0 is because that these is only 1 batch. all_bbox = torch.clamp( (self.decode_boxes(txtytwth_pred) / self.scale_torch)[0], 0., 1.) all_class = (torch.softmax(cls_pred[0, :, :], dim=1) * all_obj) # separate box pred and class conf all_obj = all_obj.to('cpu').numpy() all_class = all_class.to('cpu').numpy() all_bbox = all_bbox.to('cpu').numpy() bboxes, scores, cls_inds = self.postprocess( all_bbox, all_class) # print(len(all_boxes)) return bboxes, scores, cls_inds else: txtytwth_pred = txtytwth_pred.view(B, HW, self.anchor_number, 4) # decode bbox, and remember to cancel its grad since we set iou as the label of objectness. with torch.no_grad(): x1y1x2y2_pred = (self.decode_boxes(txtytwth_pred) / self.scale_torch).view(-1, 4) txtytwth_pred = txtytwth_pred.view(B, -1, 4) x1y1x2y2_gt = target[:, :, 7:].view(-1, 4) # compute iou iou = tools.iou_score(x1y1x2y2_pred, x1y1x2y2_gt).view(B, -1, 1) # print(iou.min(), iou.max()) # we set iou between pred bbox and gt bbox as conf label. # [obj, cls, txtytwth, x1y1x2y2] -> [conf, obj, cls, txtytwth] target = torch.cat([iou, target[:, :, :7]], dim=2) conf_loss, cls_loss, txtytwth_loss, total_loss = tools.loss( pred_conf=conf_pred, pred_cls=cls_pred, pred_txtytwth=txtytwth_pred, label=target, num_classes=self.num_classes, obj_loss_f='mse') return conf_loss, cls_loss, txtytwth_loss, total_loss
def run_training(): num_classes = 1329 IMG_W = 448 IMG_H = 448 CAPACITY = 1000 train_dir = 'tfrecords' BATCH_SIZE = FLAGS.batch_size train_all = FLAGS.train_all learning_rate = FLAGS.learning_rate momentum = FLAGS.momentum num_epoch = FLAGS.num_epoch logger.info('learning_rate ' + str(learning_rate)) logger.info('num_epoch ' + str(num_epoch)) total_train_count, total_val_count, total_test_count = input_data.get_total_count( 'total_count.txt') train_batch, train_label_batch = input_data.get_batch( train_dir, 'train', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, True) val_batch, val_label_batch = input_data.get_batch(train_dir, 'validataion', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, False) test_batch, test_label_batch = input_data.get_batch( train_dir, 'test', IMG_W, IMG_H, BATCH_SIZE, CAPACITY, False) imgs = tf.placeholder(tf.float32, [BATCH_SIZE, IMG_W, IMG_H, 3]) labels = tf.placeholder(tf.int32, [BATCH_SIZE]) keep_pro = tf.placeholder(tf.float32) vgg = bilinear_vgg(imgs, num_classes, train_all, keep_pro) loss = tools.loss(vgg.logits, labels) accuracy, num_correct_preds = tools.evaluation(vgg.logits, labels) optimizer = tools.optimize(loss, learning_rate, momentum) gpu_options = tf.GPUOptions(allow_growth=True) config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(config=config) as sess: if not os.path.exists(checkpoint): os.makedirs(checkpoint) sess.run(tf.global_variables_initializer()) weight_files = ['vgg19.npy'] if train_all == True: weight_files.append('last_layers.npz') tools.load_initial_weights(weight_files, sess, train_all) saver = tf.train.Saver() ''' logger.info("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(checkpoint) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) logger.info('Loading success, global_step is ' + global_step) else: print('No checkpoint file found') ''' coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph) total_batch = total_train_count / BATCH_SIZE total_val_batch = total_val_count / BATCH_SIZE for epoch in range(0, num_epoch): for i in range(total_batch): try: batch_xs, batch_ys = sess.run( [train_batch, train_label_batch]) #左右两边命名不要一样 _ = sess.run(optimizer, feed_dict={ imgs: batch_xs, labels: batch_ys, keep_pro: 0.7 }) if i % 50 == 0: train_loss, train_accuracy, summary_str = sess.run( [loss, accuracy, summary_op], feed_dict={ imgs: batch_xs, labels: batch_ys, keep_pro: 0.7 }) train_writer.add_summary(summary_str, epoch * total_batch + i) logger.info("Epoch: " + str(epoch) + " Step: " + str(i) + " Loss: " + str(train_loss)) logger.info("Training Accuracy --> " + str(train_accuracy)) batch_val_x, batch_val_y = sess.run( [val_batch, val_label_batch]) val_loss, val_accuracy, val_summary_str = sess.run( [loss, accuracy, summary_op], feed_dict={ imgs: batch_val_x, labels: batch_val_y, keep_pro: 1.0 }) val_writer.add_summary(val_summary_str, epoch * total_batch + i) logger.info("val Loss: " + str(train_loss)) logger.info("val Accuracy --> " + str(train_accuracy)) except tf.errors.OutOfRangeError: logger.info('batch out of range') break checkpoint_path = os.path.join(checkpoint, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=epoch) if train_all == False: tools.save_last_layers_weights(sess, vgg) # correct_val_count = 0 # val_loss_total = 0.0 #for i in range(total_val_batch): # try: # batch_val_x,batch_val_y = sess.run([val_batch, val_label_batch]) # val_loss,preds = sess.run([loss,num_correct_preds], feed_dict={imgs: batch_val_x, labels: batch_val_y}) # val_loss_total += val_loss # correct_val_count+=preds #val_writer.add_summary(summary_str, epoch * total_batch + i) # except tf.errors.OutOfRangeError: # logger.info('val batch out of range') # break #logger.info("------------") #logger.info("Epoch: "+str (epoch+1)+" correct_val_count, total_val_count "+ str(correct_val_count)+" , "+str( total_val_count)) #logger.info("Epoch: "+str (epoch+1)+ " Step: "+ str(i)+" Loss: "+str( val_loss_total/total_val_batch)) #logger.info("Validation Data Accuracy --> "+str( 100.0*correct_val_count/(1.0*total_val_count))) #logger.info("------------") #break correct_test_count = 0 total_test_batch = total_test_count / BATCH_SIZE for i in range(total_test_batch): try: batch_test_x, batch_test_y = sess.run( [test_batch, test_label_batch]) preds = sess.run(num_correct_preds, feed_dict={ imgs: batch_test_x, labels: batch_test_y, keep_pro: 1.0 }) correct_test_count += preds except tf.errors.OutOfRangeError: logger.info('test batch out of range') break logger.info("correct_test_count, total_test_count " + str(correct_test_count) + " , " + str(total_test_count)) logger.info("Test Data Accuracy --> " + str(100.0 * correct_test_count / (1.0 * total_test_count))) coord.request_stop() coord.join(threads)