def evaluate(network): with tf.Graph().as_default() as g: eval_data = FLAGS.eval_data == 'test' if network == 1: images, labels = cifar10.inputs(eval_data=eval_data) logits, w1, b1, w2, b2 = cifar10.create_model(images) else: images, labels = cifar10_2.inputs(eval_data=eval_data) logits, w1, b1, w2, b2 = cifar10_2.create_model(images) top_k_op = tf.nn.in_top_k(logits, labels, 1) variable_averages = tf.train.ExponentialMovingAverage( cifar10.MOVING_AVERAGE_DECAY) variables_to_restore = variable_averages.variables_to_restore() saver = tf.train.Saver(variables_to_restore) summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(FLAGS.eval_dir, g) while True: eval_once(saver, summary_writer, top_k_op, summary_op) if FLAGS.run_once: break time.sleep(FLAGS.eval_interval_secs)
def train(): with tf.Graph().as_default(): global_step = tf.contrib.framework.get_or_create_global_step() images, labels = cifar10.inputs(False) logits, fc1_w, fc2_w, fc1_b, fc2_b = cifar10.create_model(images) loss = cifar10.loss(logits, labels) regularizers = (tf.nn.l2_loss(fc1_w) + tf.nn.l2_loss(fc1_b) + tf.nn.l2_loss(fc2_w) + tf.nn.l2_loss(fc2_b)) loss += 5e-4 * regularizers train_op = cifar10.train(loss, global_step) class _LoggerHook(tf.train.SessionRunHook): def begin(self): self._step = -1 self._start_time = time.time() def before_run(self, run_context): self._step += 1 return tf.train.SessionRunArgs(loss) def after_run(self, run_context, run_values): if self._step % FLAGS.log_frequency == 0: current_time = time.time() duration = current_time - self._start_time self._start_time = current_time loss_value = run_values.results examples_per_sec = FLAGS.log_frequency * FLAGS.batch_size / duration sec_per_batch = float(duration / FLAGS.log_frequency) format_str = ( '%s: step %d, loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch)') print(format_str % (datetime.now(), self._step, loss_value, examples_per_sec, sec_per_batch)) with tf.train.MonitoredTrainingSession( checkpoint_dir=FLAGS.train_dir, hooks=[ tf.train.StopAtStepHook(last_step=FLAGS.max_steps), tf.train.NanTensorHook(loss), _LoggerHook() ], config=tf.ConfigProto( log_device_placement=FLAGS.log_device_placement, allow_soft_placement=True)) as mon_sess: while not mon_sess.should_stop(): mon_sess.run(train_op)
def main(args): debug = (args.debug == 'True') print(args) np.random.seed(args.seed) with tf.Graph().as_default(): train_dataset, num_train_file = DateSet(args.file_list, args, debug) test_dataset, num_test_file = DateSet(args.test_list, args, debug) list_ops = {} batch_train_dataset = train_dataset.batch(args.batch_size).repeat() train_iterator = batch_train_dataset.make_one_shot_iterator() train_next_element = train_iterator.get_next() batch_test_dataset = test_dataset.batch(args.batch_size).repeat() test_iterator = batch_test_dataset.make_one_shot_iterator() test_next_element = test_iterator.get_next() list_ops['num_train_file'] = num_train_file list_ops['num_test_file'] = num_test_file model_dir = args.model_dir print('Total number of examples: {}'.format(num_train_file)) print('Test number of examples: {}'.format(num_test_file)) print('Model dir: {}'.format(model_dir)) tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) list_ops['global_step'] = global_step list_ops['train_dataset'] = train_dataset list_ops['test_dataset'] = test_dataset list_ops['train_next_element'] = train_next_element list_ops['test_next_element'] = test_next_element epoch_size = num_train_file // args.batch_size print('Number of batches per epoch: {}'.format(epoch_size)) image_batch = tf.placeholder(tf.float32, shape=(None, args.image_size, args.image_size, 3), name='image_batch') landmark_batch = tf.placeholder(tf.float32, shape=(None, 196), name='landmark_batch') list_ops['image_batch'] = image_batch list_ops['landmark_batch'] = landmark_batch phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') list_ops['phase_train_placeholder'] = phase_train_placeholder print('Building training graph.') landmarks_pre, landmarks_loss = create_model(image_batch, landmark_batch, phase_train_placeholder, args) get_param_num() L2_loss = tf.add_n(tf.losses.get_regularization_losses()) loss_sum = tf.reduce_sum(tf.square(landmark_batch - landmarks_pre), axis=1) loss_sum = tf.reduce_mean(loss_sum) loss_sum += L2_loss train_op, lr_op = train_model(loss_sum, global_step, num_train_file, args) list_ops['landmarks'] = landmarks_pre list_ops['L2_loss'] = L2_loss list_ops['loss'] = loss_sum list_ops['train_op'] = train_op list_ops['lr_op'] = lr_op test_mean_error = tf.Variable(tf.constant(0.0), dtype=tf.float32, name='ME') test_failure_rate = tf.Variable(tf.constant(0.0), dtype=tf.float32, name='FR') test_10_loss = tf.Variable(tf.constant(0.0), dtype=tf.float32, name='TestLoss') train_loss = tf.Variable(tf.constant(0.0), dtype=tf.float32, name='TrainLoss') train_loss_l2 = tf.Variable(tf.constant(0.0), dtype=tf.float32, name='TrainLoss2') tf.summary.scalar('test_mean_error', test_mean_error) tf.summary.scalar('test_failure_rate', test_failure_rate) tf.summary.scalar('test_10_loss', test_10_loss) tf.summary.scalar('train_loss', train_loss) tf.summary.scalar('train_loss_l2', train_loss_l2) save_params = tf.trainable_variables() saver = tf.train.Saver(save_params, max_to_keep=None) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=False, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) with sess.as_default(): epoch_start = 0 if args.pretrained_model: pretrained_model = args.pretrained_model if (not os.path.isdir(pretrained_model)): print('Restoring pretrained model: {}'.format( pretrained_model)) saver.restore(sess, args.pretrained_model) else: print('Model directory: {}'.format(pretrained_model)) ckpt = tf.train.get_checkpoint_state(pretrained_model) model_path = ckpt.model_checkpoint_path assert (ckpt and model_path) epoch_start = int( model_path[model_path.find('model.ckpt-') + 11:]) + 1 print('Checkpoint file: {}'.format(model_path)) saver.restore(sess, model_path) # if args.save_image_example: # save_image_example(sess, list_ops, args) print('Running train.') merged = tf.summary.merge_all() train_write = tf.summary.FileWriter(log_dir, sess.graph) for epoch in range(epoch_start, args.max_epoch): start = time.time() train_L, train_L2 = train(sess, epoch_size, epoch, list_ops) print("train time: {}".format(time.time() - start)) checkpoint_path = os.path.join(model_dir, 'model.ckpt') metagraph_path = os.path.join(model_dir, 'model.meta') saver.save(sess, checkpoint_path, global_step=epoch, write_meta_graph=False) if not os.path.exists(metagraph_path): saver.export_meta_graph(metagraph_path) start = time.time() test_ME, test_FR, test_loss = test(sess, list_ops, args) print("test time: {}".format(time.time() - start)) summary, _, _, _, _, _ = sess.run([ merged, test_mean_error.assign(test_ME), test_failure_rate.assign(test_FR), test_10_loss.assign(test_loss), train_loss.assign(train_L), train_loss_l2.assign(train_L2) ]) train_write.add_summary(summary, epoch)
import model1 import model2 from datetime import datetime # testing dt = datetime.strptime("20210523", "%Y%m%d").date() # test model2 column_list = ['date', 'close', 'real', 'gold', 'comp', 'spx', 'indu', 'oil', 'btc_diff', 'gold_diff', 'comp_diff', 'spx_diff', 'indu_diff', 'oil_diff', 'btc_diffpct', 'gold_diffpct', 'comp_diffpct', 'spx_diffpct', 'indu_diffpct', 'oil_diffpct', 'timestamp'] input_list = column_list[3:8] # ['gold', 'comp', 'sp500', 'indu', 'oil', 'timestamp'] input_list.append('timestamp') print(input_list) in_dict = { input_list[0] : [40], input_list[1] : [14000], input_list[2] : [43000], input_list[3] : [35000], input_list[4] : [20], input_list[5] : [1621555200000000000] } model2.create_model(input_list) print(f"Model2 Predict Price: {model2.predict(in_dict)}")
def main(args): debug = (args.debug == 'True') print(args) np.random.seed(args.seed) with tf.Graph().as_default(): train_dataset, num_train_file = DateSet(args.file_list, args, debug) test_dataset, num_test_file = DateSet(args.test_list, args, debug) list_ops = {} batch_train_dataset = train_dataset.batch(args.batch_size).repeat() train_iterator = batch_train_dataset.make_one_shot_iterator() train_next_element = train_iterator.get_next() batch_test_dataset = test_dataset.batch(args.batch_size).repeat() test_iterator = batch_test_dataset.make_one_shot_iterator() test_next_element = test_iterator.get_next() list_ops['num_train_file'] = num_train_file list_ops['num_test_file'] = num_test_file model_dir = args.model_dir print(model_dir) if 'test' in model_dir and debug and os.path.exists(model_dir): import shutil shutil.rmtree(model_dir) assert not os.path.exists(model_dir) os.mkdir(model_dir) print('Total number of examples: {}'.format(num_train_file)) print('Test number of examples: {}'.format(num_test_file)) print('Model dir: {}'.format(model_dir)) tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) list_ops['global_step'] = global_step list_ops['train_dataset'] = train_dataset list_ops['test_dataset'] = test_dataset list_ops['train_next_element'] = train_next_element list_ops['test_next_element'] = test_next_element epoch_size = num_train_file // args.batch_size print('Number of batches per epoch: {}'.format(epoch_size)) image_batch = tf.placeholder(tf.float32, shape=(None, args.image_size, args.image_size, 3), name='image_batch') landmark_batch = tf.placeholder(tf.float32, shape=(None, 136), name='landmark_batch') attribute_batch = tf.placeholder(tf.int32, shape=(None, 6), name='attribute_batch') euler_angles_gt_batch = tf.placeholder(tf.float32, shape=(None, 3), name='euler_angles_gt_batch') list_ops['image_batch'] = image_batch list_ops['landmark_batch'] = landmark_batch list_ops['attribute_batch'] = attribute_batch list_ops['euler_angles_gt_batch'] = euler_angles_gt_batch phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') list_ops['phase_train_placeholder'] = phase_train_placeholder print('Building training graph.') landmarks_pre, euler_angles_pre = create_model( image_batch, landmark_batch, phase_train_placeholder, args) _sum_k = tf.reduce_sum(tf.map_fn( lambda x: 1 - tf.cos(abs(x)), euler_angles_gt_batch - euler_angles_pre), axis=1) # attributes_w_n = tf.to_float(attribute_batch[:, 1:6]) # mat_ratio = tf.reduce_mean(attributes_w_n, axis=0) # # bbb = tf.map_fn(lambda x: 1.0 / x if not x == 0.0 else float(args.batch_size), bbb) # mat_ratio = tf.where(tf.equal(mat_ratio, 0.0), (mat_ratio + 1) / float(args.batch_size), 1.0 / mat_ratio) # attributes_w_n = tf.reduce_sum(attributes_w_n * mat_ratio, axis=1) regularization_loss = tf.add_n(tf.losses.get_regularization_losses()) # contour_loss = WingLoss(landmark_batch[:, 0:34], landmarks_pre[:, 0:34], 4.0, 0.50) # inner_brow_loss = 3*WingLoss(landmark_batch[:, 34:54], landmarks_pre[:, 34:54], 4.0, 0.50) # inner_nose_loss = 3*WingLoss(landmark_batch[:, 54:72], landmarks_pre[:, 54:72], 4.0, 0.50) # inner_eye_loss = 9*WingLoss(landmark_batch[:, 72:96], landmarks_pre[:, 72:96], 4.0, 0.50) # inner_mouth_loss = 15*WingLoss(landmark_batch[:, 96:136], landmarks_pre[:, 96:136], 4.0, 0.50) # loss_sum = tf.add_n([contour_loss, inner_brow_loss, inner_nose_loss, inner_eye_loss, inner_mouth_loss]) # contour_loss = tf.reduce_mean(contour_loss * _sum_k) # inner_brow_loss = tf.reduce_mean(inner_brow_loss * _sum_k) # inner_nose_loss = tf.reduce_mean(inner_nose_loss * _sum_k) # inner_eye_loss = tf.reduce_mean(inner_eye_loss * _sum_k) # inner_mouth_loss = tf.reduce_mean(inner_mouth_loss * _sum_k) # loss_sum = L2Loss(landmark_batch, landmarks_pre) loss_sum = WingLoss(landmark_batch, landmarks_pre, 4.0, 0.50) # loss_sum = tf.reduce_mean(loss_sum*_sum_k*attributes_w_n) loss_sum = tf.reduce_mean(loss_sum * _sum_k) loss_sum += regularization_loss # tf.summary.scalar("contour_loss", contour_loss) # tf.summary.scalar("inner_brow_loss", inner_brow_loss) # tf.summary.scalar("inner_nose_loss", inner_nose_loss) # tf.summary.scalar("inner_eye_loss", inner_eye_loss) # tf.summary.scalar("inner_mouth_loss", inner_mouth_loss) tf.summary.scalar("loss", loss_sum) save_params = tf.trainable_variables() # variables_to_train = [v for v in save_params if v.name.split('/', 2)[1] == 'fc' # or v.name.split('/', 1)[0] == 'pfld_conv1' # or v.name.split('/', 1)[0] == 'pfld_conv2' # or v.name.split('/', 1)[0] == 'pfld_conv3' # or v.name.split('/', 1)[0] == 'pfld_conv4' # or v.name.split('/', 1)[0] == 'pool1' # or v.name.split('/', 1)[0] == 'Flatten' # or v.name.split('/', 1)[0] == 'pfld_fc1' # or v.name.split('/', 1)[0] == 'pfld_fc2'] train_op, lr_op = train_model(loss_sum, global_step, num_train_file, args, save_params) list_ops['landmarks'] = landmarks_pre list_ops['train_op'] = train_op list_ops['lr_op'] = lr_op list_ops['regularization_loss'] = regularization_loss list_ops['loss'] = loss_sum # list_ops['contour_loss'] = contour_loss # list_ops['inner_brow_loss'] = inner_brow_loss # list_ops['inner_nose_loss'] = inner_nose_loss # list_ops['inner_eye_loss'] = inner_eye_loss # list_ops['inner_mouth_loss'] = inner_mouth_loss # from tensorflow.contrib.framework.python.framework import checkpoint_utils # var_list = checkpoint_utils.list_variables("./pretrained_models/model.ckpt-51") # for v in var_list: # print(v) # 只加载部分权重,除了最后的输出fc层,其它层的权重都加载 # variables_to_restore = [v for v in save_params if v.name.split('/', 2)[1] != 'fc'] # restorer = tf.train.Saver(variables_to_restore, max_to_keep=None) restorer = tf.train.Saver(save_params, max_to_keep=None) saver = tf.train.Saver(save_params, max_to_keep=None) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.80) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=False, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) with sess.as_default(): if args.pretrained_model: pretrained_model = args.pretrained_model if (not os.path.isdir(pretrained_model)): print('Restoring pretrained model: {}'.format( pretrained_model)) restorer.restore(sess, args.pretrained_model) else: print('Model directory: {}'.format(pretrained_model)) ckpt = tf.train.get_checkpoint_state(pretrained_model) model_path = ckpt.model_checkpoint_path assert (ckpt and model_path) print('Checkpoint file: {}'.format(model_path)) restorer.restore(sess, model_path) if args.save_image_example: save_image_example(sess, list_ops, args) merged = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(args.loss_log, sess.graph) sess.graph.finalize() # 查看循环内是否增加新的图节点 print('Running train.') for epoch in range(args.max_epoch): train(sess, epoch_size, epoch, args.max_epoch, list_ops, merged, summary_writer) checkpoint_path = os.path.join(model_dir, 'model.ckpt') metagraph_path = os.path.join(model_dir, 'model.meta') saver.save(sess, checkpoint_path, global_step=epoch, write_meta_graph=False) if not os.path.exists(metagraph_path): saver.export_meta_graph(metagraph_path) test(sess, list_ops, args)
def main(args): debug = (args.debug == 'True') print(args) np.random.seed(args.seed) with tf.Graph().as_default(): train_dataset, num_train_file = DateSet(args.file_list, args, debug) test_dataset, num_test_file = DateSet(args.test_list, args, debug) list_ops = {} batch_train_dataset = train_dataset.batch(args.batch_size).repeat() train_iterator = batch_train_dataset.make_one_shot_iterator() train_next_element = train_iterator.get_next() batch_test_dataset = test_dataset.batch(args.batch_size).repeat() test_iterator = batch_test_dataset.make_one_shot_iterator() test_next_element = test_iterator.get_next() list_ops['num_train_file'] = num_train_file list_ops['num_test_file'] = num_test_file model_dir = args.model_dir if 'test' in model_dir and debug and os.path.exists(model_dir): import shutil shutil.rmtree(model_dir) assert not os.path.exists(model_dir) os.mkdir(model_dir) print('Total number of examples: {}'.format(num_train_file)) print('Test number of examples: {}'.format(num_test_file)) print('Model dir: {}'.format(model_dir)) tf.set_random_seed(args.seed) global_step = tf.Variable(0, trainable=False) list_ops['global_step'] = global_step list_ops['train_dataset'] = train_dataset list_ops['test_dataset'] = test_dataset list_ops['train_next_element'] = train_next_element list_ops['test_next_element'] = test_next_element epoch_size = num_train_file // args.batch_size print('Number of batches per epoch: {}'.format(epoch_size)) image_batch = tf.placeholder(tf.float32, shape=(None, args.image_size, args.image_size, 3),\ name='image_batch') landmark_batch = tf.placeholder(tf.float32, shape=(None, 196), name='landmark_batch') attribute_batch = tf.placeholder(tf.int32, shape=(None, 6), name='attribute_batch') euler_angles_gt_batch = tf.placeholder(tf.float32, shape=(None, 3), name='euler_angles_gt_batch') w_n = tf.placeholder(tf.float32, shape=(None), name='w_n') list_ops['image_batch'] = image_batch list_ops['landmark_batch'] = landmark_batch list_ops['attribute_batch'] = attribute_batch list_ops['euler_angles_gt_batch'] = euler_angles_gt_batch list_ops['w_n'] = w_n phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') list_ops['phase_train_placeholder'] = phase_train_placeholder print('Building training graph.') # total_loss, landmarks, heatmaps_loss, heatmaps= create_model(image_batch, landmark_batch,\ # phase_train_placeholder, args) landmarks_pre, landmarks_loss,euler_angles_pre = create_model(image_batch, landmark_batch,\ phase_train_placeholder, args) L2_loss = tf.add_n(tf.losses.get_regularization_losses()) _sum_k = tf.reduce_sum(tf.map_fn(lambda x: 1 - tf.cos(abs(x)), \ euler_angles_gt_batch - euler_angles_pre), axis=1) loss_sum = tf.reduce_sum(tf.square(landmark_batch - landmarks_pre), axis=1) loss_sum = tf.reduce_mean(loss_sum * _sum_k * w_n) loss_sum += L2_loss train_op, lr_op = train_model(loss_sum, global_step, num_train_file, args) list_ops['landmarks'] = landmarks_pre list_ops['L2_loss'] = L2_loss list_ops['loss'] = loss_sum list_ops['train_op'] = train_op list_ops['lr_op'] = lr_op save_params = tf.trainable_variables() saver = tf.train.Saver(save_params, max_to_keep=None) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=1.0) sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=False, log_device_placement=False)) sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) with sess.as_default(): if args.pretrained_model: pretrained_model = args.pretrained_model if (not os.path.isdir(pretrained_model)): print('Restoring pretrained model: {}'.format( pretrained_model)) saver.restore(sess, args.pretrained_model) else: print('Model directory: {}'.format(pretrained_model)) ckpt = tf.train.get_checkpoint_state(pretrained_model) model_path = ckpt.model_checkpoint_path assert (ckpt and model_path) print('Checkpoint file: {}'.format(model_path)) saver.restore(sess, model_path) if args.save_image_example: save_image_example(sess, list_ops, args) print('Running train.') for epoch in range(args.max_epoch): train(sess, epoch_size, epoch, list_ops) checkpoint_path = os.path.join(model_dir, 'model.ckpt') metagraph_path = os.path.join(model_dir, 'model.meta') saver.save(sess, checkpoint_path, global_step=epoch, write_meta_graph=False) if not os.path.exists(metagraph_path): saver.export_meta_graph(metagraph_path) test(sess, list_ops, args)