Exemple #1
0
def test(img):
    inputs = tf.placeholder(tf.float32, [1, 448, 448, 3])
    prediction = vgg16(inputs)
    pred_bboxes = prediction[:, :, :, :8]#[1, 7, 7, 8]
    pred_bboxes = tf.reshape(pred_bboxes, [1, 7, 7, 2, 4])#[1, 7, 7, 2, 4]
    pred_confidence = prediction[:, :, :, 8:10]#[1, 7, 7, 2]
    pred_class = prediction[:, :, :, 10:]#[1, 7, 7, 20]
    pred_bboxes = norm2bbox(pred_bboxes)#[1, 7, 7, 2, 4]
    class_confidences = tf.split(pred_class, num_or_size_splits=20, axis=-1)
    pred_bboxes = tf.reshape(pred_bboxes, [-1, 4])
    indx_class = []
    scores_class = []
    for class_confidence in class_confidences:
        scores = pred_confidence * class_confidence#[1, 7, 7, 2]
        scores = tf.reshape(scores, [-1])
        indx = tf.image.non_max_suppression(pred_bboxes, scores, 5)
        indx_class.append(indx[tf.newaxis, :])
        scores_class.append(scores[tf.newaxis, :])
    indx_class = tf.concat(indx_class, axis=0)
    scores_class = tf.concat(scores_class, axis=0)
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
    saver.restore(sess, "./save_para/.\\model.ckpt")

    INDX_CLASS, PRED_BBOXES, SCORES_CLASS = sess.run([indx_class, pred_bboxes, scores_class], feed_dict={inputs: img[np.newaxis, :, :, :]})
    bboxes, class_num = select_bbox_again(INDX_CLASS, SCORES_CLASS, PRED_BBOXES)
    for i in range(bboxes.shape[0]):
        try:
            img = draw_bbox(img, np.int32(bboxes[i]), OBJECT_NAMES[class_num[i]])
        except:
            continue
    Image.fromarray(np.uint8(img)).show()
 def __init__(self):
     self.clean_img = tf.placeholder(tf.float32, [None, None, None, IMG_C])
     self.noised_img = tf.placeholder(tf.float32, [None, None, None, IMG_C])
     self.train_phase = tf.placeholder(tf.bool)
     form_resnet = FormResNet("FormResNet")
     self.denoised_img, self.res = form_resnet(self.noised_img, self.train_phase)
     self.L_pix = tf.reduce_mean(tf.reduce_sum(tf.square(self.denoised_img - self.clean_img), [1, 2, 3]))
     # self.Phi = vgg16(tf.concat([self.denoised_img, self.denoised_img, self.denoised_img], 3))
     # self.Phi_ = vgg16(tf.concat([self.clean_img, self.clean_img, self.clean_img], 3))
     self.Phi = vgg16(self.denoised_img)
     self.Phi_ = vgg16(self.clean_img)
     self.L_feat = tf.reduce_mean(tf.square(self.Phi - self.Phi_))
     self.L_grad = tf.reduce_mean(tf.reduce_sum(tf.abs(sobel(self.denoised_img)[0] - sobel(self.clean_img)[0]) +\
                   tf.abs(sobel(self.denoised_img)[1] - sobel(self.clean_img)[1]), [1, 2, 3]))
     self.L_cross = (1 - ALPHA - BETA) * self.L_pix + ALPHA * self.L_feat + BETA * self.L_grad
     self.Opt = tf.train.AdamOptimizer(1e-4).minimize(self.L_cross)
     self.sess = tf.Session()
     saver = tf.train.Saver()
     # saver.restore(self.sess, "./save_para_3_sigma25_2/FormResNet25.ckpt")
     saver.restore(self.sess, "./sigma50_6000/FormResNet50.ckpt")
 def __init__(self):
     self.clean_img = tf.placeholder(tf.float32, [None, None, None, IMG_C])
     self.noised_img = tf.placeholder(tf.float32, [None, None, None, IMG_C])
     self.train_phase = tf.placeholder(tf.bool)
     form_resnet = FormResNet("FormResNet")
     self.denoised_img, self.res = form_resnet(self.noised_img,
                                               self.train_phase)
     self.L_pix = tf.reduce_mean(
         tf.reduce_sum(tf.square(self.denoised_img - self.clean_img),
                       [1, 2, 3]))
     # self.Phi = vgg16(tf.concat([self.denoised_img, self.denoised_img, self.denoised_img], 3))
     # self.Phi_ = vgg16(tf.concat([self.clean_img, self.clean_img, self.clean_img], 3))
     self.Phi = vgg16(self.denoised_img)
     self.Phi_ = vgg16(self.clean_img)
     self.L_feat = tf.reduce_mean(tf.square(self.Phi - self.Phi_))
     self.L_grad = tf.reduce_mean(tf.reduce_sum(tf.abs(sobel(self.denoised_img)[0] - sobel(self.clean_img)[0]) +\
                   tf.abs(sobel(self.denoised_img)[1] - sobel(self.clean_img)[1]), [1, 2, 3]))
     self.L_cross = (
         1 - ALPHA -
         BETA) * self.L_pix + ALPHA * self.L_feat + BETA * self.L_grad
     self.Opt = tf.train.AdamOptimizer(1e-4).minimize(self.L_cross)
     self.sess = tf.Session()
     self.sess.run(tf.global_variables_initializer())
