def export(): with tf.Graph().as_default(): #TODO(xuesen) for serving serialized_tf_example = tf.placeholder(tf.string, name='tf_example') feature_configs = { 'image/encoded': tf.FixedLenFeature(shape=[], dtype=tf.string), } tf_example = tf.parse_example(serialized_tf_example, feature_configs) jpegs = tf_example['image/encoded'] images = tf.map_fn(preprocess_image, jpegs, dtype=tf.float32) # Run inference. feature = vgg.inference(images) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, 'model/inshop.sgd.adam') # Export inference model. init_op = tf.group(tf.initialize_all_tables(), name='init_op') #TODO() Export inference model using regression_signture ? feat_signature = exporter.regression_signature( input_tensor=serialized_tf_example, output_tensor=feature) named_graph_signature = { 'inputs': exporter.generic_signature({'images': jpegs}), 'outputs': exporter.generic_signature({'feats': feature}) } model_exporter = exporter.Exporter(saver) model_exporter.init(default_graph_signature=feat_signature, init_op=init_op, named_graph_signatures=named_graph_signature) model_exporter.export('model/vgg_serving', tf.constant(150000), sess) print('Successfully exported model to model/.')
def image_test_custom(): """Train CIFAR-10 for a number of steps.""" with tf.Graph().as_default(): img_name = '9_363_3.BMP' img_normal = imread('E:/final Project/3.4.19/croped vids/matlab custom/' + img_name) img_normal = np.transpose(img_normal, [1, 0, 2]) img_normal_in = np.reshape(img_normal,[1,160,160,3]) image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu, tf.constant(False)) logits = graph['s'] logits = tf.transpose(logits) logits_r = tf.reshape(logits,[vgg.batch_size]) saver = tf.train.Saver(tf.global_variables()) config = tf.ConfigProto(allow_soft_placement = True) sess = tf.Session(config=config) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg19_train_holes/') init = tf.global_variables_initializer() sess.run(init) saver.restore(sess, ckpt) out_normal = sess.run(logits, feed_dict={image: img_normal_in})[0][0] print('custom: ',out_normal) print('done')
def main(): network = importlib.import_module(net_name) with tf.Graph().as_default(): with tf.Session() as sess: input_tensor = tf.placeholder(dtype=tf.float32, shape=[1, 96, 96, 3], name='input') #images_placeholder = tf.placeholder(name='input', shape=[None, 96, 96, 3], dtype=tf.float32) # Load the model metagraph and checkpoint cpkt_file_path = os.path.join( "./ToBeConvertModels/checkpoint/0.449233.ckpt") # Build the inference graph predict_labels = vgg.inference(input_tensor, phase_train=False) saver = tf.train.Saver() tf.get_default_session().run(tf.global_variables_initializer()) tf.get_default_session().run(tf.local_variables_initializer()) saver.restore(tf.get_default_session(), cpkt_file_path) # Retrieve the protobuf graph definition and fix the batch norm nodes input_graph_def = sess.graph.as_graph_def() # Freeze the graph def output_graph_def = freeze_graph_def(sess, input_graph_def, [ "vgg_16/yaw_fc8/BiasAdd", "vgg_16/pitch_fc8/BiasAdd", "vgg_16/roll_fc8/BiasAdd" ]) # Serialize and dump the output graph to the filesystem with tf.gfile.GFile("./ConvertedModels/output.pb", 'wb') as f: f.write(output_graph_def.SerializeToString())
def export(): with tf.Graph().as_default(): # Build inference model. # Please refer to Tensorflow inception model for details. # Input transformation. jpegs = tf.placeholder(tf.string) images = tf.map_fn(preprocess_image, jpegs, dtype=tf.float32) print(images) # Run inference. feature = vgg.inference(images) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, 'model/inshop.sgd.adam') # Export inference model. init_op = tf.group(tf.initialize_all_tables(), name='init_op') model_exporter = exporter.Exporter(saver) signature = exporter.classification_signature( input_tensor=jpegs, classes_tensor=None, scores_tensor=feature) model_exporter.init(default_graph_signature=signature, init_op=init_op) model_exporter.export('model', tf.constant(150000), sess) print('Successfully exported model to model/.')
def image_list_test(): """Train CIFAR-10 for a number of steps.""" with tf.Graph().as_default(): image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu, tf.constant(False)) logits = graph['s'] logits = tf.transpose(logits) logits_r = tf.reshape(logits,[vgg.batch_size]) saver = tf.train.Saver(tf.global_variables()) config = tf.ConfigProto(allow_soft_placement = True) sess = tf.Session(config=config) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg19_train_holes/') init = tf.global_variables_initializer() sess.run(init) saver.restore(sess, ckpt) image_list = os.listdir('E:/final Project/3.4.19/croped vids/matlab normal/') normal_result = [] top_result = [] middle_result = [] bottom_result = [] for img_name in image_list: img_normal = imread('E:/final Project/3.4.19/croped vids/matlab normal/' + img_name) img_top = imread('E:/final Project/3.4.19/croped vids/matlab top/' + img_name) img_middle = imread('E:/final Project/3.4.19/croped vids/matlab middle/' + img_name) img_bottom = imread('E:/final Project/3.4.19/croped vids/matlab bottom/' + img_name) img_normal = np.transpose(img_normal, [1, 0, 2]) img_normal_in = np.reshape(img_normal,[1,160,160,3]) img_top = np.transpose(img_top, [1, 0, 2]) img_top_in = np.reshape(img_top,[1,160,160,3]) img_middle = np.transpose(img_middle, [1, 0, 2]) img_middle_in = np.reshape(img_middle,[1,160,160,3]) img_bottom = np.transpose(img_bottom, [1, 0, 2]) img_bottom_in = np.reshape(img_bottom,[1,160,160,3]) out_normal = sess.run(logits, feed_dict={image: img_normal_in})[0][0] out_top = sess.run(logits, feed_dict={image: img_top_in})[0][0] out_middle = sess.run(logits, feed_dict={image: img_middle_in})[0][0] out_bottom = sess.run(logits, feed_dict={image: img_bottom_in})[0][0] normal_result.append(out_normal) top_result.append(out_top) middle_result.append(out_middle) bottom_result.append(out_bottom) print('done')
def __init__(self,model_path='model/inshop.sgd.adam'): self.model_path = model_path self.x = tf.placeholder(tf.string,shape=[]) img = tf.image.decode_jpeg(self.x,channels=3) img = tf.expand_dims(utils.preprocess_image(img),0) self.feature = vgg.inference(img) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction = 0.3) self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) assert tf.gfile.Exists(self.model_path) saver = tf.train.Saver() print('Using model from {}'.format(self.model_path)) saver.restore(self.sess,self.model_path)
def batch_test(): """Train CIFAR-10 for a number of steps.""" with tf.Graph().as_default(): images, labels = vgg.inputs(eval_data='test') graph = vgg.inference(images,gpu) logits = graph['s'] logits = tf.transpose(logits) # Calculate loss. logits_r = tf.reshape(logits,[vgg.batch_size]) diff = vgg.ang_diff(logits_r,labels) true_count = tf.reduce_sum(tf.cast(tf.less(diff,25),tf.uint8)) saver = tf.train.Saver(tf.global_variables()) config = tf.ConfigProto(allow_soft_placement = True) sess = tf.Session(config=config) # Start the queue runners. tf.train.start_queue_runners(sess=sess) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg_19_train_cont/') init = tf.global_variables_initializer() sess.run(init) saver.restore(sess, ckpt) true_count_sum = 0 # Counts the number of correct predictions. diffs = np.array([]) for i in range(FLAGS.test_batch_size): true_count_ ,diff_= sess.run([true_count,tf.unstack(diff)]) true_count_sum += true_count_ diffs = np.append(diffs,diff_) if diff_[0] <= 25: print(i," :",diff_[0]) diffs_var = np.var(diffs) diffs_mean = np.mean(diffs) # Compute precision @ 1. precision = true_count_sum / (FLAGS.test_batch_size*FLAGS.batch_size) print('%s: precision @ 1 = %.3f' % (datetime.now(), precision)) print('done')
def cnn_vis(): with tf.Graph().as_default(): img_name = '9_363.BMP' img_normal = imread('E:/final Project/3.4.19/croped vids/matlab normal/' + img_name) image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) img_normal = np.transpose(img_normal, [1, 0, 2]) img_normal_in = np.reshape(img_normal,[1,160,160,3]) graph = vgg.inference(image, gpu, tf.constant(False)) logits = graph['s'] logits = tf.transpose(logits) logits_r = tf.reshape(logits,[vgg.batch_size]) saver = tf.train.Saver(tf.global_variables()) config = tf.ConfigProto(allow_soft_placement = True) sess = tf.Session(config=config) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg19_train_holes/') init = tf.global_variables_initializer() sess.run(init) saver.restore(sess, ckpt) cnnvis({image: img_normal_in},sess) print('done')
def walk(): date = datetime.now() date_str = date.strftime("%d")+date.strftime("%m")+date.strftime("%y")+'_'+date.strftime("%H")+date.strftime("%M")+date.strftime("%S") kml_name = date_str + '.kml' _step_dist = 350 size = 5 lat = 31.62489921 lon = 34.84234767 bearing = 0.5754 heading = 296.9 kml=simplekml.Kml() kml.newpoint(name='0', coords=[(lon,lat)]) kml.save(kml_name) with tf.Graph().as_default() as g: image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu, tf.constant(False)) logits = graph['s'] config = tf.ConfigProto(allow_soft_placement = True) sess = tf.InteractiveSession(config=config) init = tf.global_variables_initializer() sess.run(init) summary = tf.Summary() summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter('D:/tensorflow_fs/vgg_eval/', g) saver = tf.train.Saver(graph['v']) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg_19_train_test/RG_0_622/') saver.restore(sess, ckpt) point_list = [] cord_list = [] ang_diff_list = [] compare_list = [] step = 0 while ((dist.distance((31.669251,34.741851),(lat,lon)).m > 150) and step < 40): next_heading = (heading + bearing)%360 step_dist = _step_dist new_lat,new_lon = destinationPoint(lat, lon, step_dist, next_heading) points = find_closest_points(new_lat, new_lon, next_heading,size) cord_list += [[new_lat, new_lon, bearing, next_heading, heading]] heading = HeadingTo([lat, lon], [new_lat, new_lon]) lat, lon = new_lat, new_lon if (points[0] == []): raise 'did not find point' point_list += [points] ang_diff_list +=[[points[0][1],points[0][2]]] kml.newpoint(name=str(step+1), coords=[(new_lon,new_lat)]) kml.save(kml_name) bearings = [[]]*len(points) for p in range(len(points)): if (points[p] != []): ang_diff = points[p][2] file_name = points[p][0][3] frame_num = int(points[p][0][4]) p_lat = float(points[p][0][0]) p_lon = float(points[p][0][1]) if (file_name in ['33','34','35', '46', '47', '50', '51_1', '53', '54']): filetype = '.mp4' else: filetype = '.mov' filename = 'E:/Final Project/walk/vids/DJI_00' + file_name + filetype vid = imageio.get_reader(filename,'ffmpeg') img = vid.get_data(frame_num) img_rsz_t = imresize(img,[160,160,3]) if (p == 0): print('vid: '+ str(file_name) + ', frame num: '+ str(frame_num) + ', filetype: ' + filetype) img_in = np.reshape(img_rsz_t,[1,160,160,3]) b_c = bearing_compensation([p_lat,p_lon],[lat,lon]) bearings[p] = (sess.run(logits, feed_dict={image: img_in,is_training: False})[0][0] - ang_diff + b_c) bearing_avg = np.average(bearings) compare_list += [bearings,bearing_avg,[z[2] for z in points]] bearing = bearing_avg step += 1 cv2.destroyAllWindows() print(cord_list)
def train(): print(FLAGS.train_dir) with tf.Session() as sess: global_step = tf.contrib.framework.get_or_create_global_step() images = tf.placeholder(tf.float32, shape=(FLAGS.batch_size, IMAGE_SIZE, IMAGE_SIZE, 3)) labels = tf.placeholder(tf.int32, shape=(FLAGS.batch_size)) indexes = tf.placeholder(tf.int32, shape=(FLAGS.batch_size)) #mode_eval = tf.placeholder(tf.bool, shape=()) keep_prob = tf.placeholder(tf.float32) # Build a Graph that computes the logits predictions from the # inference model. logits = vgg.inference(images, keep_prob) # Calculate loss. loss = vgg.loss(logits, labels) top_k_op = tf.nn.in_top_k(logits, labels, 1) prediction = tf.argmax(logits, 1) #tf.summary.scalar('prediction', loss) cmatix = tf.contrib.metrics.confusion_matrix(prediction, labels) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. train_op = vgg.train(loss, global_step) #train = tf.train.GradientDescentOptimizer(0.00001).minimize(loss) tf.summary.scalar('dropout_keep_probability', keep_prob) # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph) writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph) # summary_writer_validation = tf.summary.FileWriter(FLAGS.validate_dir) # Build an initialization operation to run below. init = tf.global_variables_initializer() sess.run(init) # Start the queue runners. tf.train.start_queue_runners(sess=sess) # Create a saver. saver = tf.train.Saver(tf.global_variables()) loss_train = np.array([]) loss_valid = np.array([]) precision_test = np.array([]) steps_train = np.array([]) steps_valid = np.array([]) steps_precision = np.array([]) confusion_matrix_predictions = np.array([]) confusion_matrix_labels = np.array([]) EPOCH = 0 start_time_global = time.time() for step in xrange(FLAGS.max_steps): #if step > 100: FLAGS.__setattr__("INITIAL_LEARNING_RATE", 0.001) if (step % EPOCHS_NUM == 0) and step > 300: print("validating") #assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step != 0: EPOCH = EPOCH + 1 # feeding data for validation images_batch, labels_batch, index_batch = sess.run( [images_v, labels_v, indexs_v]) # Run model _, loss_value = sess.run( [train_op, loss], feed_dict={ images: images_batch, labels: labels_batch, indexes: index_batch, keep_prob: 1.0 }) print('%s: loss = %.5f' % (datetime.now(), loss_value)) loss_valid = np.concatenate((loss_valid, [loss_value])) steps_valid = np.concatenate((steps_valid, [EPOCH])) else: #print("here") #print (step) start_time = time.time() # feed data for training images_batch, labels_batch, index_batch = sess.run( [images_t, labels_t, indexs_t]) # Run model _, loss_value, summary_str = sess.run( [train_op, loss, summary_op], feed_dict={ images: images_batch, labels: labels_batch, indexes: index_batch, keep_prob: 0.5 }) duration = time.time() - start_time assert not np.isnan( loss_value), 'Model diverged with loss = NaN' if step % 10 == 0: #summary_str = sess.run([summary_op], # feed_dict={images: images_batch, labels: labels_batch, indexes: index_batch, keep_prob: 0.5}) writer.add_summary(summary_str, step) if step % 200 == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ( '%s: step %d, loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch)') print(format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) if (step - 2) % EPOCHS_NUM == 0: loss_train = np.concatenate((loss_train, [loss_value])) steps_train = np.concatenate((steps_train, [EPOCH])) # Save the model checkpoint periodically. if step % 1000 == 0 or (step + 1) == FLAGS.max_steps: checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) np.savez(FLAGS.train_dir + '_losses.npz', steps_train=steps_train, loss_train=loss_train, steps_valid=steps_valid, loss_valid=loss_valid, precision=precision_test, steps_precision=steps_precision, confusion_matrix_predictions= confusion_matrix_predictions, confusion_matrix_labels=confusion_matrix_labels) if EPOCH == 400: break final_time_global = time.time() print("Finish") print(final_time_global - start_time_global) sess.close()
def train(): """Train CIFAR-10 for a number of steps.""" with tf.Graph().as_default(): global_step = tf.Variable(0, trainable=False) num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size)) images_train, labels_train = vgg.distorted_inputs() images_val, labels_val = vgg.inputs(eval_data='test') is_training = tf.placeholder('bool', [], name='is_training') images, labels = tf.cond(is_training, lambda: (images_train, labels_train), lambda: (images_val, labels_val)) # Build a Graph that computes the logits predictions from the # inference model. graph = vgg.inference(images,gpu,is_training) logits = graph['s'] params = graph['p'] logits = tf.transpose(logits) # Calculate loss. loss = vgg.loss(logits, labels) logits_r = tf.reshape(logits,[vgg.batch_size]) diff = vgg.ang_diff(logits_r,labels) true_count = tf.reduce_sum(tf.cast(tf.less(diff,25),tf.uint8)) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. train_op = vgg.train(loss, global_step) # Create a saver. saver = tf.train.Saver(tf.global_variables()) summary = tf.Summary() # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # Build an initialization operation to run below. init = tf.global_variables_initializer() # Start running operations on the Graph. config = tf.ConfigProto(allow_soft_placement = True) #config.gpu_options.allow_growth = True sess = tf.Session(config=config) checkpoint_path = os.path.join(FLAGS.train_dir, 'model.ckpt') # Start the queue runners. tf.train.start_queue_runners(sess=sess) summary_writer = tf.compat.v1.summary.FileWriter(FLAGS.eval_dir, sess.graph) if (FLAGS.Resume): ckpt = tf.train.get_checkpoint_state(FLAGS.train_dir) if ckpt and ckpt.model_checkpoint_path: # Restores from checkpoint saver.restore(sess, ckpt.model_checkpoint_path) global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] sub_saver = tf.train.Saver(graph['v']) sub_saver.save(sess, FLAGS.train_dir) else: print('No checkpoint file found') return else: sess.run(init,{ is_training: False }) load_weights(params,'vgg19.npy', sess) test_iters = 11 total_sample_count = test_iters * FLAGS.batch_size for step in range(FLAGS.max_steps): start_time = time.time() _, loss_value = sess.run([train_op, loss],{ is_training: True }) duration = time.time() - start_time assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step > 1 and step % 250 == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch)') print (format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) summary_str = sess.run(summary_op,{ is_training: False }) summary_writer.add_summary(summary_str, step) summary.ParseFromString(sess.run(summary_op,{ is_training: False })) summary_writer.add_summary(summary, step) if step > 1 and step % 1000== 0 or (step + 1) == FLAGS.max_steps: true_count_sum = 0 # Counts the number of correct predictions. diffs = np.array([]) for i in range(test_iters): true_count_ ,diff_= sess.run([true_count,tf.unstack(diff)],{ is_training: False }) true_count_sum += true_count_ diffs = np.append(diffs,diff_) diffs_var = np.var(diffs) diffs_mean = np.mean(diffs) # Compute precision @ 1. precision = true_count_sum / total_sample_count print('%s: precision @ 1 = %.3f' % (datetime.now(), precision)) summary.ParseFromString(sess.run(summary_op,{ is_training: False })) summary.value.add(tag='Precision @ 1', simple_value=precision) summary.value.add(tag='diffs_var', simple_value=diffs_var) summary.value.add(tag='diffs_mean', simple_value=diffs_mean) summary_writer.add_summary(summary, step) # Save the model checkpoint periodically. saver.save(sess, checkpoint_path, global_step=step)
def run_training(): #1.create log and model saved dir according to the datetime subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') models_dir = os.path.join("saved_models", subdir, "models") if not os.path.isdir(models_dir): # Create the model directory if it doesn't exist os.makedirs(models_dir) logs_dir = os.path.join("saved_models", subdir, "logs") if not os.path.isdir(logs_dir): # Create the log directory if it doesn't exist os.makedirs(logs_dir) topn_models_dir = os.path.join("saved_models", subdir, "topn")#topn dir used for save top accuracy model if not os.path.isdir(topn_models_dir): # Create the topn model directory if it doesn't exist os.makedirs(topn_models_dir) topn_file=open(os.path.join(topn_models_dir,"topn_acc.txt"),"a+") topn_file.close() #2.load dataset and define placeholder demo=TFRecordDataset( ) train_iterator,train_next_element=demo.generateDataset(tfrecord_path='tfrecord_dataset/train.tfrecords',batch_size=512) phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') images_placeholder = tf.placeholder(name='input', shape=[None, 96, 96, 3], dtype=tf.float32) binned_pose_placeholder = tf.placeholder(name='binned_pose', shape=[None,3 ], dtype=tf.int64) cont_labels_placeholder = tf.placeholder(name='cont_labels', shape=[None,3 ], dtype=tf.float32) yaw,pitch,roll = vgg.inference(images_placeholder,phase_train=phase_train_placeholder) yaw_logit = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=yaw,labels=binned_pose_placeholder[:,0]) pitch_logit = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=pitch,labels=binned_pose_placeholder[:,1]) roll_logit = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=roll,labels=binned_pose_placeholder[:,2]) loss_yaw = tf.reduce_mean(yaw_logit) loss_pitch = tf.reduce_mean(pitch_logit) loss_roll = tf.reduce_mean(roll_logit) softmax_yaw=tf.nn.softmax(yaw) softmax_pitch=tf.nn.softmax(pitch) softmax_roll=tf.nn.softmax(roll) yaw_predicted = tf.math.reduce_sum( (softmax_yaw * tf.linspace(0.0,66.0,67) ), 1 )* 3 - 99 pitch_predicted = tf.math.reduce_sum( (softmax_pitch * tf.linspace(0.0,66.0,67) ), 1 )* 3 - 99 roll_predicted = tf.math.reduce_sum( (softmax_roll * tf.linspace(0.0,66.0,67) ), 1 )* 3 - 99 yaw_mse_loss = tf.losses.mean_squared_error(labels=cont_labels_placeholder[:,0], predictions=yaw_predicted) pitch_mse_loss = tf.losses.mean_squared_error(labels=cont_labels_placeholder[:,1], predictions=pitch_predicted) roll_mse_loss = tf.losses.mean_squared_error(labels=cont_labels_placeholder[:,2], predictions=roll_predicted) alpha = 0.001 total_loss_softmax=(loss_yaw+loss_pitch+loss_roll) total_loss_mse = alpha*(yaw_mse_loss+pitch_mse_loss+roll_mse_loss) total_loss = total_loss_softmax+total_loss_mse yaw_correct_prediction = tf.equal(tf.argmax(yaw,1),binned_pose_placeholder[:,0] ) pitch_correct_prediction = tf.equal(tf.argmax(pitch,1),binned_pose_placeholder[:,1] ) roll_correct_prediction = tf.equal(tf.argmax(roll,1),binned_pose_placeholder[:,2] ) yaw_accuracy = tf.reduce_mean(tf.cast(yaw_correct_prediction, tf.float32)) pitch_accuracy = tf.reduce_mean(tf.cast(pitch_correct_prediction, tf.float32)) roll_accuracy = tf.reduce_mean(tf.cast(roll_correct_prediction, tf.float32)) #adjust learning rate global_step = tf.Variable(0, trainable=False) #learning_rate = tf.train.exponential_decay(0.001,global_step,100000,0.98,staircase=True) learning_rate = tf.train.piecewise_constant(global_step, boundaries=[8000, 16000, 24000, 32000], values=[0.001, 0.0001, 0.0001, 0.00001, 0.000001],name='lr_schedule') #optimize loss and update #optimizer = tf.train.AdamOptimizer(learning_rate, beta1=0.5) optimizer = tf.train.MomentumOptimizer(learning_rate, 0.9, use_nesterov=True) #optimizer = tf.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.9, epsilon=1.0) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = optimizer.minimize(total_loss,global_step=global_step) saver=tf.train.Saver(tf.trainable_variables(),max_to_keep=5) sess=utils.session() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) saver.restore(sess, "/home/hanson/work/FaceHeadpose_TF/saved_models/20190801-135403/models/0.563564.ckpt") minimum_loss_value=999.0 total_loss_value = 0.0 for epoch in range(1000): sess.run(train_iterator.initializer) while True: use_time=0 try: images_train, binned_pose,cont_labels = sess.run(train_next_element) start_time=time.time() input_dict={phase_train_placeholder:True,images_placeholder:images_train,binned_pose_placeholder:binned_pose,cont_labels_placeholder:cont_labels} total_loss_mse_value,total_loss_softmax_value,yaw_acc,pitch_acc,roll_acc,step,lr,train_loss,_ = sess.run([ total_loss_mse, total_loss_softmax, yaw_accuracy, pitch_accuracy, roll_accuracy, global_step, learning_rate, total_loss, train_op], feed_dict=input_dict) total_loss_value+=train_loss end_time=time.time() use_time+=(end_time-start_time) # display train result if(step%100==0): use_time=0 average_loss_value = total_loss_value/100.0 total_loss_value=0 print ("step:%d lr:%f sloss:%f mloss%f average_loss:%f YAW_ACC:%.2f PITCH_ACC:%.2f ROLL_ACC:%.2f epoch:%d"%(step, lr, total_loss_softmax_value, total_loss_mse_value, float(average_loss_value), yaw_acc, pitch_acc, roll_acc, epoch) ) if average_loss_value<minimum_loss_value: print("save ckpt") filename_cpkt = os.path.join(models_dir,"%f.ckpt"%average_loss_value) saver.save(sess, filename_cpkt) minimum_loss_value=average_loss_value except tf.errors.OutOfRangeError: print("End of epoch ") break
def run_training(): #1.create log and model saved dir according to the datetime subdir = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') models_dir = os.path.join("saved_models", subdir, "models") if not os.path.isdir( models_dir): # Create the model directory if it doesn't exist os.makedirs(models_dir) logs_dir = os.path.join("saved_models", subdir, "logs") if not os.path.isdir( logs_dir): # Create the log directory if it doesn't exist os.makedirs(logs_dir) topn_models_dir = os.path.join( "saved_models", subdir, "topn") #topn dir used for save top accuracy model if not os.path.isdir( topn_models_dir ): # Create the topn model directory if it doesn't exist os.makedirs(topn_models_dir) topn_file = open(os.path.join(topn_models_dir, "topn_acc.txt"), "a+") topn_file.close() #2.load dataset and define placeholder conf = config.get_config() demo = TFRecordDataset(conf) train_iterator, train_next_element = demo.generateDataset( tfrecord_path='tfrecord_dataset/train.tfrecords', test_mode=0, batch_size=256) phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') images_placeholder = tf.placeholder( name='input', shape=[None, conf.input_img_height, conf.input_img_width, 3], dtype=tf.float32) binned_pose_placeholder = tf.placeholder(name='binned_pose', shape=[None, 3], dtype=tf.int64) cont_labels_placeholder = tf.placeholder(name='cont_labels', shape=[None, 3], dtype=tf.float32) yaw, pitch, roll = vgg.inference(images_placeholder, phase_train=phase_train_placeholder) loss_yaw = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=yaw, labels=binned_pose_placeholder[:, 0]) loss_pitch = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=pitch, labels=binned_pose_placeholder[:, 1]) loss_roll = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=roll, labels=binned_pose_placeholder[:, 2]) softmax_yaw = tf.nn.softmax(yaw) softmax_pitch = tf.nn.softmax(pitch) softmax_roll = tf.nn.softmax(roll) yaw_predicted = tf.math.reduce_sum( (softmax_yaw * tf.linspace(0.0, 67.0, 68))) * 3 - 99 pitch_predicted = tf.math.reduce_sum( (softmax_pitch * tf.linspace(0.0, 67.0, 68))) * 3 - 99 roll_predicted = tf.math.reduce_sum( (softmax_roll * tf.linspace(0.0, 67.0, 68))) * 3 - 99 yaw_mse_loss = tf.reduce_mean( tf.square(yaw_predicted - cont_labels_placeholder[:, 0])) pitch_mse_loss = tf.reduce_mean( tf.square(pitch_predicted - cont_labels_placeholder[:, 1])) roll_mse_loss = tf.reduce_mean( tf.square(roll_predicted - cont_labels_placeholder[:, 2])) # # Total loss #loss_yaw += 0.0001 * yaw_mse_loss #loss_pitch += 0.0001 * pitch_mse_loss #loss_roll += 0.0001 * roll_mse_loss #reg_loss=tf.reduce_mean(0.0001 * yaw_mse_loss+ 0.0001 * pitch_mse_loss+ 0.0001 * roll_mse_loss) #softmax_loss=tf.reduce_mean(yaw_predicted+pitch_predicted+roll_predicted) total_loss = (loss_yaw + loss_pitch + loss_roll) #total_loss=0.0001 * yaw_mse_loss#+ 0.0001 * pitch_mse_loss+ 0.0001 * roll_mse_loss total_loss = tf.reduce_mean(loss_pitch) print(total_loss) #total_loss=reg_loss+softmax_loss #correct_prediction = tf.equal(tf.argmax(predictions,1),labels_placeholder ) #accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) #adjust learning rate global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay(0.001, global_step, 100000, 0.98, staircase=True) #optimize loss and update #optimizer = tf.train.AdamOptimizer(learning_rate, beta1=0.5) optimizer = tf.train.MomentumOptimizer(learning_rate, 0.9, use_nesterov=True) #optimizer = tf.train.RMSPropOptimizer(learning_rate, decay=0.9, momentum=0.9, epsilon=1.0) grads = optimizer.compute_gradients(total_loss) #with tf.name_scope('clip_grads'): #grads = slim.learning.clip_gradient_norms(grads, 2 ) train_op = optimizer.apply_gradients(grads, global_step=global_step) #train_op=tf.train.MomentumOptimizer(learning_rate, 0.9, use_nesterov=True).minimize(total_loss,global_step=global_step) saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=5) sess = fu.session() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) for epoch in range(conf.max_nrof_epochs): sess.run(train_iterator.initializer) while True: use_time = 0 try: images_train, binned_pose, cont_labels = sess.run( train_next_element) start_time = time.time() input_dict = { phase_train_placeholder: True, images_placeholder: images_train, binned_pose_placeholder: binned_pose, cont_labels_placeholder: cont_labels } step, lr, train_loss, _ = sess.run( [global_step, learning_rate, total_loss, train_op], feed_dict=input_dict) end_time = time.time() use_time += (end_time - start_time) #display train result if (step % conf.display_iter == 0): print("step:%d lr:%f time:%.3f total_loss:%.3f epoch:%d" % (step, lr, use_time, float(train_loss), epoch)) use_time = 0 except tf.errors.OutOfRangeError: print("End of epoch ") break
def neurons_test(): size = 3 test_points=[[31.630185, 34.821536],[31.64212421,34.79050406],[31.6483181,34.7808723],[31.6483181,34.7808723],[31.65319346,34.76873743],[31.66124538,34.7553989],[31.66512506,34.74895476]] #test_points=[[31.630185, 34.821536]] thresh = 5 with tf.Graph().as_default() as g: image = tf.compat.v1.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu,tf.constant(False)) activations = graph['a'] act_thr = {} for layer in activations: if 'fc' in layer: act_thr[layer] = np.zeros([360,activations[layer].shape[1]]) config = tf.ConfigProto(allow_soft_placement = True) sess = tf.InteractiveSession(config=config) init = tf.global_variables_initializer() sess.run(init) saver = tf.train.Saver(graph['v']) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg_19_train_test/') saver.restore(sess, ckpt) idx = 0 for lat,lon in test_points: idx = idx + 1 heading_2_dest = HeadingTo ([lat, lon],[31.669243,34.742072]) start = 1 for heading in range(start,360): points = find_closest_points2(lat, lon,heading) if (points[0] == []): raise 'did not find point' bearings = [[]]*len(points) locations = [[]]*len(points) for p in range(len(points)): if (points[p] != []): ang_diff = points[p][2] file_name = points[p][0][3] frame_num = int(points[p][0][4]) p_lat = float(points[p][0][0]) p_lon = float(points[p][0][1]) locations[p] = [p_lat,p_lon] p_heading = int(np.floor(float(points[p][0][5]))) if (file_name in ['33','34','35', '46', '47', '50', '51_1', '53', '54']): filetype = '.mp4' else: filetype = '.mov' filename = 'E:/Final Project/walk/vids/DJI_00' + file_name + filetype vid = imageio.get_reader(filename,'ffmpeg') img = vid.get_data(frame_num) img_rsz = imresize(img,[160,160,3]) img_rsz[:,:,1] = 0 if (p == 1): print('vid: '+ str(file_name) + ', frame num: '+ str(frame_num) + ', filetype: ' + filetype) img_in = np.reshape(img_rsz,[1,160,160,3]) for layer in activations: if 'fc' in layer: act_thr[layer][p_heading] += (sess.run(activations[layer],feed_dict={image: img_in})[0])/7 for layer in activations: if 'fc' in layer: scipy.io.savemat('E:/Final Project/walk/neurons/'+layer+'.mat', mdict={layer: act_thr[layer]}) print(str(idx) + ' done')
def location_test(): size = 8 lat = 31.653862 lon = 34.768527 heading = 10 heading_2_dest = HeadingTo ([lat, lon],[31.669243,34.742072]) with tf.Graph().as_default() as g: image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu, tf.constant(False)) logits = graph['s'] config = tf.ConfigProto(allow_soft_placement = True) sess = tf.InteractiveSession(config=config) init = tf.global_variables_initializer() sess.run(init,{is_training: False}) saver = tf.train.Saver(graph['v']) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg19_train_holes/') saver.restore(sess, ckpt) points = find_closest_points(lat, lon,heading,size) if (points[0] == []): raise 'did not find point' bearings = [[]]*len(points) locations = [[]]*len(points) for p in range(len(points)): if (points[p] != []): ang_diff = points[p][2] file_name = points[p][0][3] frame_num = int(points[p][0][4]) p_lat = float(points[p][0][0]) p_lon = float(points[p][0][1]) locations[p] = [p_lat,p_lon] if (file_name in ['33','34','35', '46', '47', '50', '51_1', '53', '54']): filetype = '.mp4' else: filetype = '.mov' filename = 'E:/Final Project/walk/vids/DJI_00' + file_name + filetype vid = imageio.get_reader(filename,'ffmpeg') img = vid.get_data(frame_num) img_rsz = imresize(img,[160,160,3]) img_rsz[:,:,1] = 0 if (p == 2): print('vid: '+ str(file_name) + ', frame num: '+ str(frame_num) + ', filetype: ' + filetype) img_in = np.reshape(img_rsz,[1,160,160,3]) b_c = bearing_compensation([p_lat,p_lon],[lat,lon]) bearings[p] = (sess.run(logits, feed_dict={image: img_in})[0][0] - ang_diff + b_c) bearing_avg = np.average(bearings) bearing = bearing_avg db_heading = float(points[2][0][5]) ang_diff_abs = np.minimum(np.abs(db_heading - heading_2_dest), 360 - np.abs(db_heading - heading_2_dest)) db_h_shift = (db_heading + (360 - heading_2_dest))%360 ang_diff_sign = np.sign(db_h_shift - 180) ang_diff = ang_diff_abs * ang_diff_sign print('cord: ',points[2][0][0],',',points[2][0][1],' heading: ',db_heading,', heading to dest: ',heading_2_dest,'headings diff: ',ang_diff, 'correction: ',bearing) print('done')
def batch_walk(): with tf.Graph().as_default() as g: image = tf.placeholder(dtype=tf.float32,shape=(1,160,160,3)) graph = vgg.inference(image, gpu) logits = graph['s'] config = tf.ConfigProto(allow_soft_placement = True) sess = tf.InteractiveSession(config=config) init = tf.global_variables_initializer() sess.run(init) summary = tf.Summary() summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter('D:/tensorflow_fs/vgg_eval/', g) saver = tf.train.Saver(graph['v']) ckpt = tf.train.latest_checkpoint('D:/tensorflow_fs/vgg19_train_holes/') saver.restore(sess, ckpt) for run in range(50): date = datetime.now() date_str = date.strftime("%d")+date.strftime("%m")+date.strftime("%y")+'_'+date.strftime("%H")+date.strftime("%M")+date.strftime("%S") kml_name = date_str +'run_' + str(run) + '.kml' f = open("run_log_" + str(run) + '.txt', "a") _step_dist = 350 size = 5 init_step_dist = random.randint(1000,5000) lat, lon = destinationPoint(31.62489921, 34.84234767, init_step_dist, 296.9) bearing = 0 heading = 296.9 + (random.randint(0,30) - 60) kml=simplekml.Kml() kml.newpoint(name='0', coords=[(lon,lat)]) kml.save(kml_name) step = 0 while ((dist.distance((31.669251,34.741851),(lat,lon)).m > 150) and step < 40): next_heading = (heading + bearing)%360 step_dist = _step_dist new_lat,new_lon = destinationPoint(lat, lon, step_dist, next_heading) points = find_closest_points(new_lat, new_lon, next_heading,size) heading = HeadingTo([lat, lon], [new_lat, new_lon]) lat, lon = new_lat, new_lon f.write(str(step) + ' :' + str(lat) + ',' + str(lon)+ ',' + str(heading) + '\n') if (points[0] == []): raise 'did not find point' kml.newpoint(name=str(step+1), coords=[(new_lon,new_lat)]) kml.save(kml_name) bearings = [[]]*len(points) for p in range(len(points)): if (points[p] != []): ang_diff = points[p][2] file_name = points[p][0][3] frame_num = int(points[p][0][4]) p_lat = float(points[p][0][0]) p_lon = float(points[p][0][1]) if (file_name in ['33','34','35', '46', '47', '50', '51_1', '53', '54']): filetype = '.mp4' else: filetype = '.mov' filename = 'E:/Final Project/walk/vids/DJI_00' + file_name + filetype vid = imageio.get_reader(filename,'ffmpeg') img = vid.get_data(frame_num) img_rsz = imresize(img,[160,160,3]) img_rsz[:,:,1] = 0 img_in = np.reshape(img_rsz,[1,160,160,3]) b_c = bearing_compensation([p_lat,p_lon],[lat,lon]) bearings[p] = (sess.run(logits, feed_dict={image: img_in})[0][0] - ang_diff + b_c) if (p == 0): print('vid: '+ str(file_name) + ', frame num: '+ str(frame_num) + ', filetype: ' + filetype) bearing_avg = np.average(bearings) bearing = bearing_avg step += 1 f.close()
def train(): sys.stdout.write("\033[93m") # yellow message print("Load and test model") sys.stdout.write("\033[0;0m") with tf.Session() as sess: global_step = tf.contrib.framework.get_or_create_global_step() images = tf.placeholder(tf.float32, shape=(FLAGS.batch_size, IMAGE_SIZE, IMAGE_SIZE, 3)) labels = tf.placeholder(tf.int32, shape=(FLAGS.batch_size)) indexes = tf.placeholder(tf.int32, shape=(FLAGS.batch_size)) # mode_eval = tf.placeholder(tf.bool, shape=()) keep_prob = tf.placeholder(tf.float32) # Build a Graph that computes the logits predictions from the # inference model. logits = vgg.inference(images, keep_prob) # Calculate loss. loss = vgg.loss(logits, labels) top_k_op = tf.nn.in_top_k(logits, labels, 1) prediction = tf.argmax(logits, 1) #cmatix = tf.contrib.metrics.confusion_matrix(prediction, labels) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. train_op = vgg.train(loss, global_step) # train = tf.train.GradientDescentOptimizer(0.00001).minimize(loss) # Create a saver. saver = tf.train.Saver(tf.global_variables()) # Restore the moving average version of the learned variables for eval. #variable_averages = tf.train.ExponentialMovingAverage( # vgg.MOVING_AVERAGE_DECAY) #variables_to_restore = variable_averages.variables_to_restore() #saver = tf.train.Saver(variables_to_restore) #saver = tf.train.import_meta_graph('/home/mikelf/Datasets/T-lessV2/restore_models/model.ckpt-61000.meta') saver.restore( sess, "/home/mikelf/experiments/full_test/vgg_scratch/100p/checkpoint/vgg_train_rgb_16bs01lr_SGD_100p/model.ckpt-85000" ) #sess.run(tf.global_variables_initializer()) print("Model restored.") # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # Build an initialization operation to run below. ##init = tf.global_variables_initializer() # Start running operations on the Graph. # sess = tf.Session(config=tf.ConfigProto( # log_device_placement=FLAGS.log_device_placement)) ##sess.run(init) coord = tf.train.Coordinator() # Start the queue runners. threads = tf.train.start_queue_runners(sess=sess, coord=coord) # summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph) summary_writer_train = tf.summary.FileWriter(FLAGS.train_dir, sess.graph) # summary_writer_validation = tf.summary.FileWriter(FLAGS.validate_dir) loss_train = np.array([]) loss_valid = np.array([]) precision_test = np.array([]) steps_train = np.array([]) steps_valid = np.array([]) steps_precision = np.array([]) EPOCH = 0 start_time_global = time.time() print("getting precision on test dataset") # assert not np.isnan(loss_value), 'Model diverged with loss = NaN' # feeding data for evaluation num_iter = int(math.ceil(FLAGS.num_examples / FLAGS.batch_size)) true_count = 0 # Counts the number of correct predictions. total_sample_count = num_iter * FLAGS.batch_size step = 0 x = [] cf_matrix_array = [] labels_array = [] while step < num_iter: images_batch, labels_batch, index_batch = sess.run( [images_p, labels_p, indexs_p]) predictions, cf_matrix = sess.run( [top_k_op, prediction], feed_dict={ images: images_batch, labels: labels_batch, indexes: index_batch, keep_prob: 1.0 }) true_count += np.sum(predictions) step += 1 x.extend(index_batch) cf_matrix_array = np.append(cf_matrix_array, cf_matrix, axis=0) labels_array = np.append(labels_array, labels_batch, axis=0) print(cf_matrix_array.shape) print(len(x)) dupes = [xa for n, xa in enumerate(x) if xa in x[:n]] # print(sorted(dupes)) print(len(dupes)) precision = true_count / total_sample_count print('%s: precision @ 1 = %.5f' % (datetime.now(), precision)) precision_test = np.concatenate((precision_test, [precision])) steps_precision = np.concatenate((steps_precision, [EPOCH])) final_time_global = time.time() print("Finish") print(final_time_global - start_time_global) cnf_matrix = confusion_matrix(labels_array, cf_matrix_array) np.set_printoptions(precision=2) class_names = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30' ] # Plot non-normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion matrix, without normalization') # Plot normalized confusion matrix #plt.figure() #plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=True, # title='Normalized confusion matrix') plt.show() coord.request_stop() coord.join(threads) sess.close()
def train(): with tf.Graph().as_default(): data_set = cifar10.CIFAR10() images = data_set.load(FLAGS.data_path) global_step = tf.Variable(0, trainable=False) random_z = vgg.inputs() D_logits_real, D_logits_fake, D_logits_fake_for_G, \ D_sigmoid_real, D_sigmoid_fake, D_sigmoid_fake_for_G = \ vgg.inference(images, random_z) G_loss, D_loss = vgg.loss_l2(D_logits_real, D_logits_fake, D_logits_fake_for_G) t_vars = tf.trainable_variables() G_vars = [var for var in t_vars if 'g_' in var.name] D_vars = [var for var in t_vars if 'd_' in var.name] G_train_op, D_train_op = vgg.train(G_loss, D_loss, G_vars, D_vars, global_step) sampler = vgg.sampler(random_z) #summary_op = tf.merge_all_summaries() sess = sess_init() tf.train.start_queue_runners(sess=sess) #summary_writer = tf.train.SummaryWriter(FLAGS.log_dir, sess.graph) saver = tf.train.Saver() for step in xrange(1, FLAGS.max_steps + 1): batch_z = np.random.uniform( -1, 1, [FLAGS.batch_size, FLAGS.z_dim]).astype(np.float32) _, errD = sess.run([D_train_op, D_loss], feed_dict={random_z: batch_z}) _, errG = sess.run([G_train_op, G_loss], feed_dict={random_z: batch_z}) if step % 100 == 0: print "step = %d, errD = %f, errG = %f" % (step, errD, errG) if np.mod(step, 1000) == 0: samples = sess.run(sampler, feed_dict={random_z: batch_z}) save_images(samples, [8, 8], './samples/train_{:d}.bmp'.format(step)) # if step % 1000 == 0: # summary_str = sess.run(summary_op, # feed_dict={random_z: batch_z}) # summary_writer.add_summary(summary_str, step) if step % 10000 == 0: saver.save( sess, '{0}/vgg-{1}.model'.format(FLAGS.checkpoint_dir, step), global_step)