def predict(): data = tf.placeholder(tf.float32, [None, 331, 331, 3]) label = tf.placeholder(tf.float32, [None, None]) dropout = tf.placeholder(tf.float32) phase = tf.placeholder(tf.bool) net = MyInceptionV4(data, label, dropout, phase) # batch data transformer = transforms.Sequential([ transforms.Resize([331, 331]), transforms.Preprocess(), # transforms.RandomHorizontalFlip(), ]) mt_loader = MTCSVLoader( root='E:/fashion-dataset/rank', csv_path='E:\\fashion-dataset\\rank\\Tests\\question.csv', batch_size=64, transformer_fn=transformer, shuffle=False, num_epochs=1, allow_smaller_final_batch=True) sess = session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() saver.restore( sess, '{}/model/MyInceptionV4/MultiTask/fashion-ai.ckpt'.format(hp.pro_path)) queue = multiprocessing.Queue(maxsize=30) writer_process = multiprocessing.Process( target=csv_writer, args=['{}/result/sub.csv'.format(hp.pro_path), queue, 'stop']) writer_process.start() for attr_key, n_class in di.num_classes_v2.items(): flat_logit = net.layers['cls_prob_{}'.format(attr_key)] y_pred = tf.argmax(flat_logit, axis=1) print('writing predictions...') try: while not mt_loader.coord.should_stop(): img_batch, label_batch, name_batch = mt_loader.batch( attr_key=attr_key) names = list(map(lambda v: bytes.decode(v), name_batch)) probs, preds = sess.run([flat_logit, y_pred], feed_dict={ net.data: img_batch, net.is_training: False, net.keep_prob: 1 }) queue.put(('continue', names, attr_key, probs)) print(probs.shape) except tf.errors.OutOfRangeError: print('Predict {} Done.'.format(attr_key)) queue.put(('stop', None, None, None)) writer_process.join() sess.close()
def __init__(self): self.config = config self.session = session() self.purchase_num = 1 self.sku_id = self.config.get_config('config', 'sku_id') self.order_data = dict() self.init_info = dict() self.timers = Timer() log.info('正在同步系统时间')
def _bulid(self, dataset, sess=None): self._dataset = dataset if self._is_eager: self._eager_iterator = tfe.Iterator(dataset) else: self._iterator = dataset.make_initializable_iterator( shared_name='CelebA') self.img_iter_init = self._iterator.make_initializer( self._dataset) # add this..works well self._batch_op = self._iterator.get_next() if sess: self._sess = sess else: self._sess = session() try: self.reset() except: pass
with tf.control_dependencies([d_step_]): d_step = tf.group(*(tf.assign(var, tf.clip_by_value(var, -clip, clip)) for var in d_var)) g_step = tf.train.RMSPropOptimizer(learning_rate=lr).minimize( g_loss, var_list=g_var) # summaries d_summary = utils.summary({wd: 'wd'}) g_summary = utils.summary({g_loss: 'g_loss'}) # sample f_sample = generator(z, training=False) """ train """ ''' init ''' # session sess = utils.session() # iteration counter it_cnt, update_cnt = utils.counter() # saver saver = tf.train.Saver(max_to_keep=5) # summary writer summary_writer = tf.summary.FileWriter('./summaries/celeba_wgan', sess.graph) ''' initialization ''' ckpt_dir = './checkpoints/celeba_wgan' utils.mkdir(ckpt_dir + '/') if not utils.load_checkpoint(ckpt_dir, sess): sess.run(tf.global_variables_initializer()) ''' train ''' try: z_ipt_sample = np.random.normal(size=[100, z_dim])
def train(): alpha_span = 800000 batch_size = 32 ckpt_dir = './checkpoints/wgp' n_gen = 1 n_critic = 1 it_start = 0 #epoch = 20*(alpha_span * 2 // (2*4936)) # 4936 is number of images def preprocess_fn(img): img = tf.image.resize_images(img, [target_size, target_size], method=tf.image.ResizeMethod.AREA) / 127.5 -1 return img def preprocess_fn_dummy(img): img = tf.image.resize_images(img, [final_size, final_size], method=tf.image.ResizeMethod.AREA) / 127.5 -1 return img # dataset img_paths = glob.glob('./imgs/faces/*.png') data_pool = utils.DiskImageData(5, img_paths, batch_size//2, shape=[640, 640, 3], preprocess_fn=preprocess_fn) data_pool_dummy = utils.DiskImageData(7, img_paths, 1, shape=[640, 640, 3], preprocess_fn=preprocess_fn_dummy) batch_epoch = len(data_pool) // (batch_size * 1)#n_critic # build graph print('Building a graph ...') nodes = build(batch_size) # session sess = utils.session() saver = tf.train.Saver() # summary summary_writer = tf.summary.FileWriter('./summaries/wgp/', sess.graph) utils.mkdir(ckpt_dir + '/') print('Initializing all variables ...') sess.run(tf.global_variables_initializer()) # run final size session for storing all variables to be used into the optimizer print('Running final size dummy session ...') #if target_size == initial_size and len(sys.argv) <= 3: # _ = sess.run([nodes['dummy']['d']], feed_dict=get_ipt(2, final_size, 1.0, data_pool_dummy ,z_dim, nodes['dummy']['input'] )) # _ = sess.run([nodes['dummy']['g']], feed_dict=get_ipt(2, final_size, 1.0, data_pool_dummy ,z_dim, nodes['dummy']['input'] )) # load checkpoint if len(sys.argv)>3 and sys.argv[2]=='resume': print ('Loading the checkpoint ...') saver.restore(sess, ckpt_dir+'/model.ckpt') it_start = 1 + int(sys.argv[3]) last_saved_iter = it_start - 1 ''' train ''' for it in range(it_start, 9999999999): # fade alpha alpha_ipt = it / (alpha_span / batch_size) if alpha_ipt > 1 or target_size == initial_size: alpha_ipt = 1.0 print('Alpha : %f' % alpha_ipt) alpha_ipt = 1.0 # train D for i in range(n_critic): d_summary_opt, _ = sess.run([nodes['summaries']['d'], nodes['product']['d']],\ feed_dict=get_ipt(batch_size, target_size, alpha_ipt, data_pool, z_dim, nodes['product']['input'])) summary_writer.add_summary(d_summary_opt, it) # train G for i in range(n_gen): g_summary_opt, _ = sess.run([nodes['summaries']['g'], nodes['product']['g']],\ feed_dict=get_ipt(batch_size, target_size, alpha_ipt, data_pool, z_dim, nodes['product']['input'])) summary_writer.add_summary(g_summary_opt, it) # display epoch = it // batch_epoch it_epoch = it % batch_epoch + 1 if it % 1 == 0: print("iter : %8d, epoch : (%3d) (%5d/%5d) _ resume point : %d" % (it, epoch, it_epoch, batch_epoch,last_saved_iter)) # sample if (it + 1) % batch_epoch == 0: f_sample_opt = sess.run(nodes['sample'], feed_dict=get_ipt_for_sample(batch_size, z_dim, nodes['product']['input'])) f_sample_opt = np.clip(f_sample_opt, -1, 1) save_dir = './sample_images_while_training/wgp/' utils.mkdir(save_dir + '/') osz = int(math.sqrt(batch_size))+1 utils.imwrite(utils.immerge(f_sample_opt, osz, osz), '%s/iter_(%d).png' % (save_dir, it)) # save if (it + 1) % batch_epoch == 0: last_saved_iter = it save_path = saver.save(sess, '%s/model.ckpt' % (ckpt_dir)) print('Model saved in file: %s' % save_path)
self._eval( iteration, self.train_config["validsize"], v_list, ) if __name__ == "__main__": parser = argparse.ArgumentParser(description="SCFT") parser.add_argument('--session', type=str, default='scft', help="session name") parser.add_argument('--data_path', type=Path, help="path containing color images") parser.add_argument('--sketch_path', type=Path, help="path containing sketch images") args = parser.parse_args() outdir, modeldir = session(args.session) with open("param.yaml", "r") as f: config = yaml.safe_load(f) pprint.pprint(config) trainer = Trainer(config, outdir, modeldir, args.data_path, args.sketch_path) trainer()
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 train_net(attr_key): with tf.Graph().as_default(): # placeholder data = tf.placeholder(tf.float32, [None, 331, 331, 3]) label = tf.placeholder(tf.float32, [None, None]) is_training = tf.placeholder(tf.bool) keep_prob = tf.placeholder(tf.float32) # network net = MyInceptionV4(data=data, label=label, keep_prob=keep_prob, is_training=is_training) # batch data transformer = transforms.Sequential( [ transforms.Resize([331, 331]), transforms.Preprocess(), transforms.RandomHorizontalFlip(), ] ) loader = STCSVLoader(root='E:/fashion-dataset/base', attr_key=attr_key, csv_path='{}/dataset/labels/s1_label.csv'.format(hp.pro_path), batch_size=hp.batch_size, transformer_fn=transformer, shuffle=hp.shuffle, min_after_dequeue=hp.min_after_dequeue, num_threads=hp.num_threads, allow_smaller_final_batch=hp.allow_smaller_final_batch, seed=hp.seed, num_epochs=None) num_batch = loader.n_sample // hp.batch_size hp.display = 1 hp.snapshot_iter = num_batch hp.stepsize = num_batch * 5 global_step = tf.Variable(0, name='global_step', trainable=False) lr = tf.train.exponential_decay(hp.learning_rate, global_step, hp.stepsize, hp.lr_decay, staircase=True) opt1 = tf.train.MomentumOptimizer(lr, hp.momentum) opt2 = tf.train.MomentumOptimizer(hp.times * lr, hp.momentum) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) update_op = tf.group(*update_ops) var1 = tf.trainable_variables()[0:-16] var2 = tf.trainable_variables()[-16:] cls_score = 'cls_score_{}'.format(attr_key) flat_logit = net.layers[cls_score] flat_label = net.layers['label'] # acc y_pred = tf.argmax(flat_logit, axis=1) y_true = tf.argmax(flat_label, axis=1) accuracy = tf.reduce_mean(tf.cast(tf.equal(y_pred, y_true), tf.float32)) # loss loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=flat_logit, labels=flat_label ) ) with tf.control_dependencies([update_op]): cost = tf.identity(loss) # optimizer train_op1 = opt1.minimize(cost, global_step=global_step, var_list=var1) train_op2 = opt2.minimize(cost, var_list=var2) train_op = tf.group(train_op1, train_op2) # session sess = session() saver = tf.train.Saver(max_to_keep=50) sess.run(tf.global_variables_initializer()) net.load(sess, '{}/model/Pretrain/{}'.format(hp.pro_path, 'inception_v4.ckpt')) step = -1 last_snapshot_iter = -1 max_step = hp.num_epoch * num_batch print('num_batch', num_batch) now_ime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') print('%s Start Training...iter: %d(%d) / %d(%d) lr: %s' % ( now_ime, (step + 1), 0, max_step, hp.num_epoch, sess.run(lr))) for epoch in range(hp.num_epoch): for step in range((epoch * num_batch), ((epoch + 1) * num_batch)): data_batch, label_batch, name_batch = loader.batch() _ = sess.run( train_op, feed_dict={ net.data: data_batch, net.label: label_batch, net.is_training: True, net.keep_prob: hp.keep_prob } ) if (step + 1) % hp.display == 0: loss_value, acc, y1, y2 = sess.run( [loss, accuracy, y_true, y_pred], feed_dict={ net.data: data_batch, net.label: label_batch, net.is_training: False, net.keep_prob: 1.0 } ) print(y1) print(y2) now_ime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') print('%s iter: %d(%d) / %d(%d), total loss: %.4f, acc: %.2f, lr: %s' % (now_ime, (step + 1), (epoch + 1), max_step, hp.num_epoch, loss_value, acc, sess.run(lr))) if (step + 1) % hp.snapshot_iter == 0: last_snapshot_iter = step net.save(sess, saver, step) if last_snapshot_iter != step: net.save(sess, saver, step) sess.close()
def __init__(self, root, csv_path, batch_size, height=331, width=331, transformer_fn=None, num_epochs=None, shuffle=True, min_after_dequeue=25, allow_smaller_final_batch=False, num_threads=2, seed=None): root = root.replace('\\', '/') root = root if root[-1] == '/' else '{}/'.format(root) self.root = root self.csv_path = csv_path.replace('\\', '/') self.batch_size = batch_size self.height = height self.width = width self.transformer_fn = transformer_fn self.num_epochs = num_epochs self.shuffle = shuffle self.min_after_dequeue = min_after_dequeue self.allow_smaller_final_batch = allow_smaller_final_batch self.num_threads = num_threads self.seed = seed df = pd.read_csv(self.csv_path, header=None) if shuffle: df = df.sample(frac=1., random_state=seed) try: df[2] = df.apply(lambda line: line[2].index('y') + len(line[2]) if line[3] else line[2].index('y'), axis=1) except Exception as e: print(e) print('{}: create session!'.format(self.__class__.__name__)) self.batch_ops = {} self.n_sample = {} self.graph = tf.Graph() with self.graph.as_default(): with tf.device('/cpu:0'): for attr_key, n_class in di.num_classes_v2.items(): data_path = df[df[1].isin([attr_key])][0].values label = df[df[1].isin([attr_key])][2].values batch_ops, n_sample = csv_batch( root=self.root, data_path=data_path, label=label, n_class=n_class, batch_size=batch_size, height=height, width=width, transformer_fn=transformer_fn, num_epochs=num_epochs, shuffle=shuffle, min_after_dequeue=min_after_dequeue, allow_smaller_final_batch=allow_smaller_final_batch, num_threads=num_threads, seed=seed) self.batch_ops[attr_key] = batch_ops self.n_sample[attr_key] = n_sample if num_epochs is not None: self.init = tf.local_variables_initializer() self.sess = session(graph=self.graph) if num_epochs is not None: self.sess.run(self.init) self.coord = tf.train.Coordinator() self.threads = tf.train.start_queue_runners(sess=self.sess, coord=self.coord)
if iteration % self.train_config["snapshot_interval"] == 1: self._eval(iteration, self.train_config["validsize"], v_list, self.outdir) self._eval(iteration, self.train_config["validsize"], v_fix_list, self.outdir_fix) if __name__ == "__main__": parser = argparse.ArgumentParser(description="BicycleGAN") parser.add_argument('--session', type=str, default='bicyclegan', help="session name") parser.add_argument('--data_path', type=Path, help="path containing color images") parser.add_argument('--sketch_path', type=Path, help="path containing color images") args = parser.parse_args() outdir, outdir_fix, modeldir = session(args.session) with open("param.yaml", "r") as f: config = yaml.safe_load(f) pprint.pprint(config) trainer = Trainer(config, outdir, outdir_fix, modeldir, args.data_path, args.sketch_path) trainer()
def __init__(self, data_root, mask_root, batch_size, height=256, width=256, transformer_fn=None, num_epochs=None, data_suffix='npy', mask_suffix='tif', shuffle=True, min_after_dequeue=25, allow_smaller_final_batch=False, num_threads=2, seed=None): self.data_root = data_root self.mask_root = mask_root self.batch_size = batch_size self.height = height self.width = width self.transformer_fn = transformer_fn self.num_epochs = num_epochs self.data_suffix = data_suffix self.mask_suffix = mask_suffix self.shuffle = shuffle self.min_after_dequeue = min_after_dequeue self.allow_smaller_final_batch = allow_smaller_final_batch self.num_threads = num_threads self.seed = seed data_root = data_root.replace('\\', '/') data_root = data_root if data_root[-1] == '/' else '{0}/'.format(data_root) mask_root = mask_root.replace('\\', '/') mask_root = mask_root if mask_root[-1] == '/' else '{0}/'.format(mask_root) data_paths = glob.glob('{0}*.{1}'.format(data_root, data_suffix)) data_paths = list(map(lambda x: x.replace('\\', '/'), data_paths)) data_names = list(map(lambda x: x.split('/')[-1].split('.')[0], data_paths)) mask_paths = list(map(lambda x: '{}{}.{}'.format(mask_root, x, mask_suffix), data_names)) if shuffle: random.seed(seed) randnum = random.randint(0, 2018) random.seed(randnum) random.shuffle(data_paths) random.seed(randnum) random.shuffle(data_names) random.seed(randnum) random.shuffle(mask_paths) # print(data_paths) # print(data_names) # print(mask_paths) print('{}: create session!'.format(self.__class__.__name__)) self.graph = tf.Graph() with self.graph.as_default(): with tf.device('/cpu:0'): self.batch_ops, self.n_sample = self.folder_batch(data_paths=data_paths, mask_paths=mask_paths, data_names=data_names, batch_size=batch_size, height=height, width=width, transformer_fn=transformer_fn, num_epochs=num_epochs, shuffle=shuffle, min_after_dequeue=min_after_dequeue, allow_smaller_final_batch=allow_smaller_final_batch, num_threads=num_threads, seed=seed) if num_epochs is not None: self.init = tf.local_variables_initializer() self.sess = session(graph=self.graph) if num_epochs is not None: self.sess.run(self.init) self.coord = tf.train.Coordinator() self.threads = tf.train.start_queue_runners(sess=self.sess, coord=self.coord)