Exemple #4
0
def train():
    inputs = tf.placeholder(tf.float32, [None, 448, 448, 3])
    labels = tf.placeholder(tf.float32, [None, 7, 7, 25])
    prediction = vgg16(inputs)
    loss, loss_bboxes, loss_confidence_obj, loss_confidence_noobj, loss_class = yolo_loss(prediction, labels)
    Opt = tf.train.MomentumOptimizer(1e-3, momentum=0.9).minimize(loss)
    sess = tf.Session()
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
    # saver.restore(sess, "./save_para/.\\model.ckpt")
    for i in range(10000):
        batch_img, batch_labels = read_batch(img_path, xml_path, BATCH_SIZE)
        sess.run(Opt, feed_dict={inputs: batch_img, labels: batch_labels})
        [LOSS, b, o, n, c] = sess.run([loss, loss_bboxes, loss_confidence_obj, loss_confidence_noobj, loss_class], feed_dict={inputs: batch_img, labels: batch_labels})
        print("Iteration: %d, Loss: %f, loss_bbox: %f, loss_confi_obj: %f, loss_confi_noobj: %f, loss_class: %f"%(i, LOSS, b, o, n, c))
        if i % 500 == 0:
            saver.save(sess, "./save_para/model.ckpt")
Exemple #5
0
def main(argv=None):

    ## Create the directory for training model
    if gfile.Exists(TRAIN_MODEL_DIR):
        gfile.DeleteRecursively(TRAIN_MODEL_DIR)
    gfile.MakeDirs(TRAIN_MODEL_DIR)

    # Using logging to output and record everything
    # set up logging to file
    util.set_logging(os.path.join(TRAIN_MODEL_DIR, 'myapp.log'))

    # Write down all the FLAGS
    logging.info('FLAG information')
    for key, value in tf.app.flags.FLAGS.__flags.iteritems():
        logging.info( 'FLAG(%s) : %s'%(key, str(value)))


    # Select the dataset
    if FLAGS.dataset == 'cifar10':
        ds = cifar10()
    elif FLAGS.dataset == 'cifar100':
        ds = cifar100()
    else:
        raise ValueError('Wrong dataset name. Check FLAGS.dataset')

    # Download the dataset
    ds.maybe_download()

    # Read data
    train_data, train_labels = ds.read_data(True)

    TRAIN_SIZE = train_labels.shape[0]
    logging.info('Training Size = %d', TRAIN_SIZE)


    # This is where training samples and labels are fed to the graph.
    # These placeholder nodes will be fed a batch of training data at each
    # training step using the {feed_dict} argument to the Run() call below.
    # This part depends on the Dataset
    train_data_node = tf.placeholder(
        tf.float32,
        shape=(FLAGS.batch_size, ds.image_size(), ds.image_size(), ds.num_channel()), name='data_node')
    train_labels_node = tf.placeholder(tf.float32,
                                     shape=(FLAGS.batch_size, ds.num_label()), name='label_node')
    tf.image_summary('images', train_data_node, max_images=FLAGS.batch_size)

    # Training Model Architecture
    # Select the network
    if FLAGS.network == 'vgg16':
        network = vgg16()
    elif FLAGS.network == 'snn30k':
        network = snn30k()
    elif FLAGS.network == 'snn30k_wo_norm':
        network = snn30k_wo_norm()
    else:
        raise ValueError('Wrong dataset name. Check FLAGS.network')




    network_dict= network.model2(data=train_data_node, num_label=ds.num_label() , d1=FLAGS.d1, d2=FLAGS.d2, pair=FLAGS.pair, train=True)
    logits = network_dict['softmax_linear']
    softmax = tf.nn.softmax(logits)
    tf.histogram_summary('logits', logits)
    tf.histogram_summary('softmax',softmax)


    # Define Objective Function
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
        logits, train_labels_node), name='cross_entropy')
    tf.add_to_collection('losses', cross_entropy )
    loss = tf.add_n(tf.get_collection('losses'), name='total_loss')
    tf.add_to_collection('show', cross_entropy)
    tf.add_to_collection('show', loss)
    tf.scalar_summary('loss/total_loss', loss)
    tf.scalar_summary('loss/entropy', cross_entropy)

    # Optimizer: set up a variable that's incremented once per batch and
    # controls the learning rate decay.
    batch = tf.Variable(0)
    # Decay once per epoch, using an exponential schedule starting at 0.01.
    learning_rate = tf.train.exponential_decay(
        FLAGS.learning_rate,                # Base learning rate.
        batch * FLAGS.batch_size ,          # Current index into the dataset.
        TRAIN_SIZE * FLAGS.decay_step,      # Decay step.
        FLAGS.decay_rate,                   # Decay rate.
        staircase=True,
        name='learning_rate'
        )
    #learning_rate = tf.Variable(FLAGS.learning_rate, name='learning_rate')

    tf.scalar_summary("learning_rate", learning_rate)
    tf.add_to_collection('show', learning_rate)
    # Use simple momentum for the optimization.
    optimizer = tf.train.MomentumOptimizer(learning_rate, FLAGS.momentum)
