def test(first, second, out): data_frame1 = np.expand_dims(imread(first), 0) data_frame3 = np.expand_dims(imread(second), 0) H = data_frame1.shape[1] W = data_frame1.shape[2] adatptive_H = int(np.ceil(H / 32.0) * 32.0) adatptive_W = int(np.ceil(W / 32.0) * 32.0) pad_up = int(np.ceil((adatptive_H - H) / 2.0)) pad_bot = int(np.floor((adatptive_H - H) / 2.0)) pad_left = int(np.ceil((adatptive_W - W) / 2.0)) pad_right = int(np.floor((adatptive_W - W) / 2.0)) print(str(H) + ', ' + str(W)) print(str(adatptive_H) + ', ' + str(adatptive_W)) """Perform test on a trained model.""" with tf.Graph().as_default(): # Create input and target placeholder. input_placeholder = tf.placeholder(tf.float32, shape=(None, H, W, 6)) input_pad = tf.pad(input_placeholder, [[0, 0], [pad_up, pad_bot], [pad_left, pad_right], [0, 0]], 'SYMMETRIC') edge_vgg_1 = Vgg16(input_pad[:, :, :, :3], reuse=None) edge_vgg_3 = Vgg16(input_pad[:, :, :, 3:6], reuse=True) edge_1 = tf.nn.sigmoid(edge_vgg_1.fuse) edge_3 = tf.nn.sigmoid(edge_vgg_3.fuse) edge_1 = tf.reshape(edge_1, [-1, input_pad.get_shape().as_list()[1], input_pad.get_shape().as_list()[2], 1]) edge_3 = tf.reshape(edge_3, [-1, input_pad.get_shape().as_list()[1], input_pad.get_shape().as_list()[2], 1]) with tf.variable_scope("Cycle_DVF"): # Prepare model. model = Voxel_flow_model(is_train=False) prediction = model.inference(tf.concat([input_pad, edge_1, edge_3], 3))[0] # Create a saver and load. sess = tf.Session() # Restore checkpoint from file. if FLAGS.pretrained_model_checkpoint_path: restorer = tf.train.Saver() restorer.restore(sess, FLAGS.pretrained_model_checkpoint_path) print('%s: Pre-trained model restored from %s' % (datetime.now(), FLAGS.pretrained_model_checkpoint_path)) feed_dict = {input_placeholder: np.concatenate((data_frame1, data_frame3), 3)} # Run single step update. prediction_np = sess.run(prediction, feed_dict=feed_dict) output = prediction_np[-1, pad_up:adatptive_H - pad_bot, pad_left:adatptive_W - pad_right, :] output = np.round(((output + 1.0) * 255.0 / 2.0)).astype(np.uint8) output = np.dstack((output[:, :, 2], output[:, :, 1], output[:, :, 0])) cv2.imwrite(out, output)
def evaluate(args): content_image = utils.tensor_load_rgbimage(args.content_image, size=args.content_size, keep_asp=True) content_image = content_image.unsqueeze(0) style = utils.tensor_load_rgbimage(args.style_image, size=args.style_size) style = style.unsqueeze(0) style = utils.preprocess_batch(style) vgg = Vgg16() utils.init_vgg16(args.vgg_model_dir) vgg.load_state_dict( torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight"))) style_model = HangSNetV1() style_model.load_state_dict(torch.load(args.model)) if args.cuda: style_model.cuda() vgg.cuda() content_image = content_image.cuda() style = style.cuda() style_v = Variable(style, volatile=True) utils.subtract_imagenet_mean_batch(style_v) features_style = vgg(style_v) gram_style = [utils.gram_matrix(y) for y in features_style] content_image = Variable(utils.preprocess_batch(content_image)) target = Variable(gram_style[2].data, requires_grad=False) style_model.setTarget(target) output = style_model(content_image) utils.tensor_save_bgrimage(output.data[0], args.output_image, args.cuda)
def test(test_data_path): with tf.Session() as sess: #加载数据 test_data = np.load(test_data_path) test_x = test_data['x'] test_y = test_data['y'] x = tf.placeholder(tf.float32, [None, 224, 224, 1]) y = tf.placeholder(tf.float32, [None, n_classes]) #构建模型 model = Vgg16() pred = model.build(x) #测试网络 correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) #初始化所有共享变量 sess.run(tf.global_variables_initializer()) #保存模型 saver = tf.train.Saver() print("===============Testing===================") saver.restore(sess, 'model/...') batch_x = test_x batch_y = test_y accu = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}) loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y}) print('Testing Accuracy= %.5f' % (accu))
def get_vgg_model(MAX_CAPTION_LEN): image_model = Vgg16().model image_model.pop() image_model.pop() image_model.trainable = False image_model.add(RepeatVector(MAX_CAPTION_LEN)) return image_model
def setup(self, sess, reuse=False): try: with tf.name_scope('vgg16') as scope: # if reuse: # scope.reuse_variables() self.edge_model = Vgg16(self.cfgs, self.img_place_holder, reuse=reuse) from tensorflow.python import pywrap_tensorflow reader = pywrap_tensorflow.NewCheckpointReader( '/home/yyl/pjs/pycharm-remote-data/HED-BSDS/holy-edge/hed/vgg16/hed-model-5000' ) var_to_shape_map = reader.get_variable_to_shape_map() # saver_edge = tf.train.import_meta_graph('/home/yyl/pjs/pycharm-remote-data/HED-BSDS/holy-edge/hed/vgg16/hed-model-5000.meta') t_vars = tf.global_variables() var_edge = [var for var in t_vars if 'vgg16' in var.name] saver_edge = tf.train.Saver(var_edge) saver_edge.restore( sess, '/home/yyl/pjs/pycharm-remote-data/HED-BSDS/holy-edge/hed/vgg16/hed-model-5000' ) except Exception as err: self.io.print_error( 'Error setting up VGG-16 model, {}'.format(err)) self.init = False
def __init__(self, out_channels=2): super(ResidualEncoder, self).__init__() # using a pretrained model vgg16 self.resnet = Vgg16() # convolution only adjust the width and height size # the b_conv4 layer use 1*1 filter self.b_conv4 = nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0) # assert(self.bn_4.get_shape().as_list()[1:] == [28, 28, 512]) # assert(self.b_conv4.get_shape().as_list()[1:] == [28, 28, 256]) # Backward upscale layer 4 self.b_conv4_upscale = nn.Upsample(scale_factor=2) self.b_conv3 = nn.Conv2d(256, 128, kernel_size=3, stride=1, padding=1) # Backward upscale layer 3 self.b_conv3_upscale = nn.Upsample(scale_factor=2) self.b_conv2 = nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=1) # Backward upscale layer 2 self.b_conv2_upscale = nn.Upsample(scale_factor=2) self.b_conv1 = nn.Conv2d(64, 3, kernel_size=3, stride=1, padding=1) # Backward upscale bottom layer self.b_conv1_upscale = nn.Upsample(scale_factor=2) self.b_conv0 = nn.Conv2d(3, 3, kernel_size=3, stride=1, padding=1) self.b_conv_last = nn.Conv2d(3, out_channels, kernel_size=3, stride=1, padding=1)
def train_ofb(args): train_dataset = dataset.DAVISDataset(args.dataset, use_flow=True) train_loader = DataLoader(train_dataset, batch_size=1) transformer = transformer_net.TransformerNet(args.pad_type) transformer.train() optimizer = torch.optim.Adam(transformer.parameters(), args.lr) mse_loss = torch.nn.MSELoss() vgg = Vgg16() vgg.load_state_dict( torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight"))) vgg.eval() if args.cuda: transformer.cuda() vgg.cuda() mse_loss.cuda() style = utils.tensor_load_resize(args.style_image, args.style_size) style = style.unsqueeze(0) print("=> Style image size: " + str(style.size())) print("=> Pixel OFB loss weight: %f" % args.time_strength) style = utils.preprocess_batch(style) if args.cuda: style = style.cuda() style = utils.subtract_imagenet_mean_batch(style) features_style = vgg(style) gram_style = [utils.gram_matrix(y).detach() for y in features_style] train_loader.dataset.reset() transformer.train() transformer.cuda() agg_content_loss = agg_style_loss = agg_pixelofb_loss = 0. iters = 0 anormaly = False elapsed_time = 0 for batch_id, (x, flow, conf) in enumerate(tqdm(train_loader)): x, flow, conf = x[0], flow[0], conf[0] iters += 1 optimizer.zero_grad() x = utils.preprocess_batch(x) # (N, 3, 256, 256) if args.cuda: x = x.cuda() flow = flow.cuda() conf = conf.cuda() y = transformer(x) # (N, 3, 256, 256) begin_time = time.time() warped_y, warped_y_mask = warp(y[1:], flow) warped_y = warped_y.detach() warped_y_mask *= conf pixel_ofb_loss = args.time_strength * weighted_mse( y[:-1], warped_y, warped_y_mask) pixel_ofb_loss.backward() elapsed_time += time.time() - begin_time if batch_id > 1000: break print(elapsed_time / float(batch_id + 1))
def conv_model(self): vgg = Vgg16() model = vgg.model last_conv_idx = [ i for i, l in enumerate(model.layers) if type(l) is Convolution2D ][-1] conv_layers = model.layers[:last_conv_idx + 1] return Sequential(conv_layers)
def __init__(self, num_classes): self.model_dir = FLAGS.model_path self.cnn_net = Vgg16() with tf.device("/gpu:0"): self.faster_rcnn = FasterRCNN(self.cnn_net, num_classes, batch_size=BATCH_SIZE, is_training=False) self.faster_rcnn.build(mode='predict') self._initialize()
def main(argv=None): # pylint: disable=unused-argument X = tf.placeholder(tf.float32, [None, 224, 224, 3]) y = tf.placeholder(tf.int64, [None]) is_train = tf.placeholder(tf.bool) global_step = tf.Variable(0, trainable=False) vgg = Vgg16(model_path=None, learning_rate=1e-3, decay=0.9999, decay_step=350, decay_factor=0.1) logits = vgg.inference(X, is_train) loss = vgg.loss(logits, y) train_op = vgg.train(loss, global_step) accuracy = vgg.accuracy(logits, y) # Create a saver. # saver = tf.train.Saver(tf.global_variables()) # Build the summary operation based on the TF collection of Summaries. # summary_op = tf.merge_all_summaries() # Build an initialization operation to run below. init = tf.global_variables_initializer() batch_data = BatchDatset() with tf.Session() as sess: with tf.device('/gpu:0'): sess.run(init) losses = [] accs = [] print('*************** training ***************') for step in xrange(FLAGS.max_iter): # create a feed dictionary for this batch X_batch, y_batch = batch_data.next_batch(FLAGS.batch_size) feed_dict = { X: X_batch, y: y_batch, is_train: FLAGS.mode is 'train' } _, los, acc, fc8 = sess.run( [train_op, loss, accuracy, vgg.fc8], feed_dict=feed_dict) losses.append(los) accs.append(acc) print('loss:', los) if step % FLAGS.print_every == 0: print( "Iteration {0}: with minibatch training loss = {1:.3g} and accuracy of {2:.2g}%" .format(step, los, acc * 100)) print('losses:', losses) print('accs:', accs) data = {'loss': losses, 'accuracy': accs} with open('temp.pickle', 'wb') as file: pickle.dump(data, file)
def prepare_vgg(sal_type, layer_idx, load_weights, sess): # construct the graph based on the gradient type we want if sal_type == 'GuidedBackprop': eval_graph = tf.get_default_graph() with eval_graph.gradient_override_map({'Relu': 'GuidedRelu'}): vgg = Vgg16(sess=sess) elif sal_type == 'Deconv': eval_graph = tf.get_default_graph() with eval_graph.gradient_override_map({'Relu': 'DeconvRelu'}): vgg = Vgg16(sess=sess) elif sal_type == 'PlainSaliency': vgg = Vgg16(sess=sess) else: raise Exception("Unknown saliency_map type - 1") # different options for loading weights if load_weights == 'trained': vgg.load_weights(weight_path, sess) elif load_weights == 'random': vgg.init(sess) elif load_weights == 'part': # fill the first "idx" layers with the trained weights # randomly initialize the rest vgg.load_weights_part(layer_idx * 2 + 1, weight_path, sess) elif load_weights == 'reverse': # do not fill the first "idx" layers with the trained weights # randomly initialize them vgg.load_weights_reverse(layer_idx * 2 + 1, weight_path, sess) elif load_weights == 'only': # do not load a specific layer ("idx") with the trained weights # randomly initialize it vgg.load_weights_only(layer_idx * 2 + 1, weight_path, sess) else: raise Exception("Unknown load_weights type - 1") return vgg
def define_VGG(pretrained=True, gpu_ids=[]): vgg = Vgg16() if pretrained: vgg.load_state_dict(torch.load('models/vgg16.weight')) if len(gpu_ids) > 0: vgg.cuda(device_id=gpu_ids[0]) return vgg
def init_vgg16(model_folder): if not os.path.exists(os.path.join(model_folder, 'vgg16.weight')): if not os.path.exists(os.path.join(model_folder, 'vgg16.t7')): os.system( 'wget https://www.dropbox.com/s/76l3rt4kyi3s8x7/vgg16.t7?dl=1 -O ' + os.path.join(model_folder, 'vgg16.t7')) vgglua = load_lua(os.path.join(model_folder, 'vgg16.t7')) vgg = Vgg16() for (src, dst) in zip(vgglua.parameters()[0], vgg.parameters()): dst.data[:] = src torch.save(vgg.state_dict(), os.path.join(model_folder, 'vgg16.weight'))
def prepare_vgg(sal_type, sess): # construct the graph based on the gradient type we want if sal_type == 'GuidedBackprop': eval_graph = tf.get_default_graph() with eval_graph.gradient_override_map({'Relu': 'GuidedRelu'}): vgg = Vgg16(sess=sess) elif sal_type == 'Deconv': eval_graph = tf.get_default_graph() with eval_graph.gradient_override_map({'Relu': 'DeconvRelu'}): vgg = Vgg16(sess=sess) elif sal_type == 'PlainSaliency': vgg = Vgg16(sess=sess) else: raise Exception("Unknown saliency type") return vgg
def optimize(args): """ Gatys et al. CVPR 2017 ref: Image Style Transfer Using Convolutional Neural Networks """ # load the content and style target content_image = utils.tensor_load_rgbimage(args.content_image, size=args.content_size, keep_asp=True) content_image = content_image.unsqueeze(0) content_image = Variable(utils.preprocess_batch(content_image), requires_grad=False) utils.subtract_imagenet_mean_batch(content_image) style_image = utils.tensor_load_rgbimage(args.style_image, size=args.style_size) style_image = style_image.unsqueeze(0) style_image = Variable(utils.preprocess_batch(style_image), requires_grad=False) utils.subtract_imagenet_mean_batch(style_image) # load the pre-trained vgg-16 and extract features vgg = Vgg16() utils.init_vgg16(args.vgg_model_dir) vgg.load_state_dict(torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight"))) if args.cuda: content_image = content_image.cuda() style_image = style_image.cuda() vgg.cuda() features_content = vgg(content_image) f_xc_c = Variable(features_content[1].data, requires_grad=False) features_style = vgg(style_image) gram_style = [utils.gram_matrix(y) for y in features_style] # init optimizer output = Variable(content_image.data, requires_grad=True) optimizer = Adam([output], lr=args.lr) mse_loss = torch.nn.MSELoss() # optimizing the images for e in range(args.iters): utils.add_imagenet_mean_batch(output) output.data.clamp_(0, 255) utils.subtract_imagenet_mean_batch(output) optimizer.zero_grad() features_y = vgg(output) content_loss = args.content_weight * mse_loss(features_y[1], f_xc_c) style_loss = 0. for m in range(len(features_y)): gram_y = utils.gram_matrix(features_y[m]) gram_s = Variable(gram_style[m].data, requires_grad=False) style_loss += args.style_weight * mse_loss(gram_y, gram_s) total_loss = content_loss + style_loss if (e + 1) % args.log_interval == 0: print(total_loss.data.cpu().numpy()[0]) total_loss.backward() optimizer.step() # save the image utils.tensor_save_bgrimage(output.data[0], args.output_image, args.cuda)
def build_net(self, image, word, target_word, config): with tf.name_scope("content_vgg"): self.cnn_net = Vgg16() self.cnn_net.build(image) with tf.device("/gpu:0"): init_state = self.cnn_net.relu6 self.lstm = lstm.LSTM(initial_state=init_state, input=word, target=target_word, config=config)
def main(FLAGS): v = Vgg16() # var_list = [v for k, v in v.var_dict.items()] checkpoint = tf.train.Checkpoint(model=v) checkpoint.restore(FLAGS.start_checkpoint) call = v.__call__.get_concrete_function( tf.TensorSpec([None, 224, 224, 3], tf.float32)) tf.saved_model.save(v, "/home/applevidur/tf_model/vgg16_with_signature/1", signatures=call)
def init_vgg16(model_folder): """load the vgg16 model feature""" if not os.path.exists(os.path.join(model_folder, 'vgg16.weight')): if not os.path.exists(os.path.join(model_folder, 'vgg16.t7')): os.system( 'wget http://cs.stanford.edu/people/jcjohns/fast-neural-style/models/vgg16.t7 -O ' + os.path.join(model_folder, 'vgg16.t7')) vgglua = load_lua(os.path.join(model_folder, 'vgg16.t7')) vgg = Vgg16() for (src, dst) in zip(vgglua.parameters()[0], vgg.parameters()): dst.data[:] = src torch.save(vgg.state_dict(), os.path.join(model_folder, 'vgg16.weight'))
def init_vgg16(model_folder): from vgg16 import Vgg16 if not os.path.exists(os.path.join(model_folder, 'vgg16.weight')): if not os.path.exists(os.path.join(model_folder, 'vgg16.t7')): os.system( 'wget https://www.dropbox.com/s/76l3rt4kyi3s8x7/vgg16.t7?dl=1 -O ' + os.path.join(model_folder, 'vgg16.t7')) raise Exception("fix lua->python loading since api was removed") vgglua = load_lua(os.path.join(model_folder, 'vgg16.t7')) vgg = Vgg16() for (src, dst) in zip(vgglua.parameters()[0], vgg.parameters()): dst.data[:] = src
def __init__(self, training_data_provider, dropout=0.6, batch_size=64): vgg = Vgg16() model = vgg.model conv_model, _ = split_model(model) dense_model = get_batchnorm_model(conv_model, dropout) self._conv_model = conv_model self._dense_model = dense_model self._batch_size = batch_size self._train_feature_set = training_data_provider.get_feature_set( 'train', conv_model, 'sf_train_conv_features.bc') self._train_feature_set.shuffle() self._valid_feature_set = training_data_provider.get_feature_set( 'valid', conv_model, 'sf_valid_conv_features.bc')
def __init__(self, net_name, dataset_name, pre_model=None, is_train=True): super().__init__() self.net_name = net_name self.is_train = is_train if dataset_name == 'sysu': self.num_pid = 5532 self.queue_size = 5000 elif dataset_name == 'prw': self.num_pid = 483 self.queue_size = 500 else: raise KeyError(dataset_name) self.lut_momentum = 0.5 self.reid_feat_dim = 256 self.register_buffer( 'lut', torch.zeros(self.num_pid, self.reid_feat_dim).cuda()) self.register_buffer( 'queue', torch.zeros(self.queue_size, self.reid_feat_dim).cuda()) if self.net_name == 'vgg16': self.net = Vgg16(pre_model, self.is_train) elif self.net_name == 'res34': self.net = resnet(34, pre_model, self.is_train) elif self.net_name == 'res50': self.net = resnet(50, pre_model, self.is_train) elif self.net_name == 'dense121': self.net = densenet(121, pre_model, self.is_train) elif self.net_name == 'dense161': self.net = densenet(161, pre_model, self.is_train) else: raise KeyError(self.net_name) self.fc7_channels = self.net.fc7_channels # SPIN consists of three main parts self.head = self.net.head self.strpn = STRPN(self.net.net_conv_channels, self.num_pid, self.is_train) self.tail = self.net.tail self.cls_score_net = nn.Linear(self.fc7_channels, 2) self.bbox_pred_net = nn.Linear(self.fc7_channels, 8) self.reid_feat_net = nn.Linear(self.fc7_channels, self.reid_feat_dim) self.init_linear_weight(False)
def create_model(opt): vgg = Vgg16() vgg.model.pop() click.echo('Replacing last layer of model...') for layer in vgg.model.layers: layer.trainable = False vgg.model.add(Dense(2, activation='softmax')) vgg.model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) vgg.model.load_weights(os.path.join(MODEL_PATH, 'finetune_1_ll.h5')) return vgg
def create_model(): vgg = Vgg16() vgg.model.pop() click.echo('Replacing last layer of model...') for layer in vgg.model.layers: layer.trainable = False vgg.model.add(Dense(2, activation='softmax')) # OPTIMIZER = Nadam() OPTIMIZER = RMSprop(lr=0.001) vgg.model.compile(optimizer=OPTIMIZER, loss='categorical_crossentropy', metrics=['accuracy']) return vgg, OPTIMIZER
def predict_imagenet(filename): test_x = ImageDataGenerator.get_image(filename) X = tf.placeholder(tf.float32, [None, 224, 224, 3]) keep_prob = tf.placeholder(tf.float32) model = Vgg16(X, keep_prob) y_ = model.create_model() prob = tf.nn.softmax(y_) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) model.initial_weights(sess) y_, output = sess.run([y_, prob], feed_dict={ X: [test_x], keep_prob: 1 }) ImageDataGenerator.predict(output)
def __init__(self, imdb, roidb, val_imdb, val_roidb, pretrain_model): self.imdb = imdb self.roidb = roidb self.val_imdb = val_imdb self.val_roidb = val_roidb self.pretrain_model = pretrain_model self.model_dir = FLAGS.model_path self.log_dir = FLAGS.log_path self.val_log_dir = FLAGS.val_log_path self.cnn_net = Vgg16() with tf.device("/gpu:0"): self.faster_rcnn = FasterRCNN(self.cnn_net, self.imdb.num_classes, batch_size=config.BATCH_SIZE, is_training=True) self.faster_rcnn.build(mode='train') variables = tf.global_variables() print ("all var:",variables)
def main(): #taken care of in ~/.keras/keras.json # from keras import backend # backend.set_image_dim_ordering('tf') #which dataset to work on?large or the small # path = settings.DATA_ALL path = settings.DATA_SAMPLE # where are we? datadir = os.path.join(os.getcwd(), settings.DATA_FOLDER_NAME) # create model with correct number of outputs # this pops off the existing last layer, sets remaining layers to not trainable # and puts on a layer with the correct number of outputs # Import our class, and instantiate from vgg16 import Vgg16 vgg = Vgg16() # Grab a few images at a time for training and validation. # NB: They must be in subdirectories named based on their category batches = vgg.get_batches(os.path.join(path, settings.TRAIN_FOLDER_NAME), batch_size=settings.BATCH_SIZE) val_batches = vgg.get_batches(os.path.join(path, settings.VALIDATE_FOLDER_NAME), batch_size=settings.BATCH_SIZE * 2) # add a different fully connected layer at the end # load the best weights from CHECKPOINTFILE_1 (if it exists) vgg.finetune(batches, checkpointfile=settings.CHECKPOINTFILE_1) # create checkpoint to be used by model.fit to save the best model via callback filepath = settings.CHECKPOINTFILE_1 checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint] # fit the model vgg.fit(batches, val_batches, nb_epoch=settings.NUMBER_EPOCHS, callbacks=callbacks_list)
def predict_dog_cat(filename): test_x = ImageDataGenerator.get_image(filename) X = tf.placeholder(tf.float32, [None, 224, 224, 3]) keep_prob = tf.placeholder(tf.float32) model = Vgg16(X, keep_prob, 2) y_ = model.create_model() predict = tf.argmax(y_, 1) saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state('./ckpt') if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): print("Reading model parameters from %s" % ckpt.model_checkpoint_path) saver.restore(sess, ckpt.model_checkpoint_path) else: print("no model") return pred = sess.run(predict, feed_dict={X: [test_x], keep_prob: 1}) print(cat_dog_class_names[pred[0]])
def encoder(self, x, is_training=True, reuse=False): vgg_net = Vgg16() vgg_net.encoder(x) with tf.variable_scope(self.scope, reuse=False): self.conv6 = self.conv_layer(vgg_net.conv5_3, [3, 3], self.channel_scale(512), self.channel_scale(1024), is_training, scope="conv6") self.conv7 = self.conv_layer(self.conv6, [1, 1], self.channel_scale(1024), self.channel_scale(1024), is_training, scope="conv7") self.conv8_1 = self.conv_layer(self.conv7, [1, 1], self.channel_scale(1024), self.channel_scale(256), is_training, scope="conv8_1") self.conv8_2 = self.conv_layer(self.conv8_1, [3, 3], self.channel_scale(256), self.channel_scale(512), is_training, scope="conv8_2", stride=2) self.conv9_1 = self.conv_layer(self.conv8_2, [1, 1], self.channel_scale(512), self.channel_scale(128), is_training, scope="conv9_1") self.conv9_2 = self.conv_layer(self.conv9_1, [3, 3], self.channel_scale(128), self.channel_scale(256), is_training, scope="conv9_2",stride=2) self.conv10_1 = self.conv_layer(self.conv9_2, [1, 1], self.channel_scale(256), self.channel_scale(128), is_training, scope="conv10_1") self.conv10_2 = self.conv_layer(self.conv10_1, [3, 3], self.channel_scale(128), self.channel_scale(256), is_training, scope="conv10_2", stride=2) self.p11 = tf.nn.avg_pool(self.conv10_2, [1, 3, 3, 1], [1, 1, 1, 1], "SAME") all_class_num = self.class_num + 1 self.out1 = self.conv_layer(vgg_net.conv4_3, [3, 3], self.channel_scale(512), self.layer_boxs[0]*(all_class_num + 4), is_training, scope="out1", activation_fn=None) self.out2 = self.conv_layer(self.conv7, [3, 3], self.channel_scale(1024), self.layer_boxs[1]* (all_class_num + 4), is_training, scope="out2", activation_fn=None) self.out3 = self.conv_layer(self.conv8_2, [3, 3], self.channel_scale(512), self.layer_boxs[2]* (all_class_num + 4), is_training, scope="out3", activation_fn=None) self.out4 = self.conv_layer(self.conv9_2, [3, 3], self.channel_scale(256), self.layer_boxs[3]* (all_class_num + 4), is_training, scope="out4", activation_fn=None) self.out5 = self.conv_layer(self.conv10_2, [3, 3], self.channel_scale(256), self.layer_boxs[4]* (all_class_num + 4), is_training, scope="out5", activation_fn=None) self.out6 = self.conv_layer(self.p11, [3, 3], self.channel_scale(256), self.layer_boxs[5]* (all_class_num + 4), is_training, scope="out6", activation_fn=None) self.outs = [self.out1, self.out2, self.out3, self.out4, self.out5, self.out6] self.outfs = [] for i, out in enumerate(self.outs): tmp_outf = tf.reshape(out, [self.flags.batch_size, -1, all_class_num+4]) self.outfs.append(tmp_outf) self.formatted_outs = tf.concat(self.outfs, 1) self.pred_labels = self.formatted_outs[:, :, :all_class_num] self.pred_locs = self.formatted_outs[:, :, all_class_num:]
def get_vgg(path_config, batch_size): """Tune the model and return model""" print("Getting model for {p}".format(p=path_config.data)) vgg = Vgg16() existing_weight_file = path_config.get_latest_weight() if os.path.exists(existing_weight_file): print("Loading weights from {wf}".format(wf=existing_weight_file)) vgg.model.load_weights(existing_weight_file) else: # Grab a few images at a time for training and validation. # NB: They must be in subdirectories named based on their category train_batches = vgg.get_batches(path_config.train, batch_size=batch_size) val_batches = vgg.get_batches(path_config.valid, batch_size=batch_size*2) vgg.finetune(train_batches) vgg.model.optimizer.lr = 0.01 print("Learning Rate={lr}, Batch size={bs}".format(lr=vgg.model.optimizer.lr, bs=batch_size)) timestamp_as_string = datetime.now().strftime("%Y-%m-%d-%H%M%S") epoch_count = 10 epoch_history = [] for epoch in range(epoch_count): print("Fitting epoch {c}/{of}".format(c=epoch, of=epoch_count)) history = vgg.fit(train_batches, val_batches, nb_epoch=1) weights_filename = "{ts}_fit_{epoch}.h5".format(ts=timestamp_as_string, epoch=epoch) weights_file_path = os.path.join(path_config.results, weights_filename) #print("Saving weights to {weights_file}".format(weights_file=weights_file_path)) vgg.model.save_weights(weights_file_path) epoch_history.append(history.history) print(epoch_history) return vgg
def train_vgg(img_type): #data train_imgs, train_labels = read_image(path, img_type) #model vgg = Vgg16() images = tf.placeholder(tf.float32, [None, 256, 256, 1]) labels = tf.placeholder(tf.int32, [None, 1]) probs, logits = vgg.build(images) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels)) train_step = tf.train.AdamOptimizer(learning_rate=1e-3).minimize(loss) correct_prediction = tf.equal(tf.cast(tf.argmax(logits, 1), tf.int32), labels) acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) saver = tf.train.Saver() #training part with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(1, max_epochs + 1): start_time = time.time() #training for batch_images, batch_labels in minibatches(train_imgs, train_labels, batch_size, shuffle=True): feed_dict = {labels: batch_labels, images: batch_images} _, err, ac = sess.run([train_step, loss, acc], feed_dict=feed_dict) end_time = time.time() print(end_time - start_time) if epoch % 500 == 0: saver.save(sess, './model' + str(epoch) + '.ckpt')