#    optimizer = tf.train.AdamOptimizer(learning_rate)

    # Compute the gradients for a list of variables.
    grads_and_vars = optimizer.compute_gradients(loss, var_list=tf.all_variables())

    # Let Batch normalization variables have higher learning rate
    clipped_grads_and_vars = []
    """
    for gv in grads_and_vars:
        if gv[0] is not None:
            if 'bn_weights' in gv[1].name:
                clipped_grads_and_vars.append([tf.mul(gv[0], tf.constant([1.00001]) ), gv[1]])
            elif 'bn_biases' in gv[1].name:
                clipped_grads_and_vars.append([tf.mul(gv[0], tf.constant([1.00001]) ), gv[1]])
            else:
                clipped_grads_and_vars.append([gv[0] , gv[1]])


    train_op = optimizer.apply_gradients(clipped_grads_and_vars, global_step=batch)
    """
    train_op = optimizer.apply_gradients(grads_and_vars, global_step=batch)

    # Build the summary operation based on the TF collection of Summaries.
    summary_op = tf.merge_all_summaries()

    train_loss=[]
    train_error= []

    # Create a local session to run this computation.
    with tf.Session() as s:
        # Create a saver to store all the variables later
        saver = tf.train.Saver(tf.all_variables())
        # Run all the initializers to prepare the trainable parameters.
        tf.initialize_all_variables().run()

        summary_writer = tf.train.SummaryWriter(TRAIN_MODEL_DIR,
                                            graph_def=s.graph_def)


        offset_old = 0
        logging.info('Initialized!')
        ret = []


        # Loop through training steps.
        num_steps = FLAGS.num_epochs * TRAIN_SIZE // FLAGS.batch_size
        session_start_time = time.time()
        for step in xrange(FLAGS.num_epochs * TRAIN_SIZE // FLAGS.batch_size):
            # Compute the offset of the current minibatch in the data.
            # Note that we could use better randomization across epochs.
            offset = (step * FLAGS.batch_size) % (TRAIN_SIZE - FLAGS.batch_size)
            batch_data = train_data[offset:(offset + FLAGS.batch_size), :, :, :]
            batch_labels = train_labels[offset:(offset + FLAGS.batch_size)]
            # This dictionary maps the batch data (as a np array) to the
            # node in the graph is should be fed to.
            feed_dict = {train_data_node: batch_data,
                   train_labels_node: batch_labels}
            start_time = time.time()
            # Run the graph and fetch some of the nodes.
            # Remind : (train_op) is the most parameter here. Without it, Tensorflow will not do the backpropogation.
            ret.append( s.run(
                tf.get_collection('show')+[logits, train_op],
                feed_dict=feed_dict) )
            duration = time.time() - start_time

            train_error.append( util.error_rate(ret[-1][-2], batch_labels ))

            if step % FLAGS.iter_print_train_info == (FLAGS.iter_print_train_info-1):
                # Print the training Information
                logging.info('Epoch %.2f, Step %d' % ((float(step) * FLAGS.batch_size / TRAIN_SIZE), step))

                # Print the time information
                sec_per_batch = float(duration)
                remaining_sec  = int(float((time.time() - session_start_time)/step) * float(num_steps - step))
                remaining_time = str(datetime.timedelta(seconds=remaining_sec))
                logging.info('%.3f sec/batch, remaining time = %s' %(sec_per_batch, remaining_time))

                ret = np.array(ret)
                for idx, var in enumerate(tf.get_collection('show')):
                    logging.info('Average (%s): %f' % (var.name, np.mean(ret[:, idx])) )

                logging.info('Average Train error: %.2f%%' % np.mean(train_error))

                train_error = []
                ret = []
                print('\n')
                sys.stdout.flush()

            if step % 100==99:
                # Save the summary information
                logging.info('Save the summary information')
                summary_str = s.run(summary_op, feed_dict)
                summary_writer.add_summary(summary_str, step)

            # Per Epoch
            if(offset < offset_old ):
                cur_epoch =np.round((float(step) * FLAGS.batch_size / TRAIN_SIZE))
                cur_epoch = int(cur_epoch)
                logging.info('Epoch %d' % cur_epoch)

                # Randomize Data for Batch normalization
                logging.info('Reorder data order for Batch Normalization')
                rand_idx = np.random.permutation(len(train_labels))
                train_data   = train_data[rand_idx, :, :, :]
                train_labels = train_labels[rand_idx, :]

                # Horizontal mirroring
                logging.info('Randomly horizontal flip the Images')
                mir_idx  = np.random.randint(2, size= len(train_labels))
                mir_idx = np.nonzero(mir_idx > 0 )[0]
                for i in range(ds.num_channel()):
                    train_data[mir_idx, :, :, i ] = train_data[mir_idx, :, ::-1, i]

                if((cur_epoch % 10) == 9):
                    # Save Model
                    checkpoint_path = os.path.join(TRAIN_MODEL_DIR, 'model.ckpt')
                    logging.info('Save the model : %s'%(checkpoint_path))
                    saver.save(s, checkpoint_path, global_step=step)

                sys.stdout.flush()

            offset_old = offset

        # Save the last model
        logging.info('Save the model : %s'%(checkpoint_path))
        saver.save(s, checkpoint_path, global_step=step)