def test(self, test_samples, test_labels, *, data_iterator): if self.saver is None: self.define_model() if self.writer is None: self.writer = tf.summary.FileWriter('./board', tf.get_default_graph()) print('Before session') with tf.Session(graph=tf.get_default_graph()) as session: self.saver.restore(session, self.save_path) ### 测试 accuracies = [] confusionMatrices = [] for i, samples, labels in data_iterator(test_samples, test_labels, chunkSize=self.test_batch_size): result = session.run( self.test_prediction, feed_dict={self.tf_test_samples: samples} ) # self.writer.add_summary(summary, i) accuracy, cm = self.accuracy(result, labels, need_confusion_matrix=True) accuracies.append(accuracy) confusionMatrices.append(cm) print('Test Accuracy: %.1f%%' % accuracy) print(' Average Accuracy:', np.average(accuracies)) print('Standard Deviation:', np.std(accuracies)) self.print_confusion_matrix(np.add.reduce(confusionMatrices))
def __init__(self, model_dir, files, use_gpu=False): import tensorflow as tf from glob import glob self.files = files cluster_file = model_dir+'clusters.npy' self.n_clusters = getNCluster(cluster_file) self._load_cluster(cluster_file) if not use_gpu: d = tf.device('/cpu:0') data = tf.placeholder(tf.uint8, shape=(None,None,3)) w_data = tf.expand_dims(tf.cast(data,tf.float32),0) - tf.constant([123,117,103],dtype=tf.float32,shape=(1,1,3)) vgg = vgg16(w_data, n_out=self.n_clusters) avg_vgg = tf.reduce_mean(tf.reduce_mean(vgg,1),1) pred = tf.argmax(avg_vgg,dimension=1) self.vgg, self.pred, self.data = vgg, pred, data if not use_gpu: del d saver = tf.train.Saver(tf.all_variables()) tf.get_default_graph().finalize() self.sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.3))) snap = youngest([f for f in glob(os.path.join(model_dir, 'final.ckpt*')) + glob(os.path.join(model_dir, 'snap.ckpt*')) if '.meta' not in f]) saver.restore(self.sess, snap)
def train(self, train_samples, train_labels, *, data_iterator, iteration_steps): self.writer = tf.summary.FileWriter('./board', tf.get_default_graph()) with tf.Session(graph=tf.get_default_graph()) as session: tf.initialize_all_variables().run() ### 训练 print('Start Training') # batch 1000 for i, samples, labels in data_iterator(train_samples, train_labels, iteration_steps=iteration_steps, chunkSize=self.train_batch_size): _, l, predictions, summary = session.run( [self.optimizer, self.loss, self.train_prediction, self.merged_train_summary], feed_dict={self.tf_train_samples: samples, self.tf_train_labels: labels} ) self.writer.add_summary(summary, i) # labels is True Labels accuracy, _ = self.accuracy(predictions, labels) if i % 50 == 0: print('Minibatch loss at step %d: %f' % (i, l)) print('Minibatch accuracy: %.1f%%' % accuracy) ### # 检查要存放的路径值否存在。这里假定只有一层路径。 import os if os.path.isdir(self.save_path.split('/')[0]): save_path = self.saver.save(session, self.save_path) print("Model saved in file: %s" % save_path) else: os.makedirs(self.save_path.split('/')[0]) save_path = self.saver.save(session, self.save_path) print("Model saved in file: %s" % save_path)
def build_reparam_loss_and_gradients(inference, var_list): """Build loss function. Its automatic differentiation is a stochastic gradient of $-\\text{ELBO} = -\mathbb{E}_{q(z; \lambda)} [ \log p(x, z) - \log q(z; \lambda) ]$ based on the reparameterization trick (Kingma and Welling, 2014). Computed by sampling from $q(z;\lambda)$ and evaluating the expectation using Monte Carlo sampling. """ p_log_prob = [0.0] * inference.n_samples q_log_prob = [0.0] * inference.n_samples base_scope = tf.get_default_graph().unique_name("inference") + '/' for s in range(inference.n_samples): # Form dictionary in order to replace conditioning on prior or # observed variable with conditioning on a specific value. scope = base_scope + tf.get_default_graph().unique_name("sample") dict_swap = {} for x, qx in six.iteritems(inference.data): if isinstance(x, RandomVariable): if isinstance(qx, RandomVariable): qx_copy = copy(qx, scope=scope) dict_swap[x] = qx_copy.value() else: dict_swap[x] = qx for z, qz in six.iteritems(inference.latent_vars): # Copy q(z) to obtain new set of posterior samples. qz_copy = copy(qz, scope=scope) dict_swap[z] = qz_copy.value() q_log_prob[s] += tf.reduce_sum( inference.scale.get(z, 1.0) * qz_copy.log_prob(dict_swap[z])) for z in six.iterkeys(inference.latent_vars): z_copy = copy(z, dict_swap, scope=scope) p_log_prob[s] += tf.reduce_sum( inference.scale.get(z, 1.0) * z_copy.log_prob(dict_swap[z])) for x in six.iterkeys(inference.data): if isinstance(x, RandomVariable): x_copy = copy(x, dict_swap, scope=scope) p_log_prob[s] += tf.reduce_sum( inference.scale.get(x, 1.0) * x_copy.log_prob(dict_swap[x])) p_log_prob = tf.reduce_mean(p_log_prob) q_log_prob = tf.reduce_mean(q_log_prob) if inference.logging: tf.summary.scalar("loss/p_log_prob", p_log_prob, collections=[inference._summary_key]) tf.summary.scalar("loss/q_log_prob", q_log_prob, collections=[inference._summary_key]) loss = -(p_log_prob - q_log_prob) grads = tf.gradients(loss, var_list) grads_and_vars = list(zip(grads, var_list)) return loss, grads_and_vars
def restore_and_run(): sess=tf.Session() #First let's load meta graph and restore weights saver = tf.train.import_meta_graph('my_test_model-1000.meta') saver.restore(sess,tf.train.latest_checkpoint('./')) # Access saved Variables directly b1_value = sess.run('bias:0') print(b1_value) # This will print 2, which is the value of bias that we saved # cannot directly get the w4, since it depends on w1 and w2 # w1 and w2 need to be input #w4_value = sess.run('op_to_restore:0') # Now, let's access and create placeholders variables and # create feed-dict to feed new data graph = tf.get_default_graph() w1 = graph.get_tensor_by_name("w1:0") w2 = graph.get_tensor_by_name("w2:0") feed_dict ={w1:13.0,w2:17.0} #Now, access the op that you want to run. w4 = graph.get_tensor_by_name("op_to_restore:0") w4_value = sess.run(w4,feed_dict) print(w4_value) #This will print 60 which is calculated # see all operator tensor name graph.get_operations() [op.outputs for op in tf.get_default_graph().get_operations()]
def predict(self, test_X, isDBN): """Predict the labels for the test set. Parameters ---------- test_X : array_like, shape (n_samples, n_features) Test data. Returns ------- array_like, shape (n_samples,) : predicted labels. """ with self.tf_graph.as_default(): self.tf_saver = tf.train.import_meta_graph(self.model_path+'.meta') with tf.Session() as self.tf_session: self.tf_saver.restore(self.tf_session, self.model_path) self.input_data = tf.get_default_graph().get_tensor_by_name('x-input:0') self.keep_prob = tf.get_default_graph().get_tensor_by_name('keep-probs:0') self.next_train = tf.get_default_graph().get_tensor_by_name('encode-9/dropout/mul:0') self.mod_y = tf.get_default_graph().get_tensor_by_name('linear/output-y:0') feed = { self.input_data: test_X, self.keep_prob: 1 } if isDBN == True: return self.next_train.eval(feed), self.mod_y.eval(feed) return self.mod_y.eval(feed)
def _save_tf_model(self): ckpt_dir = '/opt/ml/output/data/checkpoint' model_dir = '/opt/ml/model' # Re-Initialize from the checkpoint so that you will have the latest models up. tf.train.init_from_checkpoint(ckpt_dir, {'main_level/agent/online/network_0/': 'main_level/agent/online/network_0'}) tf.train.init_from_checkpoint(ckpt_dir, {'main_level/agent/online/network_1/': 'main_level/agent/online/network_1'}) # Create a new session with a new tf graph. sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) sess.run(tf.global_variables_initializer()) # initialize the checkpoint. # This is the node that will accept the input. input_nodes = tf.get_default_graph().get_tensor_by_name('main_level/agent/main/online/' + \ 'network_0/observation/observation:0') # This is the node that will produce the output. output_nodes = tf.get_default_graph().get_operation_by_name('main_level/agent/main/online/' + \ 'network_1/ppo_head_0/policy_mean/BiasAdd') # Save the model as a servable model. tf.saved_model.simple_save(session=sess, export_dir='model', inputs={"observation": input_nodes}, outputs={"policy": output_nodes.outputs[0]}) # Move to the appropriate folder. shutil.move('model/', model_dir + '/model/tf-model/00000001/') # SageMaker will pick it up and upload to the right path. print("Success")
def __init__(self, hyperparams): tf.reset_default_graph() #Model hyperparameters self.learning_rate = hyperparams['learning_rate'] self.encoder_act_func = tf.nn.elu #tf.nn.softplus #tf.tanh self.decoder_act_func = tf.tanh self.encoder_net = hyperparams['encoder_net'] self.decoder_net = hyperparams['decoder_net'] self.z_size = hyperparams['z_size'] #Z self.x_size = hyperparams['x_size'] #X self.rs = 0 self.n_W_particles = hyperparams['n_W_particles'] #S self.n_z_particles = hyperparams['n_z_particles'] #P #Placeholders - Inputs/Targets self.x = tf.placeholder(tf.float32, [None, self.x_size]) self.batch_size = tf.shape(self.x)[0] #B self.batch_frac = tf.placeholder(tf.float32, None) #Define endocer and decoder with tf.variable_scope("encoder"): encoder = NN(self.encoder_net, self.encoder_act_func, self.batch_size) with tf.variable_scope("decoder"): decoder = BNN(self.decoder_net, self.decoder_act_func, self.batch_size) #Objective log_probs = self.log_probs(self.x, encoder, decoder) self.elbo = self.objective(*log_probs) # self.iwae_elbo = self.iwae_objective(*log_probs) self.iwae_elbo_test = self.iwae_objective_test(*log_probs) # Minimize negative ELBO self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, epsilon=1e-02).minimize(-self.elbo) # for var in tf.global_variables(): # print var # FOR INSPECING MODEL # self.decoder_means = decoder.W_means # self.decoder_logvars = decoder.W_logvars self.recons, self.priors = self.get_x_samples(self.x, encoder, decoder) #Finalize Initilization self.init_vars = tf.global_variables_initializer() self.saver = tf.train.Saver() tf.get_default_graph().finalize()
def __init__(self, hyperparams): #Model hyperparameters self.learning_rate = hyperparams['learning_rate'] self.encoder_act_func = tf.nn.elu #tf.nn.softplus #tf.tanh self.decoder_act_func = tf.tanh self.encoder_net = hyperparams['encoder_net'] self.decoder_net = hyperparams['decoder_net'] self.z_size = hyperparams['z_size'] #Z self.x_size = hyperparams['x_size'] #X self.rs = 0 self.n_W_particles = hyperparams['n_W_particles'] #S #Placeholders - Inputs/Targets self.x = tf.placeholder(tf.float32, [None, self.x_size]) self.batch_size = tf.placeholder(tf.int32, None) #B self.n_z_particles = tf.placeholder(tf.int32, None) #P self.batch_frac = tf.placeholder(tf.float32, None) #Objective self.elbo = self.objective(self.x) # Minimize negative ELBO self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, epsilon=1e-02).minimize(-self.elbo) #Finalize Initilization self.init_vars = tf.global_variables_initializer() self.saver = tf.train.Saver() tf.get_default_graph().finalize() self.sess = tf.Session()
def inference(input, batch_size, num_segments, lstm_keep_prob=0.5, conv_keep_prob=1.0, train_conv123=False, train_conv45=False, train_fc67=False): # input size is [num_segments, batch_size, 224, 224, num_length*3/2] fc6_per_step = [] with tf.variable_scope("conv"): for time_step in range(num_segments): if time_step > 0: tf.get_variable_scope().reuse_variables() fc8 = vgg16.inference(input[time_step, :, :, :, :], conv_keep_prob, train_conv123, train_conv45, train_fc67, False) fc7 = tf.get_default_graph().get_tensor_by_name("conv/fc7/fc7:0") fc6 = tf.get_default_graph().get_tensor_by_name("conv/fc6/fc6:0") # output is [batch_size*num_segments, 4096] fc6_per_step.append(fc6) with tf.variable_scope("lstm"): hidden_size = 512 lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_size, forget_bias=1.0, state_is_tuple=True) lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, input_keep_prob=lstm_keep_prob, output_keep_prob=lstm_keep_prob) cell = lstm_cell _initial_state = cell.zero_state(batch_size, tf.float32) outputs = [] state = _initial_state for time_step in range(num_segments): if time_step > 0: tf.get_variable_scope().reuse_variables() (cell_output, state) = cell(fc6_per_step[time_step], state) outputs.append(cell_output) final_state = state lstm_params = [var for var in tf.all_variables() if var.name.startswith("lstm")] for var in lstm_params: tf.add_to_collection("params", var) logits = layers.fc(tf.concat(0, outputs, 'concat'), 101, relu=False, name='cls') return logits
def main(args): images, cout_per_image, nrof_samples = load_and_align_data(args.image_files,args.image_size, args.margin, args.gpu_memory_fraction) with tf.Graph().as_default(): with tf.Session() as sess: # Load the model facenet.load_model(args.model) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") # Run forward pass to calculate embeddings feed_dict = { images_placeholder: images , phase_train_placeholder:False} emb = sess.run(embeddings, feed_dict=feed_dict) classifier_filename_exp = os.path.expanduser(args.classifier_filename) with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) print('Loaded classifier model from file "%s"\n' % classifier_filename_exp) predictions = model.predict_proba(emb) best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices] k=0 #print predictions for i in range(nrof_samples): print("\npeople in image %s :" %(args.image_files[i])) for j in range(cout_per_image[i]): print('%s: %.3f' % (class_names[best_class_indices[k]], best_class_probabilities[k])) k+=1
def main(args): align = align_dlib.AlignDlib(os.path.expanduser(args.dlib_face_predictor)) image_paths = [args.image1, args.image2] landmarkIndices = align_dlib.AlignDlib.OUTER_EYES_AND_NOSE with tf.Graph().as_default(): with tf.Session() as sess: # Load the model print('Loading model "%s"' % args.model_file) facenet.load_model(args.model_file) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") image_size = int(images_placeholder.get_shape()[1]) # Run forward pass to calculate embeddings images = load_and_align_data(image_paths, image_size, align, landmarkIndices) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb = sess.run(embeddings, feed_dict=feed_dict) dist = np.sqrt(np.mean(np.square(np.subtract(emb[0,:], emb[1,:])))) print('Distance between the embeddings: %3.6f' % dist)
def test_input_pipeline(self): Xs, Ys = dsu.tiny_imagenet_load() n_batches = 0 batch_size = 10 with tf.Graph().as_default(), tf.Session() as sess: batch_generator = dsu.create_input_pipeline( Xs[:100], batch_size=batch_size, n_epochs=1, shape=(64, 64, 3), crop_shape=(64, 64, 3)) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) coord = tf.train.Coordinator() tf.get_default_graph().finalize() threads = tf.train.start_queue_runners(sess=sess, coord=coord) try: while not coord.should_stop(): batch = sess.run(batch_generator) assert (batch.shape == (batch_size, 64, 64, 3)) n_batches += 1 except tf.errors.OutOfRangeError: pass finally: coord.request_stop() coord.join(threads) assert (n_batches == 10)
def test_distribution_creation_global_graph(): # Distribution creation doesn't modify the global graph before = tf.get_default_graph().as_graph_def() with tp.Model(): tp.Parameter() after = tf.get_default_graph().as_graph_def() assert before == after
def central_step(): # restore v1, slots op5 = tf.group(*[ tf.assign(w,v) for w,v in zip(restored_vars, tmp_vars)]) with tf.get_default_graph().control_dependencies([op5]): back = tf.group(*[tf.assign_sub(v, -self._lr_t*grad) for grad,v in grads_and_vars]) with tf.get_default_graph().control_dependencies([back]): return tf.gradients(self.gan.trainer.d_loss, d_vars) + tf.gradients(self.gan.trainer.g_loss, g_vars)
def _extractFeatures(self, alignedFrames): start = time.time() if len(alignedFrames) <= 0: return [] with self.session.graph.as_default(): with self.session.as_default(): # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("resnet/input:0") embeddings = tf.get_default_graph().get_tensor_by_name("resnet/embeddings:0") #phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("resnet/phase_train:0") #image_size = images_placeholder.get_shape()[1] #embedding_size = embeddings.get_shape()[1] frames = [f for (i, j, f) in alignedFrames] imgs = np.array(frames, copy=False) feed_dict = { images_placeholder: imgs } #phase_train_placeholder: False } emb = self.session.run(embeddings, feed_dict=feed_dict) #print emb.shape features = [(i, j, e) for (i, j, f), e in zip(alignedFrames, emb)] processTime = time.time() - start print 'feature extraction for', len(alignedFrames), 'took', processTime, 's, ~', processTime/len(alignedFrames) return features
def getOp(self, short_name): if short_name == 'FC': return tf.get_default_graph().get_operation_by_name('FC/MatMul') tokens = short_name.split('/') name = ('resnet_v1/block1/' + tokens[0] + '/bottleneck_v1/' + tokens[1] + '/Conv2D') return tf.get_default_graph().get_operation_by_name(name)
def add_check_numerics_ops(): """Connect a `check_numerics` to every floating point tensor. `check_numerics` operations themselves are added for each `half`, `float`, or `double` tensor in the graph. For all ops in the graph, the `check_numerics` op for all of its (`half`, `float`, or `double`) inputs is guaranteed to run before the `check_numerics` op on any of its outputs. Returns: A `group` op depending on all `check_numerics` ops added. Based on `tf.add_check_numerics_ops`; modified to work around problem with variables in different "frames" (triggered by attempt to merge nodes from inside and outside the while loop of an RNN). """ check_op = [] # This code relies on the ordering of ops in get_operations(). # The producer of a tensor always comes before that tensor's consumer in # this list. This is true because get_operations() returns ops in the order # added, and an op can only be added after its inputs are added. for op in tf.get_default_graph().get_operations(): if op.name and any(re.search(pattern, op.name) for pattern in NO_MONITOR): continue for output in op.outputs: if output.dtype in [tf.float16, tf.float32, tf.float64] and \ output.op._get_control_flow_context() == \ tf.get_default_graph()._get_control_flow_context(): message = op.name + ":" + str(output.value_index) with tf.control_dependencies(check_op): check_op = [tf.check_numerics(output, message=message)] return tf.group(*check_op)
def eval_network(sess, summary_writer, dataset, correct_prediction, epoch, mode, make_summary=False): correct_sum = 0 total_test = 0 if mode == 'test' and make_summary: training_summary = tf.get_default_graph().get_tensor_by_name("training_accuracy:0") loss_summary = tf.get_default_graph().get_tensor_by_name("loss:0") for i in range(dataset.labels.shape[0] / 1000): feed_dict = {x: dataset.images[i * 1000:(i + 1) * 1000], y_: dataset.labels[i * 1000:(i + 1) * 1000], # keep_prob: 1.0 } if mode == 'test' and make_summary: [test_correct, train_summ, loss_summ] = sess.run([correct_prediction, training_summary, loss_summary], feed_dict=feed_dict) summary_writer.add_summary(train_summ, epoch) summary_writer.add_summary(loss_summ, epoch) else: test_correct = correct_prediction.eval(feed_dict=feed_dict) correct_sum += sum(test_correct) total_test += len(test_correct) return float(correct_sum) / total_test
def testFromDifferentScope(self): sub = functools.partial(re.sub, r'^[^/]+/', 'agent/') restore_initializers = { 'w': initializers.restore_initializer(_checkpoint(), 'w', sub), 'b': initializers.restore_initializer(_checkpoint(), 'b', sub) } with tf.variable_scope('some_random_scope'): c = convnet.ConvNet2D( output_channels=(16, 32), kernel_shapes=(8, 4), strides=(4, 2), paddings=[conv.VALID], activation=tf.nn.relu, activate_final=True, initializers=restore_initializers) inputs = tf.constant(1 / 255.0, shape=[1, 86, 86, 3]) outputs = c(inputs) init = tf.global_variables_initializer() tf.get_default_graph().finalize() with self.test_session() as session: session.run(init) o = session.run(outputs) self.assertAllClose( np.linalg.norm(o), _TWO_CONV_LAYERS_RELU, atol=_TOLERANCE)
def testScopeRestore(self): c1 = conv.Conv2D( 16, 8, 4, name='conv_2d_0', padding=conv.VALID, initializers={ 'w': initializers.restore_initializer( _checkpoint(), 'w', scope='agent/conv_net_2d/conv_2d_0'), 'b': initializers.restore_initializer( _checkpoint(), 'b', scope='agent/conv_net_2d/conv_2d_0') }) inputs = tf.constant(1 / 255.0, shape=[1, 86, 86, 3]) outputs = c1(inputs) init = tf.global_variables_initializer() tf.get_default_graph().finalize() with self.test_session() as session: session.run(init) o = session.run(outputs) self.assertAllClose(np.linalg.norm(o), _ONE_CONV_LAYER, atol=_TOLERANCE)
def initialize_session(acoustic_checkpoint, hparams): """Initializes a transcription session.""" with tf.Graph().as_default(): examples = tf.placeholder(tf.string, [None]) hparams.batch_size = 1 batch, iterator = data.provide_batch( batch_size=1, examples=examples, hparams=hparams, is_training=False, truncated_length=0) model.get_model(batch, hparams, is_training=False) session = tf.Session() saver = tf.train.Saver() saver.restore(session, acoustic_checkpoint) onset_probs_flat = tf.get_default_graph().get_tensor_by_name( 'onsets/onset_probs_flat:0') frame_probs_flat = tf.get_default_graph().get_tensor_by_name( 'frame_probs_flat:0') velocity_values_flat = tf.get_default_graph().get_tensor_by_name( 'velocity/velocity_values_flat:0') return TranscriptionSession( session=session, examples=examples, iterator=iterator, onset_probs_flat=onset_probs_flat, frame_probs_flat=frame_probs_flat, velocity_values_flat=velocity_values_flat, hparams=hparams)
def testMoreMultipleRestore(self): restore_initializers = { 'w': initializers.restore_initializer(_checkpoint(), 'w'), 'b': initializers.restore_initializer(_checkpoint(), 'b') } with tf.variable_scope('agent'): c = convnet.ConvNet2D( output_channels=(16, 32), kernel_shapes=(8, 4), strides=(4, 2), paddings=[conv.VALID], activation=tf.nn.relu, activate_final=True, initializers=restore_initializers) inputs = tf.constant(1 / 255.0, shape=[1, 86, 86, 3]) outputs = c(inputs) init = tf.global_variables_initializer() tf.get_default_graph().finalize() with self.test_session() as session: session.run(init) o = session.run(outputs) self.assertAllClose( np.linalg.norm(o), _TWO_CONV_LAYERS_RELU, atol=_TOLERANCE)
def __init__(self, hyperparams): tf.reset_default_graph() #Model hyperparameters self.learning_rate = hyperparams['learning_rate'] self.z_size = hyperparams['z_size'] #Z self.x_size = hyperparams['x_size'] #X self.rs = 0 # self.n_W_particles = hyperparams['n_W_particles'] #S # self.n_W_particles = tf.placeholder(tf.int32, None) #S self.n_z_particles = hyperparams['n_z_particles'] #P # self.n_z_particles = tf.placeholder(tf.int32, None) #P self.n_transitions = hyperparams['leapfrog_steps'] #this is leapfrog steps, whereas T=1 like the paper # self.encoder_act_func = tf.nn.elu #tf.nn.softplus #tf.tanh # self.decoder_act_func = tf.tanh # self.encoder_net = hyperparams['encoder_net'] # self.decoder_net = hyperparams['decoder_net'] #Placeholders - Inputs/Targets self.x = tf.placeholder(tf.float32, [None, self.x_size]) # self.batch_frac = tf.placeholder(tf.float32, None) self.batch_size = tf.shape(self.x)[0] #B #Define networks q_zlx, q_vlxz, r_vlxz, p_xlz # q(z|x) net1 = NN([self.x_size, 300, 300, self.z_size*2], tf.nn.elu) # q(v|x,z) net2 = NN([self.x_size+self.z_size, 300, 300, self.z_size*2], tf.nn.elu) # r(v|x,z) net3 = NN([self.x_size+self.z_size, 300, 300, self.z_size*2], tf.nn.elu) # p(x|z) net4 = NN([self.z_size, 300, 300, self.x_size], tf.tanh) #Objective log_probs_list = self.log_probs(self.x, net1, net2, net3, net4) self.elbo = self.objective(*log_probs_list) self.iwae_elbo = self.iwae_objective(*log_probs_list) # Minimize negative ELBO self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, epsilon=1e-02).minimize(-self.elbo) # for var in tf.global_variables(): # print var #Finalize Initilization self.init_vars = tf.global_variables_initializer() self.saver = tf.train.Saver() tf.get_default_graph().finalize()
def main(): with open(a.input_file, "rb") as f: input_data = f.read() input_instance = dict(input=base64.urlsafe_b64encode(input_data).decode("ascii"), key="0") input_instance = json.loads(json.dumps(input_instance)) with tf.Session() as sess: saver = tf.train.import_meta_graph(a.model_dir + "/export.meta") saver.restore(sess, a.model_dir + "/export") input_vars = json.loads(tf.get_collection("inputs")[0]) output_vars = json.loads(tf.get_collection("outputs")[0]) input = tf.get_default_graph().get_tensor_by_name(input_vars["input"]) output = tf.get_default_graph().get_tensor_by_name(output_vars["output"]) input_value = np.array(input_instance["input"]) output_value = sess.run(output, feed_dict={input: np.expand_dims(input_value, axis=0)})[0] output_instance = dict(output=output_value.decode("ascii"), key="0") b64data = output_instance["output"] b64data += "=" * (-len(b64data) % 4) output_data = base64.urlsafe_b64decode(b64data.encode("ascii")) with open(a.output_file, "wb") as f: f.write(output_data)
def images_to_vectors(self, inpath, outjson_path, modelpath): results = dict() with tf.Graph().as_default(): with tf.Session() as sess: src.facenet.load_model(modelpath) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") image_paths = self.get_image_paths(inpath) for image_path in image_paths: # 获取图片中的人脸数 img = misc.imread(os.path.expanduser(image_path), mode='RGB') images = self.image_array_align_data(img,image_path) #判断是否检测出人脸 检测不出 就跳出此循环 if images.shape[0] == 1 : continue feed_dict = {images_placeholder: images, phase_train_placeholder: False} emb_array = sess.run(embeddings, feed_dict=feed_dict) filename_base, file_extension = os.path.splitext(image_path) for j in range(0, len(emb_array)): results[filename_base + "_" + str(j)] = emb_array[j].tolist() face_mysql_instant = face_mysql.face_mysql() face_mysql_instant.insert_facejson(filename_base + "_" + str(j), ",".join(str(li) for li in emb_array[j].tolist())) # All done, save for later! json.dump(results, open(outjson_path, "w"))
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: # Read the file containing the pairs used for testing pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs)) # Get the paths for the corresponding images paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs, args.lfw_file_ext) # Load the model print('Loading model "%s"' % args.model_file) facenet.load_model(args.model_file) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") tpr, fpr, accuracy, val, val_std, far = lfw.validate(sess, paths, actual_issame, args.seed, 60, images_placeholder, phase_train_placeholder, embeddings, nrof_folds=args.lfw_nrof_folds) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) facenet.plot_roc(fpr, tpr, 'NN4')
def gradient_memory_measure_mb(): """Evaluates gradient, prints peak memory in MBs.""" global sess start_time0 = time.perf_counter() loss = create_loss() if DUMP_GRAPHDEF: open('graphdef.txt', 'w').write(str(tf.get_default_graph().as_graph_def())) # use block_layer1, block_layer2, block_layer3 as checkpoint nodes g = tf.get_default_graph() ops = g.get_operations() for op in ge.filter_ops_from_regex(ops, "block_layer"): tf.add_to_collection("checkpoints", op.outputs[0]) start_time = time.perf_counter() grads = tf.gradients(loss, tf.trainable_variables()) start_time = time.perf_counter() sess = create_session() start_time = time.perf_counter() sessrun(tf.global_variables_initializer()) start_time = time.perf_counter() sessrun(grads) start_time = time.perf_counter() sessrun(grads) mem_use = mem_util.peak_memory(run_metadata)['/gpu:0']/1e6 print("Memory used: %.2f MB "%(mem_use)) total_time = time.perf_counter()-start_time0 print("Total time: %.2f sec"%(total_time)) assert total_time < 100 return mem_use
def restore_and_test(): data_dir = "./data" mnist = input_data.read_data_sets(data_dir, one_hot=True) sess=tf.Session() #First let's load meta graph and restore weights saver = tf.train.import_meta_graph('mnist_softmax-1000.meta') saver.restore(sess,tf.train.latest_checkpoint('./')) [op.outputs for op in tf.get_default_graph().get_operations()] graph = tf.get_default_graph() x = graph.get_tensor_by_name("x:0") y = graph.get_tensor_by_name("y/add:0") y_ = graph.get_tensor_by_name("y_:0") W = graph.get_tensor_by_name("W:0") W_value = sess.run(W) # you can see the values of W # the most import value in neuron network # the main difference with simple example. np.unique(W_value,return_counts=True) # # (array([-0.66475219, -0.66456056, -0.65921789, ..., 0.63828367, # 0.69256693, 0.72933155], dtype=float32), # array([1, 1, 1, ..., 1, 1, 1])) # Test trained model correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
def main(): from argparse import ArgumentParser from glob import glob from time import time import random import tensorflow as tf parser = ArgumentParser() parser.add_argument('--batch_size', type=int, default=32, help='batch size') parser.add_argument('-n', type=int, default=None, help='Number of images to evaluate on') parser.add_argument('--file-list', type=str, default='/fastdata/finder/streetview_test.txt', help='path to the streetview test file') parser.add_argument('--file-base-dir', type=str, default='/fastdata/finder/streetview/', help='directory of the test images') parser.add_argument('train_dir', help='training directory') args = parser.parse_args() cluster_file = args.train_dir+'clusters.npy' files = [os.path.join(args.file_base_dir,l.strip()) for l in open(args.file_list,'r')] random.shuffle(files) if args.n: files = files[:args.n] args.n = len(files) # Setup the graph data,gt = glocData(files, cluster_file, batch_size=args.batch_size) n_clusters = getNCluster(cluster_file) vgg = vgg16(data, n_out=n_clusters) avg_vgg = tf.reduce_mean(tf.reduce_mean(vgg,1),1) pred = tf.argmax(avg_vgg,dimension=1) # Initialize ops saver = tf.train.Saver(tf.all_variables()) tf.get_default_graph().finalize() with tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.3))) as sess: # Initialize stuff tf.train.start_queue_runners(sess=sess) snap = youngest([f for f in glob(os.path.join(args.train_dir, 'final.ckpt*')) + glob(os.path.join(args.train_dir, 'snap.ckpt*')) if '.meta' not in f]) saver.restore(sess, snap) # Eval top1_acc, top5_acc = [], [] id = [] for it in range(0,args.n,args.batch_size): t0 = time() gt_value, pred_value, score = sess.run([gt, pred, avg_vgg]) t1 = time() for g, p, s in zip(gt_value, pred_value, score): top1_acc.append( g==p ) ss = sorted( s ) top5_acc.append( ss[-5] <= s[g] ) id.append( np.where(s[g] == ss[::-1])[0] ) if it % (10*args.batch_size) == 0: print('%8d, top1 = %0.2f top5 = %0.2f (%0.1f im/sec)'%(it, np.mean(top1_acc), np.mean(top5_acc), args.batch_size / (t1-t0))) print('%8d, top1 = %0.2f top5 = %0.2f (%0.1f im/sec)'%(args.n, np.mean(top1_acc), np.mean(top5_acc), args.batch_size / (t1-t0))) print( [np.mean(np.array(id) <= r) for r in range(100)] )
# Symbols x = tf.placeholder("float", shape=[None, x_size]) y = tf.placeholder("float", shape=[None, y_size]) sess = tf.Session() #init = tf.global_variables_initializer() saver = tf.train.import_meta_graph( '/home/vkvalappil/Data/workspace/pythonScripts/MLP/mlp_bias_cor_' + str(h_size) + 'N/mlp_bias_cor_' + str(h_size) + 'N.meta') saver.restore( sess, tf.train.latest_checkpoint( '/home/vkvalappil/Data/workspace/pythonScripts/MLP/mlp_bias_cor_' + str(h_size) + 'N/')) graph = tf.get_default_graph() w1 = graph.get_tensor_by_name("W1:0") w2 = graph.get_tensor_by_name("W2:0") w3 = graph.get_tensor_by_name("W3:0") b1 = graph.get_tensor_by_name("b1:0") b2 = graph.get_tensor_by_name("b2:0") b3 = graph.get_tensor_by_name("b3:0") hidden_out = tf.nn.tanh(tf.add(tf.matmul(x, w1), b1)) hidden_out2 = tf.nn.tanh(tf.add(tf.matmul(hidden_out, w2), b2)) y_ = tf.add(tf.matmul(hidden_out2, w3), b3) #y_ = tf.nn.tanh(tf.add(tf.matmul(hidden_out2, w3), b3))
def train(resume, visualize): np.random.seed(cfg.random_seed) dataset, train_imdb = get_dataset() do_val = len(cfg.train.val_imdb) > 0 class_weights = class_equal_weights(train_imdb) (preloaded_batch, enqueue_op, enqueue_placeholders, q_size) = setup_preloading(Gnet.get_batch_spec(train_imdb['num_classes'])) reg = tf.contrib.layers.l2_regularizer(cfg.train.weight_decay) net = Gnet(num_classes=train_imdb['num_classes'], batch=preloaded_batch, weight_reg=reg, class_weights=class_weights) lr_gen = LearningRate() # reg_ops = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) # reg_op = tf.reduce_mean(reg_ops) # optimized_loss = net.loss + reg_op optimized_loss = tf.contrib.losses.get_total_loss() learning_rate, train_op = get_optimizer(optimized_loss, net.trainable_variables) val_net = val_imdb = None if do_val: val_imdb = imdb.get_imdb(cfg.train.val_imdb, is_training=False) val_net = Gnet(num_classes=val_imdb['num_classes'], reuse=True) with tf.name_scope('summaries'): tf.summary.scalar('loss', optimized_loss) tf.summary.scalar('data_loss', net.loss) tf.summary.scalar('data_loss_normed', net.loss_normed) tf.summary.scalar('data_loss_unnormed', net.loss_unnormed) tf.summary.scalar('lr', learning_rate) tf.summary.scalar('q_size', q_size) if cfg.train.histograms: tf.summary.histogram('roi_feats', net.roifeats) tf.summary.histogram('det_imfeats', net.det_imfeats) tf.summary.histogram('pw_feats', net.pw_feats) for i, blockout in enumerate(net.block_feats): tf.summary.histogram('block{:02d}'.format(i + 1), blockout) merge_summaries_op = tf.summary.merge_all() with tf.name_scope('averaging'): ema = tf.train.ExponentialMovingAverage(decay=0.7) maintain_averages_op = ema.apply( [net.loss_normed, net.loss_unnormed, optimized_loss]) # update moving averages after every loss evaluation with tf.control_dependencies([train_op]): train_op = tf.group(maintain_averages_op) smoothed_loss_normed = ema.average(net.loss_normed) smoothed_loss_unnormed = ema.average(net.loss_unnormed) smoothed_optimized_loss = ema.average(optimized_loss) restorer = ckpt = None if resume: ckpt = tf.train.get_checkpoint_state('./') restorer = tf.train.Saver() elif cfg.gnet.imfeats: variables_to_restore = slim.get_variables_to_restore( include=["resnet_v1"]) variables_to_exclude = \ slim.get_variables_by_suffix('Adam_1', scope='resnet_v1') + \ slim.get_variables_by_suffix('Adam', scope='resnet_v1') + \ slim.get_variables_by_suffix('Momentum', scope='resnet_v1') restorer = tf.train.Saver( list(set(variables_to_restore) - set(variables_to_exclude))) saver = tf.train.Saver(max_to_keep=None) model_manager = ModelManager() config = tf.ConfigProto() with tf.Session(config=config) as sess: train_writer = tf.summary.FileWriter(cfg.log_dir, sess.graph) tf.global_variables_initializer().run() tf.local_variables_initializer().run() coord = start_preloading(sess, enqueue_op, dataset, enqueue_placeholders) start_iter = 1 if resume: restorer.restore(sess, ckpt.model_checkpoint_path) tensor = tf.get_default_graph().get_tensor_by_name("global_step:0") start_iter = sess.run(tensor + 1) elif cfg.gnet.imfeats: restorer.restore(sess, cfg.train.pretrained_model) for it in range(start_iter, cfg.train.num_iter + 1): if coord.should_stop(): break if visualize: # don't do actual training, just visualize data visualize_detections(sess, it, learning_rate, lr_gen, net, train_op) continue (_, val_total_loss, val_loss_normed, val_loss_unnormed, summary) = sess.run([ train_op, smoothed_optimized_loss, smoothed_loss_normed, smoothed_loss_unnormed, merge_summaries_op ], feed_dict={learning_rate: lr_gen.get_lr(it)}) train_writer.add_summary(summary, it) if it % cfg.train.display_iter == 0: print(('{} iter {:6d} lr {:8g} opt loss {:8g} ' 'data loss normalized {:8g} ' 'unnormalized {:8g}').format(datetime.now(), it, lr_gen.get_lr(it), val_total_loss, val_loss_normed, val_loss_unnormed)) if do_val and it % cfg.train.val_iter == 0: print('{} starting validation'.format(datetime.now())) val_map, mc_ap, pc_ap = val_run(sess, val_net, val_imdb) print(('{} iter {:6d} validation pass: mAP {:5.1f} ' 'multiclass AP {:5.1f}').format(datetime.now(), it, val_map, mc_ap)) save_path = saver.save(sess, net.name, global_step=it) print('wrote model to {}'.format(save_path)) # dump_debug_info(sess, net, it) model_manager.add(it, val_map, save_path) model_manager.print_summary() model_manager.write_link_to_best('./gnet_best') elif it % cfg.train.save_iter == 0 or it == cfg.train.num_iter: save_path = saver.save(sess, net.name, global_step=it) print('wrote model to {}'.format(save_path)) # dump_debug_info(sess, net, it) coord.request_stop() coord.join() print('training finished') if do_val: print('summary of validation performance') model_manager.print_summary()
from Chapter02 import hy_param from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) # Pointing the model checkpoint checkpoint_file = tf.train.latest_checkpoint( os.path.join(hy_param.checkpoint_dir, 'checkpoints')) saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file)) # Loading test data test_data = np.array([mnist.test.images[6]]) # Loading input variable from the model input_x = tf.get_default_graph().get_operation_by_name("input_x").outputs[0] # Loading Prediction operation prediction = tf.get_default_graph().get_operation_by_name( "prediction").outputs[0] with tf.Session() as sess: # Restoring the model from the checkpoint saver.restore(sess, checkpoint_file) # Executing the model to make predictions data = sess.run(prediction, feed_dict={input_x: test_data}) print("Predicted digit: ", data.argmax()) # Display the feed image
'Human 2', 'Human 3', 'Human 4', 'Lee Yam Keng', 'Human 6', 'Mohammed Alzaidi', 'Human 8', 'Human 9', 'Human 10' ] #train human names print('Loading feature extraction model') modeldir = 'path/to/saved_model.pb' facenet.load_model(modeldir) images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] classifier_filename = 'save_classifier/my_classifier.pkl' classifier_filename_exp = os.path.expanduser(classifier_filename) with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) print('load classifier file-> %s' % classifier_filename_exp) video_capture = cv2.VideoCapture(1) c = 0 #video writer # fourcc = cv2.CV_FOURCC(*'XVID')
loss = tf.reduce_mean(tf.square(tf.subtract(model.y_, model.y))) + tf.add_n([tf.nn.l2_loss(v) for v in train_vars]) * L2NormConst accuracy = 100 - loss train_step = tf.train.AdamOptimizer(1e-4).minimize(loss) sess.run(tf.initialize_all_variables()) # create a summary to monitor cost tensor tf.summary.scalar("loss", loss) tf.summary.scalar("accuracy", accuracy) # merge all summaries into a single op merged_summary_op = tf.summary.merge_all() saver = tf.train.Saver(write_version = saver_pb2.SaverDef.V2) # op to write logs to Tensorboard logs_path = './logs' summary_writer = tf.summary.FileWriter(logs_path, graph=tf.get_default_graph()) # 30 epochs is a good number. You can in or decrease baed on your computation power. epochs = 30 batch_size = 32 # Training with those values takes about an hour on a GTX 1070 with CUDA 10.0 for epoch in range(epochs): for i in range(int(driving_data.num_images/batch_size)): xs, ys = driving_data.LoadTrainBatch(batch_size) train_step.run(feed_dict={model.x: xs, model.y_: ys, model.keep_prob: 0.8}) if i % 10 == 0: xs, ys = driving_data.LoadValBatch(batch_size) # The Step value is calculated by: epoch * batchsize + i loss_value = loss.eval(feed_dict={model.x:xs, model.y_: ys, model.keep_prob: 1.0}) print("Epoch: %d, Step: %d, Loss: %g" % (epoch, epoch * batch_size + i, loss_value))
def main(): """Create the model and start the training.""" args = get_arguments() os.environ['CUDA_DEVIDE_ORDER'] = "PCI_BUS_ID" os.environ['CUDA_VISIBLE_DEVICES'] = args.GPU h, w = map(int, args.input_size.split(',')) input_size = (h, w) tf.set_random_seed(args.random_seed) # Create queue coordinator. coord = tf.train.Coordinator() # Load reader. with tf.name_scope("create_inputs"): reader = ImageReader(args.data_dir, args.data_list, input_size, args.random_scale, args.random_mirror, args.ignore_label, IMG_MEAN, coord) image_batch, label_batch = reader.dequeue(args.batch_size) image_batch075 = tf.image.resize_images( image_batch, [int(h * 0.75), int(w * 0.75)]) image_batch05 = tf.image.resize_images( image_batch, [int(h * 0.5), int(w * 0.5)]) # Create network. with tf.variable_scope('', reuse=False): net = DeepLabResNetModel_34({'data': image_batch}, is_training=args.is_training, num_classes=args.num_classes) with tf.variable_scope('', reuse=True): net075 = DeepLabResNetModel_34({'data': image_batch075}, is_training=args.is_training, num_classes=args.num_classes) with tf.variable_scope('', reuse=True): net05 = DeepLabResNetModel_34({'data': image_batch05}, is_training=args.is_training, num_classes=args.num_classes) # For a small batch size, it is better to keep # the statistics of the BN layers (running means and variances) # frozen, and to not update the values provided by the pre-trained model. # If is_training=True, the statistics will be updated during the training. # Note that is_training=False still updates BN parameters gamma (scale) and beta (offset) # if they are presented in var_list of the optimiser definition. # Predictions. raw_output100 = net.layers['fc1_voc12'] raw_output075 = net075.layers['fc1_voc12'] raw_output05 = net05.layers['fc1_voc12'] raw_output = tf.reduce_max(tf.stack([ raw_output100, tf.image.resize_images(raw_output075, tf.shape(raw_output100)[1:3, ]), tf.image.resize_images(raw_output05, tf.shape(raw_output100)[1:3, ]) ]), axis=0) # Which variables to load. Running means and variances are not trainable, # thus all_variables() should be restored. restore_var = [ v for v in tf.global_variables() if 'fc' not in v.name or not args.not_restore_last ] all_trainable = [ v for v in tf.trainable_variables() if 'beta' not in v.name and 'gamma' not in v.name ] fc_trainable = [v for v in all_trainable if 'fc' in v.name] conv_trainable = [v for v in all_trainable if 'fc' not in v.name] # lr * 1.0 fc_w_trainable = [v for v in fc_trainable if 'weights' in v.name] # lr * 10.0 fc_b_trainable = [v for v in fc_trainable if 'biases' in v.name] # lr * 20.0 assert (len(all_trainable) == len(fc_trainable) + len(conv_trainable)) assert (len(fc_trainable) == len(fc_w_trainable) + len(fc_b_trainable)) # Predictions: ignoring all predictions with labels greater or equal than n_classes raw_prediction = tf.reshape(raw_output, [-1, args.num_classes]) raw_prediction100 = tf.reshape(raw_output100, [-1, args.num_classes]) raw_prediction075 = tf.reshape(raw_output075, [-1, args.num_classes]) raw_prediction05 = tf.reshape(raw_output05, [-1, args.num_classes]) label_proc = prepare_label(label_batch, tf.stack(raw_output.get_shape()[1:3]), num_classes=args.num_classes, one_hot=False) # [batch_size, h, w] label_proc075 = prepare_label(label_batch, tf.stack(raw_output075.get_shape()[1:3]), num_classes=args.num_classes, one_hot=False) label_proc05 = prepare_label(label_batch, tf.stack(raw_output05.get_shape()[1:3]), num_classes=args.num_classes, one_hot=False) raw_gt = tf.reshape(label_proc, [ -1, ]) raw_gt075 = tf.reshape(label_proc075, [ -1, ]) raw_gt05 = tf.reshape(label_proc05, [ -1, ]) indices = tf.squeeze(tf.where(tf.less_equal(raw_gt, args.num_classes - 1)), 1) indices075 = tf.squeeze( tf.where(tf.less_equal(raw_gt075, args.num_classes - 1)), 1) indices05 = tf.squeeze( tf.where(tf.less_equal(raw_gt05, args.num_classes - 1)), 1) gt = tf.cast(tf.gather(raw_gt, indices), tf.int32) gt075 = tf.cast(tf.gather(raw_gt075, indices075), tf.int32) gt05 = tf.cast(tf.gather(raw_gt05, indices05), tf.int32) prediction = tf.gather(raw_prediction, indices) prediction100 = tf.gather(raw_prediction100, indices) prediction075 = tf.gather(raw_prediction075, indices075) prediction05 = tf.gather(raw_prediction05, indices05) # Pixel-wise softmax loss. loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=prediction, labels=gt) loss100 = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=prediction100, labels=gt) loss075 = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=prediction075, labels=gt075) loss05 = tf.nn.sparse_softmax_cross_entropy_with_logits( logits=prediction05, labels=gt05) l2_losses = [ args.weight_decay * tf.nn.l2_loss(v) for v in tf.trainable_variables() if 'weights' in v.name ] reduced_loss = tf.reduce_mean(loss) + tf.reduce_mean( loss100) + tf.reduce_mean(loss075) + tf.reduce_mean(loss05) + tf.add_n( l2_losses) tf.summary.scalar('loss', reduced_loss) # Processed predictions: for visualisation. raw_output_up = tf.image.resize_bilinear(raw_output, tf.shape(image_batch)[1:3, ]) raw_output_up = tf.argmax(raw_output_up, dimension=3) pred = tf.expand_dims(raw_output_up, dim=3) # Image summary. images_summary = tf.py_func(inv_preprocess, [image_batch, args.save_num_images, IMG_MEAN], tf.uint8) labels_summary = tf.py_func( decode_labels, [label_batch, args.save_num_images, args.num_classes], tf.uint8) preds_summary = tf.py_func(decode_labels, [pred, args.save_num_images, args.num_classes], tf.uint8) tf.summary.image( 'images', tf.concat(axis=2, values=[images_summary, labels_summary, preds_summary]), max_outputs=args.save_num_images) # Concatenate row-wise. # Define loss and optimisation parameters. base_lr = tf.constant(args.learning_rate) step_ph = tf.placeholder(dtype=tf.float32, shape=()) learning_rate = tf.scalar_mul( base_lr, tf.pow((1 - step_ph / args.num_steps), args.power)) tf.summary.scalar('learning_rate', learning_rate) opt_conv = tf.train.AdamOptimizer(learning_rate) opt_fc_w = tf.train.AdamOptimizer(learning_rate) opt_fc_b = tf.train.AdamOptimizer(learning_rate) # Define a variable to accumulate gradients. accum_grads = [ tf.Variable(tf.zeros_like(v.initialized_value()), trainable=False) for v in conv_trainable + fc_w_trainable + fc_b_trainable ] # Define an operation to clear the accumulated gradients for next batch. zero_op = [v.assign(tf.zeros_like(v)) for v in accum_grads] # Compute gradients. grads = tf.gradients(reduced_loss, conv_trainable + fc_w_trainable + fc_b_trainable) # Accumulate and normalise the gradients. accum_grads_op = [ accum_grads[i].assign_add(grad / args.grad_update_every) for i, grad in enumerate(grads) ] grads_conv = accum_grads[:len(conv_trainable)] grads_fc_w = accum_grads[len(conv_trainable):(len(conv_trainable) + len(fc_w_trainable))] grads_fc_b = accum_grads[(len(conv_trainable) + len(fc_w_trainable)):] # Apply the gradients. train_op_conv = opt_conv.apply_gradients(zip(grads_conv, conv_trainable)) train_op_fc_w = opt_fc_w.apply_gradients(zip(grads_fc_w, fc_w_trainable)) train_op_fc_b = opt_fc_b.apply_gradients(zip(grads_fc_b, fc_b_trainable)) train_op = tf.group(train_op_conv, train_op_fc_w, train_op_fc_b) merged = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(args.snapshot_dir, graph=tf.get_default_graph()) # Set up tf session and initialize variables. config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) init = tf.global_variables_initializer() sess.run(init) # Saver for storing checkpoints of the model. saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=10) # Load variables if the checkpoint is provided. if args.restore_from is not None: loader = tf.train.Saver(var_list=restore_var) load(loader, sess, args.restore_from) # Start queue threads. threads = tf.train.start_queue_runners(coord=coord, sess=sess) # Iterate over training steps. for step in range(args.num_steps): start_time = time.time() feed_dict = {step_ph: step} loss_value = 0 # Clear the accumulated gradients. sess.run(zero_op, feed_dict=feed_dict) # Accumulate gradients. for i in range(args.grad_update_every): _, l_val = sess.run([accum_grads_op, reduced_loss], feed_dict=feed_dict) loss_value += l_val # Normalise the loss. loss_value /= args.grad_update_every # Apply gradients. if step % args.save_pred_every == 0: images, labels, summary, _ = sess.run( [image_batch, label_batch, merged, train_op], feed_dict=feed_dict) summary_writer.add_summary(summary, step) save(saver, sess, args.snapshot_dir, step) else: sess.run(train_op, feed_dict=feed_dict) duration = time.time() - start_time print('step {:d} \t loss = {:.3f}, ({:.3f} sec/step)'.format( step, loss_value, duration)) coord.request_stop() coord.join(threads)
import itertools import tensorflow.keras.backend as K import numpy as np import pytest import tensorflow as tf from tensorflow.keras.layers import Input from flowket.machines.ensemble import make_2d_obc_invariants, make_pbc_invariants from .simple_models import real_values_2d_model, real_values_1d_model DEFAULT_TF_GRAPH = tf.get_default_graph() def transform_sample(sample, num_of_rotations, flip): if num_of_rotations > 0: sample = np.rot90(sample, k=num_of_rotations, axes=(1, 2)) if flip: sample = np.flip(sample, axis=2) return sample def roll_sample(sample, roll_for_axis): return np.roll(sample, roll_for_axis, tuple(range(1, len(roll_for_axis)))) @pytest.mark.parametrize('model_builder, batch_size', [ (real_values_2d_model, 100), ]) def test_make_2d_obc_invariants(model_builder, batch_size):
def approximator_deep(*args): data = tf.stack(args, axis = 1, name = 'data_stacked') data = tf.squeeze(data) # print(tf.cast(tf.keras.backend.ndim(data) == 1, tf.bool), # type(tf.cast(tf.keras.backend.ndim(data)1, tf.bool))) # test = tf.cond(pred = tf.cast(tf.keras.backend.ndim(data) == 1, tf.bool), # true_fn = lambda: True, false_fn = lambda: False) # print(type(tf.cast(tf.keras.backend.ndim(data) == 1, tf.bool))) # data = tf.cond(pred = tf.equal(tf.keras.backend.ndim(data), 1), # true_fn = lambda: tf.expand_dims(data, axis=1), false_fn = lambda: data) if tf.keras.backend.ndim(data) == 1: data = tf.expand_dims(data, axis=1) with tf.name_scope("UA_fit"): w1 = tf.get_default_graph().get_tensor_by_name("w1:0") b1 = tf.get_default_graph().get_tensor_by_name("b1:0") w2 = tf.get_default_graph().get_tensor_by_name("w2:0") b2 = tf.get_default_graph().get_tensor_by_name("b2:0") w3 = tf.get_default_graph().get_tensor_by_name("w3:0") b3 = tf.get_default_graph().get_tensor_by_name("b3:0") w4 = tf.get_default_graph().get_tensor_by_name("w4:0") b4 = tf.get_default_graph().get_tensor_by_name("b4:0") w5 = tf.get_default_graph().get_tensor_by_name("w5:0") b5 = tf.get_default_graph().get_tensor_by_name("b5:0") w_out = tf.get_default_graph().get_tensor_by_name("w_out:0") ws1 = tf.matmul(data, w1) + b1 a1 = tf.nn.sigmoid(ws1) ws2 = tf.matmul(a1, w2) + b2 a2 = tf.nn.sigmoid(ws2) ws3 = tf.matmul(a2, w3) + b3 a3 = tf.nn.sigmoid(ws3) ws4 = tf.matmul(a3, w4) + b4 a4 = tf.nn.sigmoid(ws4) ws5 = tf.matmul(a4, w5) + b5 a5 = tf.nn.sigmoid(ws5) ws_out = tf.matmul(a5, w_out) return ws_out
def train(hparams, event_dir=None, model_dir=None, restore_agent=True, epoch=0): """Train.""" with tf.name_scope("rl_train"): train_summary_op, _, initialization = define_train(hparams) if event_dir: summary_writer = tf.summary.FileWriter( event_dir, graph=tf.get_default_graph(), flush_secs=60) if model_dir: model_saver = tf.train.Saver( tf.global_variables(".*network_parameters.*")) else: summary_writer = None model_saver = None # TODO(piotrmilos): This should be refactored, possibly with # handlers for each type of env if hparams.environment_spec.simulated_env: env_model_loader = tf.train.Saver( tf.global_variables("next_frame*")) else: env_model_loader = None with tf.Session() as sess: sess.run(tf.global_variables_initializer()) initialization(sess) if env_model_loader: trainer_lib.restore_checkpoint(hparams.world_model_dir, env_model_loader, sess, must_restore=True) start_step = 0 if model_saver and restore_agent: start_step = trainer_lib.restore_checkpoint( model_dir, model_saver, sess) # Fail-friendly, don't train if already trained for this epoch if start_step >= ((hparams.epochs_num * (epoch + 1))): tf.logging.info( "Skipping PPO training for epoch %d as train steps " "(%d) already reached", epoch, start_step) return for epoch_index in range(hparams.epochs_num): summary = sess.run(train_summary_op) if summary_writer: summary_writer.add_summary(summary, epoch_index) if (hparams.eval_every_epochs and epoch_index % hparams.eval_every_epochs == 0): if summary_writer and summary: summary_writer.add_summary(summary, epoch_index) else: tf.logging.info("Eval summary not saved") if (model_saver and hparams.save_models_every_epochs and (epoch_index % hparams.save_models_every_epochs == 0 or (epoch_index + 1) == hparams.epochs_num)): ckpt_path = os.path.join( model_dir, "model.ckpt-{}".format(epoch_index + 1 + start_step)) model_saver.save(sess, ckpt_path)
def __fit_by_tf(self, X, node_id, node_probability, index2type, type2index, type2prob, model_name, model_path, result_path): ## Build layers for path2vec print('\t>> Building: path2vec layers...') logger.info('\t>> Building: path2vec layers...') timeref = time.time() center_node_holder, context_node_holder, negative_samples_holder, loss = self.__build_tf_place_holders( node_probability=node_probability) ## Optimization function for path2vec optimizer = self.__optimizer(center_node_holder, context_node_holder, negative_samples_holder) print('\t\t## Building layers consumed %.2f mintues' % (round((time.time() - timeref) / 60., 3))) logger.info('\t\t## Building layers consumed %.2f mintues' % (round((time.time() - timeref) / 60., 3))) print('\t>> Training path2vec...') logger.info('\t>> Training path2vec...') old_cost = np.inf timeref = time.time() cost_file_name = model_name + "_cost.txt" save_data('', file_name=cost_file_name, save_path=result_path, mode='w', w_string=True, print_tag=False) merged = tf.summary.merge_all() saver = tf.train.Saver(max_to_keep=self.num_models) config = tf.ConfigProto(intra_op_parallelism_threads=0, inter_op_parallelism_threads=0, allow_soft_placement=True) with tf.Session(config=config) as sess: sess.run(tf.global_variables_initializer()) writer = tf.summary.FileWriter(self.log_path, sess.graph) # Define metadata variable. run_metadata = tf.RunMetadata() for epoch in np.arange(start=1, stop=self.num_epochs + 1): desc = '\t {0:d})- Epoch count ({0:d}/{1:d})...'.format(epoch, self.num_epochs) print(desc) logger.info(desc) self.__shffule(X=X) list_batches = np.arange(start=0, stop=len(X), step=self.batch) epoch_timeref = time.time() new_cost = 0.0 for idx, batch in enumerate(list_batches): total_samples = (idx + 1) / len(list_batches) desc = '\t --> Learning: {0:.4f}% ...'.format(total_samples * 100) logger.info(desc) if (idx + 1) != len(list_batches): print(desc, end="\r") if (idx + 1) == len(list_batches): print(desc) ## Generate batch negative samples center_nodes, context_nodes = self.__generate_batch(X=X[batch:batch + self.batch]) negative_nodes = self.__get_negative_samples(center_nodes=center_nodes, node_id=node_id, node_probability=node_probability, index2type=index2type, type2index=type2index, type2probs=type2prob) batch_X_size = self.batch if self.batch > 150000: batch_X_size = 10000 list_batch_X = np.arange(start=0, stop=center_nodes.shape[0], step=batch_X_size) for b_idx, batch_X_idx in enumerate(list_batch_X): center_batch = center_nodes[batch_X_idx:batch_X_idx + batch_X_size] context_batch = context_nodes[batch_X_idx:batch_X_idx + batch_X_size] negative_batch = negative_nodes[batch_X_idx:batch_X_idx + batch_X_size] for inner_iterations in np.arange(self.max_inner_iter): feed_dict = {center_node_holder: center_batch, context_node_holder: context_batch, negative_samples_holder: negative_batch} # We perform one update step by evaluating the optimizer op (including it # in the list of returned values for session.run() # Also, evaluate the merged op to get all summaries from the returned # "summary" variable. Feed metadata variable to session for visualizing # the graph in TensorBoard. loss_batch, _, summary_str = sess.run([loss, optimizer, merged], feed_dict=feed_dict, run_metadata=run_metadata) writer.add_summary(summary_str, inner_iterations) loss_batch /= center_batch.shape[0] new_cost += loss_batch / self.max_inner_iter new_cost /= len(list_batch_X) new_cost /= len(list_batches) new_cost = new_cost * -1 self.is_fit = True print('\t\t ## Epoch {0} took {1} seconds...'.format(epoch, round(time.time() - epoch_timeref, 3))) logger.info( '\t\t ## Epoch {0} took {1} seconds...'.format(epoch, round(time.time() - epoch_timeref, 3))) data = str(epoch) + '\t' + str(round(time.time() - epoch_timeref, 3)) + '\t' + str(new_cost) + '\n' save_data(data=data, file_name=cost_file_name, save_path=result_path, mode='a', w_string=True, print_tag=False) # Save models parameters based on test frequencies if (epoch % self.display_interval) == 0 or epoch == 1 or epoch == self.num_epochs: print('\t\t --> New cost: {0:.4f}; Old cost: {1:.4f}'.format(new_cost, old_cost)) logger.info('\t\t --> New cost: {0:.4f}; Old cost: {1:.4f}'.format(new_cost, old_cost)) if new_cost < old_cost or epoch == self.num_epochs: old_cost = new_cost tag_final_file = "_tf.ckpt" tag_final_embeddings = "_tf_embeddings.npz" if epoch == self.num_epochs: tag_final_file = "_final_tf.ckpt" tag_final_embeddings = "_final_tf_embeddings.npz" print('\t\t --> Storing the path2vec model to: {0:s}'.format(model_name + tag_final_file)) logger.info( '\t\t --> Storing the path2vec model to: {0:s}'.format(model_name + tag_final_file)) saver.save(sess, os.path.join(model_path, model_name + tag_final_file)) print('\t\t --> Storing the path2vec node embeddings as numpy array to: {0:s}'.format( model_name + tag_final_embeddings)) logger.info('\t\t --> Storing the path2vec node embeddings as numpy array to: {0:s}'.format( model_name + tag_final_embeddings)) model_embeddings = tf.get_default_graph() model_embeddings = model_embeddings.get_tensor_by_name("embeddings/embedding_matrix:0") # Create a configuration for visualizing embeddings with the selected_pathways in TensorBoard. # TODO: comment this config = projector.ProjectorConfig() embedding_conf = config.embeddings.add() embedding_conf.tensor_name = model_embeddings.name ## model_embeddings = sess.run(model_embeddings) np.savez(os.path.join(model_path, model_name + tag_final_embeddings), model_embeddings) # TODO: comment this embedding_conf.metadata_path = os.path.join(model_path, model_name + '_metadata.tsv') projector.visualize_embeddings(writer, config) writer.close() print('\t --> Training consumed %.2f mintues' % (round((time.time() - timeref) / 60., 3))) logger.info('\t --> Training consumed %.2f mintues' % (round((time.time() - timeref) / 60., 3)))
def __init__(self, graph_path, target_size=(320, 240), tf_config=None, trt_bool=False): self.target_size = target_size # load graph logger.info('loading graph from %s(default size=%dx%d)' % (graph_path, target_size[0], target_size[1])) with tf.gfile.GFile(graph_path, 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) if trt_bool is True: output_nodes = ["Openpose/concat_stage7"] graph_def = trt.create_inference_graph( graph_def, output_nodes, max_batch_size=1, max_workspace_size_bytes=1 << 20, precision_mode="FP16", # precision_mode="INT8", minimum_segment_size=3, is_dynamic_op=True, maximum_cached_engines=int(1e3), # use_calibration=True, ) self.graph = tf.get_default_graph() tf.import_graph_def(graph_def, name='TfPoseEstimator') self.persistent_sess = tf.Session(graph=self.graph, config=tf_config) for ts in [n.name for n in tf.get_default_graph().as_graph_def().node]: print(ts) self.tensor_image = self.graph.get_tensor_by_name( 'TfPoseEstimator/image:0') self.tensor_output = self.graph.get_tensor_by_name( 'TfPoseEstimator/Openpose/concat_stage7:0') self.tensor_heatMat = self.tensor_output[:, :, :, :19] self.tensor_pafMat = self.tensor_output[:, :, :, 19:] self.upsample_size = tf.placeholder(dtype=tf.int32, shape=(2, ), name='upsample_size') self.tensor_heatMat_up = tf.image.resize_area( self.tensor_output[:, :, :, :19], self.upsample_size, align_corners=False, name='upsample_heatmat') self.tensor_pafMat_up = tf.image.resize_area( self.tensor_output[:, :, :, 19:], self.upsample_size, align_corners=False, name='upsample_pafmat') if trt_bool is True: smoother = Smoother({'data': self.tensor_heatMat_up}, 25, 3.0, 19) else: smoother = Smoother({'data': self.tensor_heatMat_up}, 25, 3.0) gaussian_heatMat = smoother.get_output() max_pooled_in_tensor = tf.nn.pool(gaussian_heatMat, window_shape=(3, 3), pooling_type='MAX', padding='SAME') self.tensor_peaks = tf.where( tf.equal(gaussian_heatMat, max_pooled_in_tensor), gaussian_heatMat, tf.zeros_like(gaussian_heatMat)) self.heatMat = self.pafMat = None # warm-up self.persistent_sess.run( tf.variables_initializer([ v for v in tf.global_variables() if v.name.split(':')[0] in [ x.decode('utf-8') for x in self.persistent_sess.run( tf.report_uninitialized_variables()) ] ])) self.persistent_sess.run( [self.tensor_peaks, self.tensor_heatMat_up, self.tensor_pafMat_up], feed_dict={ self.tensor_image: [ np.ndarray(shape=(target_size[1], target_size[0], 3), dtype=np.float32) ], self.upsample_size: [target_size[1], target_size[0]] }) self.persistent_sess.run( [self.tensor_peaks, self.tensor_heatMat_up, self.tensor_pafMat_up], feed_dict={ self.tensor_image: [ np.ndarray(shape=(target_size[1], target_size[0], 3), dtype=np.float32) ], self.upsample_size: [target_size[1] // 2, target_size[0] // 2] }) self.persistent_sess.run( [self.tensor_peaks, self.tensor_heatMat_up, self.tensor_pafMat_up], feed_dict={ self.tensor_image: [ np.ndarray(shape=(target_size[1], target_size[0], 3), dtype=np.float32) ], self.upsample_size: [target_size[1] // 4, target_size[0] // 4] }) # logs if self.tensor_image.dtype == tf.quint8: logger.info('quantization mode enabled.')
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv) cross_entropy = tf.reduce_mean(cross_entropy) with tf.name_scope('adam_optimizer'): train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) with tf.name_scope('accuracy'): correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1)) correct_prediction = tf.cast(correct_prediction, tf.float32) accuracy = tf.reduce_mean(correct_prediction) graph_location = logdir print('Saving graph to: %s' % graph_location) train_writer = tf.summary.FileWriter(graph_location) train_writer.add_graph(tf.get_default_graph()) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) zipped_data = zip(data_sets['images_train'], data_sets['labels_train']) batches = data_helpers.gen_batch(list(zipped_data), FLAGS.batch_size, FLAGS.max_steps) for i in range(FLAGS.max_steps): batch = next(batches) images_batch, labels_batch = zip(*batch) # reshape labels_batch_reshape = np.zeros((len(labels_batch), CLASSES))
#!/usr/bin/env python # coding:utf8 # @Date : 2018-04-24 09:15:31 # @Author : Koon # @Link : zpkoon.xyz # When I wrote this, only God and I understood what I was doing. Now, God only knows. import tensorflow as tf saver = tf.train.import_meta_graph("./models/model.ckpt.meta") with tf.Session() as sess: saver.restore(sess, "./models/model.ckpt") # 通过张量的名称来获取张量 print(sess.run(tf.get_default_graph().get_tensor_by_name("add:0")))
def main(argv): print("Evaluating the model ...") config = Config() config.beam_size = FLAGS.beam_size config.phase = 'eval' if not os.path.exists(config.eval_result_dir): os.mkdir(config.eval_result_dir) print("Building the vocabulary...") vocabulary = Vocabulary(config.vocabulary_size) vocabulary.load(config.vocabulary_file) print("Vocabulary built.") print("Number of words = %d" %(vocabulary.size)) eval_data = DataProvider(config) eval_gt_coco = eval_data.returncoco() model = ShowAttendTell(config) model.build() with tf.Session() as sess: model.setup_graph_from_checkpoint(sess, config.caption_checkpoint_dir) tf.get_default_graph().finalize() captiongen = CaptionGenerator(model, vocabulary, config.beam_size, config.max_caption_length, config.batch_size) # Generate the captions for the images results = [] idx = 0 for k in tqdm(list(range(eval_data.num_batches)), desc='batch'): batch,images = eval_data.next_batch_and_images() caption_data = captiongen.beam_search(sess, images,vocabulary) fake_cnt = 0 if k<eval_data.num_batches-1 \ else eval_data.fake_count for l in range(eval_data.batch_size-fake_cnt): word_idxs = caption_data[l][0].sentence score = caption_data[l][0].score caption = vocabulary.get_sentence(word_idxs) results.append({'image_id': eval_data.image_ids[idx], 'caption': caption}) idx += 1 # Save the result in an image file, if requested if config.save_eval_result_as_image: image_file = batch[l] image_name = image_file.split(os.sep)[-1] image_name = os.path.splitext(image_name)[0] img = plt.imread(image_file) plt.switch_backend('agg') plt.imshow(img) plt.axis('off') plt.title(caption) plt.savefig(os.path.join(config.eval_result_dir, image_name+'_result.jpg')) fp = open(config.eval_result_file, 'wb') json.dump(results, fp) fp.close() # Evaluate these captions eval_result_coco = eval_gt_coco.loadRes(config.eval_result_file) scorer = COCOEvalCap(eval_gt_coco, eval_result_coco) scorer.evaluate() print("Evaluation complete.")
import os import random import tensorflow as tf # In[2]: # Get images X = [] for filename in os.listdir('Train/'): X.append(img_to_array(load_img('Train/' + filename))) X = np.array(X, dtype=float) Xtrain = 1.0 / 255 * X #Load weights inception = InceptionResNetV2(weights='imagenet', include_top=True) inception.graph = tf.get_default_graph() # In[4]: embed_input = Input(shape=(1000, )) #Encoder encoder_input = Input(shape=( 256, 256, 1, )) encoder_output = Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)(encoder_input)
import numpy as np import random import os import tensorflow as tf from keras import backend as K # fix the data generation seed for reproducibility random.seed(1) np.random.seed(1) session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1) tf.set_random_seed(1) sess = tf.Session(graph=tf.get_default_graph(), config=session_conf) K.set_session(sess) def get_training_samples(n_features, n_samples=100, upper_bound=100): temp = [] samples = [] target = [] if not os.path.exists('test_dataset.txt') and not os.path.exists( 'test_dataset_labels.txt'): for i in range(n_samples): input_seq = [ random.randint(0, upper_bound) for _ in range(n_features) ] output_seq = np.sum(input_seq) samples.append(input_seq)
def dynamic_decode(decoder, impute_finished=False, maximum_iterations=None, parallel_iterations=32, swap_memory=False, scope=None): """Perform dynamic decoding with `decoder`. Calls initialize() once and step() repeatedly on the Decoder object. Args: decoder: A `Decoder` instance. impute_finished: Python boolean. If `True`, then states for batch entries which are marked as finished get copied through and the corresponding outputs get zeroed out. This causes some slowdown at each time step, but ensures that the final state and outputs have the correct values and that backprop ignores time steps that were marked as finished. maximum_iterations: `int32` scalar, maximum allowed number of decoding steps. Default is `None` (decode until the decoder is fully done). parallel_iterations: Argument passed to `tf.while_loop`. swap_memory: Argument passed to `tf.while_loop`. scope: Optional variable scope to use. Returns: `(final_outputs, final_state, final_sequence_lengths)`. Raises: TypeError: if `decoder` is not an instance of `Decoder`. ValueError: if `maximum_iterations` is provided but is not a scalar. """ if not isinstance(decoder, Decoder): raise TypeError("Expected decoder to be type Decoder, but saw: %s" % type(decoder)) with tf.variable_scope(scope, "decoder") as varscope: # Determine context types. ctxt = tf.get_default_graph()._get_control_flow_context() # pylint: disable=protected-access is_xla = control_flow_util.GetContainingXLAContext(ctxt) is not None in_while_loop = (control_flow_util.GetContainingWhileContext(ctxt) is not None) # Properly cache variable values inside the while_loop. # Don't set a caching device when running in a loop, since it is possible # that train steps could be wrapped in a tf.while_loop. In that scenario # caching prevents forward computations in loop iterations from re-reading # the updated weights. if not tf.executing_eagerly() and not in_while_loop: if varscope.caching_device is None: varscope.set_caching_device(lambda op: op.device) if maximum_iterations is not None: maximum_iterations = tf.convert_to_tensor( maximum_iterations, dtype=tf.int32, name="maximum_iterations") if maximum_iterations.get_shape().ndims != 0: raise ValueError("maximum_iterations must be a scalar") initial_finished, initial_inputs, initial_state = decoder.initialize() zero_outputs = _create_zero_outputs(decoder.output_size, decoder.output_dtype) if is_xla and maximum_iterations is None: raise ValueError( "maximum_iterations is required for XLA compilation.") if maximum_iterations is not None: initial_finished = tf.logical_or(initial_finished, 0 >= maximum_iterations) initial_sequence_lengths = tf.zeros_like(initial_finished, dtype=tf.int32) initial_time = tf.constant(0, dtype=tf.int32) dynamic_size = maximum_iterations is None or not is_xla def _create_ta(s, d): return tf.TensorArray( dtype=d, size=0 if dynamic_size else maximum_iterations, dynamic_size=dynamic_size, element_shape=s) initial_outputs_ta = tf.contrib.framework.nest.map_structure( _create_ta, decoder.output_size, decoder.output_dtype) def condition(unused_time, unused_outputs_ta, unused_state, unused_inputs, finished, unused_sequence_lengths): return tf.logical_not(tf.reduce_all(finished)) def body(time, outputs_ta, state, inputs, finished, sequence_lengths): """Internal while_loop body. Args: time: scalar int32 tensor. outputs_ta: structure of TensorArray. state: (structure of) state tensors and TensorArrays. inputs: (structure of) input tensors. finished: bool tensor (keeping track of what's finished). sequence_lengths: int32 tensor (keeping track of time of finish). Returns: `(time + 1, outputs_ta, next_state, next_inputs, next_finished, next_sequence_lengths)`. ``` """ (next_outputs, decoder_state, next_inputs, decoder_finished) = decoder.step(time, inputs, state) if decoder.tracks_own_finished: next_finished = decoder_finished else: next_finished = tf.logical_or(decoder_finished, finished) next_sequence_lengths = tf.where( tf.logical_not(finished), tf.fill(tf.shape(sequence_lengths), time + 1), sequence_lengths) tf.contrib.framework.nest.assert_same_structure( state, decoder_state) tf.contrib.framework.nest.assert_same_structure( outputs_ta, next_outputs) tf.contrib.framework.nest.assert_same_structure( inputs, next_inputs) # Zero out output values past finish if impute_finished: emit = tf.contrib.framework.nest.map_structure( lambda out, zero: tf.where(finished, zero, out), next_outputs, zero_outputs) else: emit = next_outputs # Copy through states past finish def _maybe_copy_state(new, cur): # TensorArrays and scalar states get passed through. if isinstance(cur, tf.TensorArray): pass_through = True else: new.set_shape(cur.shape) pass_through = (new.shape.ndims == 0) return new if pass_through else tf.where(finished, cur, new) if impute_finished: next_state = tf.contrib.framework.nest.map_structure( _maybe_copy_state, decoder_state, state) else: next_state = decoder_state outputs_ta = tf.contrib.framework.nest.map_structure( lambda ta, out: ta.write(time, out), outputs_ta, emit) return (time + 1, outputs_ta, next_state, next_inputs, next_finished, next_sequence_lengths) res = tf.while_loop(condition, body, loop_vars=( initial_time, initial_outputs_ta, initial_state, initial_inputs, initial_finished, initial_sequence_lengths, ), parallel_iterations=parallel_iterations, maximum_iterations=maximum_iterations, swap_memory=swap_memory) final_outputs_ta = res[1] final_state = res[2] final_sequence_lengths = res[5] final_outputs = tf.contrib.framework.nest.map_structure( lambda ta: ta.stack(), final_outputs_ta) try: final_outputs, final_state = decoder.finalize( final_outputs, final_state, final_sequence_lengths) except NotImplementedError: pass return final_state.pred_ids
def run_inference_for_single_image(graph): sess_config = tf.ConfigProto() sess_config.intra_op_parallelism_threads = args.num_intra_threads sess_config.inter_op_parallelism_threads = args.num_inter_threads if not os.environ.get("OMP_NUM_THREADS"): os.environ["OMP_NUM_THREADS"] = str(args.num_intra_threads) with graph.as_default(): with tf.Session(config=sess_config) as sess: # Get handles to input and output tensors tensor_dict = {} if (args.evaluate_tensor is None): ops = tf.get_default_graph().get_operations() all_tensor_names = { output.name for op in ops for output in op.outputs } for key in [ 'num_detections', 'detection_boxes', 'detection_scores', 'detection_classes' ]: tensor_name = key + ':0' if tensor_name in all_tensor_names: tensor_dict[key] = tf.get_default_graph( ).get_tensor_by_name(tensor_name) else: our_op = tf.get_default_graph().get_operation_by_name( args.evaluate_tensor) tensor_names = our_op.outputs list_ops = [] for i, tensor in enumerate(tensor_names): list_ops.append(tensor.name) tensor_dict[args.evaluate_tensor] = list_ops if (args.timeline is not None): run_options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() total_duration = 0 for index, image_np in images(TEST_IMAGE_PATHS): image_tensor = tf.get_default_graph().get_tensor_by_name( 'image_tensor:0') # Run inference start_time = time.time() if (args.timeline is not None): output_dict = sess.run( tensor_dict, feed_dict={image_tensor: np.expand_dims(image_np, 0)}, options=run_options, run_metadata=run_metadata) else: output_dict = sess.run( tensor_dict, feed_dict={image_tensor: np.expand_dims(image_np, 0)}) step_duration = time.time() - start_time if (index > 20): total_duration = total_duration + step_duration if (index % 10 == 0 and index > 0): print('Step ' + str(index) + ': ' + str(step_duration) + ' seconds') if (args.number_of_steps is not None): if (args.single_image): sys.exit( "single_image and number_of_steps cannot be both enabled!" ) elif (index == (args.number_of_steps - 1)): break if (args.timeline is not None): trace = timeline.Timeline( step_stats=run_metadata.step_stats) with open( 'tl-' + time.strftime("%Y%m%d-%H%M%S") + '-' + args.timeline, 'w') as file: file.write( trace.generate_chrome_trace_format( show_memory=False)) if (args.evaluate_tensor is not None): for tensor in output_dict[args.evaluate_tensor]: print(tensor.shape) return None, None # all outputs are float32 numpy arrays, so convert types as appropriate output_dict['num_detections'] = int( output_dict['num_detections'][0]) output_dict['detection_classes'] = output_dict[ 'detection_classes'][0].astype(np.uint8) output_dict['detection_boxes'] = output_dict[ 'detection_boxes'][0] output_dict['detection_scores'] = output_dict[ 'detection_scores'][0] if (args.print_accuracy): print('num_detections:\n' + str(output_dict['num_detections'])) print('detection_classes:\n' + str(output_dict['detection_classes'])) print('detection_boxes:\n' + str(output_dict['detection_boxes'])) print('detection_scores:\n' + str(output_dict['detection_scores'])) if 'detection_masks' in output_dict: output_dict['detection_masks'] = output_dict[ 'detection_masks'][0] if index % 10 != 0: print('Step ' + str(index) + ': ' + str(step_duration) + ' seconds') # for single image option use step duration # for multiple images use total duration add 1 becouse index stats with 0 and substract 20 warmup steps steps, duration = (1, step_duration) if args.single_image else (( index + 1 - 20), total_duration) print('Avg. Duration per Step:' + str(duration / steps) + 'for processed number of steps: ' + str(steps)) return output_dict, image_np
rel_repr = encode_path_elem(rel_seq, rel_len, embd, seq_embedder_params={'name': 'test_embd', 'with_projection': False}, seq_encoder_params={ 'module': 'average' }) rel_repr_lstm = encode_path_elem(rel_seq, rel_len, embd, name='lstm_encoder', seq_embedder_params={'name': 'test_embd', 'with_projection': False}, seq_encoder_params={ 'module': 'lstm', 'repr_dim': repr_dim }) for op in tf.get_default_graph().get_operations(): print(str(op.name)) with tf.train.MonitoredTrainingSession() as sess: test_rel_seq_repr = sess.run(rel_repr, feed_dict={rel_seq: test_rel_seq, rel_len: test_rel_length}) print('Output shape', test_rel_seq_repr.shape) np.testing.assert_allclose(t1_avg, test_rel_seq_repr[0, 0, :]) np.testing.assert_allclose(t2_avg, test_rel_seq_repr[0, 1, :]) np.testing.assert_allclose(t3_avg, test_rel_seq_repr[1, 0, :]) assert (0 == test_rel_seq_repr[1, 1, :]).all() test_rel_seq_repr_lstm = sess.run(rel_repr_lstm, feed_dict={rel_seq: test_rel_seq, rel_len: test_rel_length} )
y = tf.placeholder(tf.float32, (N, 1)) with tf.name_scope("weights"): W = tf.Variable(tf.random_normal((1, 1))) b = tf.Variable(tf.random_normal((1, ))) with tf.name_scope("prediction"): y_pred = tf.matmul(x, W) + b with tf.name_scope("loss"): l = tf.reduce_sum((y - y_pred)**2) with tf.name_scope("optim"): train_op = tf.train.AdamOptimizer(.001).minimize(l) with tf.name_scope("summaries"): tf.summary.scalar("loss", l) merged = tf.summary.merge_all() train_writer = tf.summary.FileWriter('/tmp/lr-train', tf.get_default_graph()) n_steps = 8000 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # Train model for i in range(n_steps): feed_dict = {x: x_np, y: y_np} _, summary, loss = sess.run([train_op, merged, l], feed_dict=feed_dict) print("step %d, loss: %f" % (i, loss)) train_writer.add_summary(summary, i) # Get weights w_final, b_final = sess.run([W, b]) # Make Predictions
def __init__(self, nb_clusters, centroids_init=None, nb_tries=10, nb_iterations=10, input_tensor=None, latent_space_tensor=None, beta=None, threshold=2.5, assign_at_end=False): self.nb_clusters = nb_clusters self.nb_iterations = nb_iterations self.nb_tries = nb_tries self.latent_space_tensor = latent_space_tensor self.beta = beta self.assign_at_end = assign_at_end if input_tensor is None: self.graph = tf.Graph() else: self.graph = tf.get_default_graph() with self.graph.as_default(): with tf.name_scope('kmeans'): if input_tensor is None: # Spectrogram, embeddings # shape = [batch, L , E ] self.X_in = tf.placeholder("float", [None, None, None], name='Kmeans_input') else: self.X_in = input_tensor # mean, _ = tf.nn.moments(self.X_in, axes=-1, keep_dims=True) x_norm = tf.nn.l2_normalize(self.X_in, axis=-1) self.b = tf.shape(x_norm)[0] self.X_original = tf.identity(x_norm) self.X = tf.expand_dims(x_norm, 1) self.X = tf.tile(self.X, [1, self.nb_tries, 1, 1]) self.L = tf.shape(self.X)[-2] self.E = tf.shape(self.X)[-1] self.X = tf.reshape(self.X, [-1, self.L, self.E]) self.B = tf.shape(self.X)[0] self.ones = tf.ones_like(self.X, tf.float32) self.shifting = tf.tile( tf.expand_dims(tf.range(self.B) * self.nb_clusters, 1), [1, self.L]) if centroids_init is None: def random_without_replace(b, l): a = np.array([ np.random.choice(range(l), size=self.nb_clusters, replace=False) for _ in range(b) ]) return a.astype(np.int32) y = tf.py_func(random_without_replace, [self.B, self.L], tf.int32) random = tf.reshape(y, [self.B, self.nb_clusters, 1]) # Take randomly 'nb_clusters' vectors from X batch_range = tf.tile( tf.reshape(tf.range(self.B, dtype=tf.int32), shape=[self.B, 1, 1]), [1, self.nb_clusters, 1]) indices = tf.concat([batch_range, random], axis=2) self.centroid_init = tf.gather_nd(self.X, indices) else: self.centroids = tf.identity(centroids_init) self.centroids = tf.tile(self.centroids, [self.nb_tries, 1, 1]) if not self.latent_space_tensor is None: latent_space_tensor = tf.reshape(latent_space_tensor, [self.b, self.L]) log_lst = log10( tf.divide( tf.reduce_max(latent_space_tensor, [-1], keep_dims=True), latent_space_tensor)) self.notsilent_notry = tf.reshape( tf.cast(log_lst < threshold, tf.float32), [self.b, self.L, 1]) self.notsilent = tf.tile(self.notsilent_notry, [self.nb_tries, 1, 1]) else: self.notsilent = tf.ones([self.B, self.L, 1]) self.network
def main(args): start = time.time() img_ = cv2.imread(args.image_file) mt = mtcnn(160) img_ = img_[:, :, ::-1] # BGR转换为RGB image1, rectangles_ = mt.detectFace(img_) print(rectangles_) image1 = prewhiten(image1[0]) print(image1) with tf.Graph().as_default(): with tf.Session() as sess: # Load the model facenet.load_model(args.model) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") cap = cv2.VideoCapture(0) print(image1.shape) image1 = np.expand_dims(image1, axis=0) print(image1.shape) cnt = 0 while (1): start1 = int(round(time.time() * 1000)) # ms ret, img = cap.read() #cv2.imshow("333", img) #cv2.waitKey(0) img = img[:, :, ::-1] # BGR转换为RGB image2, rectangles = mt.detectFace(img) # 再折腾回来 img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) if len(image1) == 0 or len(image2) == 0: print("image1 or image2 is empty!") cv2.imshow("face", img) cv2.waitKey(10) continue for i in range(len(image2)): image2_ = copy.deepcopy(prewhiten(image2[i])) _image2 = np.expand_dims(image2_, axis=0) images = np.concatenate((image1, _image2), axis=0) # Run forward pass to calculate embeddings feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb = sess.run(embeddings, feed_dict=feed_dict) dist = np.sqrt( np.sum(np.square(np.subtract(emb[0, :], emb[1, :])))) sim = calculSimilar(emb[0, :], emb[1, :]) print("相似度: ", sim) print("Distance: ", dist) cv2.rectangle( img, (int(rectangles[i][0]), int(rectangles[i][1])), (int(rectangles[i][2]), int(rectangles[i][3])), (255, 0, 0), 1) cv2.putText( img, 'Similar: ' + str(sim)[:5], (int(rectangles[i][0]) + 5, int(rectangles[i][1]) + 5), cv2.FONT_HERSHEY_COMPLEX, 2, (0, 255, 0), 2) cv2.imshow("face", img) if cv2.waitKey(10) and 0xFF == ord('q'): break start2 = int(round(time.time() * 1000)) print("cost time(ms): ", (start2 - start1)) print("fps: ", 1000.0 / (start2 - start1)) cap.release() cv2.destroyAllWindows()
def graph_create(graphpath): with tf.gfile.FastGFile(graphpath, 'rb') as graphfile: graphdef = tf.GraphDef() graphdef.ParseFromString(graphfile.read()) return tf.import_graph_def(graphdef, name='', return_elements=[]) graph_create("ssdlite_mobilenet_v2_coco_2018_05_09/frozen_inference_graph.pb") save_dir = ('output') if not os.path.exists(save_dir): os.mkdir(save_dir) with tf.Session() as sess: tensors = [tensor for tensor in tf.get_default_graph().as_graph_def().node] for t in tensors: if ('weights' in t.name \ or 'bias' in t.name \ or 'moving_variance' in t.name \ or 'moving_mean' in t.name \ or 'beta' in t.name \ or 'gamma' in t.name \ or 'BatchNorm/batchnorm/sub' in t.name \ or 'BatchNorm/batchnorm/mul' in t.name) \ and ('sub' in t.name or 'mul/' in t.name or 'read' in t.name): ts = tf.get_default_graph().get_tensor_by_name(t.name + ":0") data = ts.eval() #print(t.name) names = t.name.split('/') layer_name = None
def main(args): #输入的数据? train_X, train_y_1, train_y_2, test_X, test_y_1, test_y_2 = load_data( ) #加载数据集 m = train_X.shape[0] #输入的训练数据x的个数 n_output_1 = test_y_1.shape[1] #所属的类的维度(有多少个类) n_output_2 = test_y_2.shape[1] lr = args.lr #未知,args并不知道是什么东西 n_epoch = args.n_epoch n_batch_size = args.n_batch_size reg_lambda = args.reg_lambda keep_prob = args.keep_prob cross_stitch_enabled = args.cross_stitch_enabled with tf.variable_scope("placeholder"): #让变量有相同的命名,包括tf.get_variable得到的变量 #即括号里面的所有变量都是叫做placeholder X = tf.placeholder(tf.float32, (None, 28, 28, 1), "X") y_1 = tf.placeholder(tf.float32, (None, n_output_1), "y_1") y_2 = tf.placeholder(tf.float32, (None, n_output_2), "y_2") is_training = tf.placeholder(tf.bool, (), "is_training") with tf.variable_scope("network"): #构建网络 #括号里面所有的变量都是叫做network with contrib.framework.arg_scope( [contrib.layers.fully_connected, slim.layers.conv2d], # he initialization weights_initializer=contrib.layers. variance_scaling_initializer(), # l2 regularization weights_regularizer=contrib.layers.l2_regularizer(reg_lambda), # BN normalizer_fn=contrib.layers.batch_norm, normalizer_params={ "is_training": is_training, "scale": True, "updates_collections": None }): # (?, 28, 28, 1) -> (?, 28, 28, 32) conv1_1 = slim.layers.conv2d(X, 32, kernel_size=[3, 3], scope="conv1_1") #两层卷积两层pooling层 conv1_2 = slim.layers.conv2d(X, 32, kernel_size=[3, 3], scope="conv1_2") # (?, 28, 28, 32) -> (?, 14, 14, 32) pool1_1 = slim.layers.max_pool2d(conv1_1, kernel_size=[2, 2], stride=2, scope="pool_1_1") pool1_2 = slim.layers.max_pool2d(conv1_2, kernel_size=[2, 2], stride=2, scope="pool_1_2") # (?, 14, 14, 32) -> (?, 14, 14, 64) conv2_1 = slim.layers.conv2d(pool1_1, 64, kernel_size=[3, 3], scope="conv2_1") conv2_2 = slim.layers.conv2d(pool1_2, 64, kernel_size=[3, 3], scope="conv2_2") # (?, 14, 14, 64) -> (?, 7, 7, 64) pool2_1 = slim.layers.max_pool2d(conv2_1, kernel_size=[2, 2], stride=2, scope="pool_2_1") pool2_2 = slim.layers.max_pool2d(conv2_2, kernel_size=[2, 2], stride=2, scope="pool_2_2") # (?, 7, 7, 64) -> (?, 3136) -> -> (?, 1024) with tf.variable_scope("fc_3_1"): #构建全连接层1 flatten_1 = contrib.layers.flatten(pool2_1) print("fully") print(flatten_1.shape) fc_3_1 = contrib.layers.fully_connected(flatten_1, 1024) with tf.variable_scope("fc_3_2"): #构建全连接层2 flatten_2 = contrib.layers.flatten(pool2_2) fc_3_2 = contrib.layers.fully_connected(flatten_2, 1024) dropout_1 = contrib.layers.dropout(fc_3_1, keep_prob=keep_prob, is_training=is_training, scope="dropout_1") dropout_2 = contrib.layers.dropout(fc_3_2, keep_prob=keep_prob, is_training=is_training, scope="dropout_2") output_1 = contrib.layers.fully_connected(dropout_1, n_output_1, activation_fn=None, scope="output_1") output_2 = contrib.layers.fully_connected(dropout_2, n_output_2, activation_fn=None, scope="output_2") with tf.variable_scope("loss"): #构建损失函数,分别为任务1和任务2的损失函数 loss_base_1 = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_1, logits=output_1)) loss_base_2 = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_2, logits=output_2)) reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) loss_total = loss_base_1 + loss_base_2 + tf.reduce_sum(reg_losses) with tf.variable_scope("evaluation"): accuracy_1 = tf.reduce_mean(tf.cast( tf.equal(tf.argmax(output_1, axis=-1), tf.argmax(y_1, axis=-1)), tf.float32), name="accuracy_1") accuracy_2 = tf.reduce_mean(tf.cast( tf.equal(tf.argmax(output_2, axis=-1), tf.argmax(y_2, axis=-1)), tf.float32), name="accuracy_2") accuracy = tf.divide(accuracy_1 + accuracy_2, 2.0, name="accuracy") with tf.variable_scope("train"): global_step = tf.get_variable("global_step", shape=(), dtype=tf.int32, trainable=False) train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize( loss_total, global_step=global_step) with tf.variable_scope("summary"): summary_loss_total = tf.summary.scalar("loss_total", loss_total) summary_accuracy_test = tf.summary.scalar("accuracy_test", accuracy) summary_accuracy_train = tf.summary.scalar("accuracy_train", accuracy) # standardization train_X_reshaped = train_X.reshape([train_X.shape[0], -1]) train_X_means = np.mean(train_X_reshaped, axis=0, keepdims=True) train_X_stds = np.std(train_X_reshaped, axis=0, keepdims=True) def standardization(x): x_reshaped = x.reshape([x.shape[0], -1]) result = (x_reshaped - train_X_means) / (train_X_stds + 1e-9) return result.reshape(x.shape) normalized_test_X = standardization(test_X) with tf.Session() as sess, tf.summary.FileWriter( "./tf_logs/independently/result", graph=tf.get_default_graph()) as f: #+ str(datetime.now().timestamp()), sess.run(tf.global_variables_initializer()) # similar logic as mnist's next_batch() epoch = 0 index_in_epoch = 0 while epoch < n_epoch: for _ in range( m // n_batch_size + 1): #get the integer part of a result from a division start = index_in_epoch if start + n_batch_size > m: epoch += 1 n_rest_data = m - start train_X_batch_rest = train_X[start:m] train_y_batch_rest_1 = train_y_1[start:m] train_y_batch_rest_2 = train_y_2[start:m] # Shuffle train data perm = np.arange(m) np.random.shuffle(perm) train_X = train_X[perm] train_y_1 = train_y_1[perm] train_y_2 = train_y_2[perm] # Start next epoch start = 0 index_in_epoch = n_batch_size - n_rest_data end = index_in_epoch train_X_batch_new = train_X[start:end] train_y_batch_new_1 = train_y_1[start:end] train_y_batch_new_2 = train_y_2[start:end] # concatenate train_X_batch = np.concatenate( (train_X_batch_rest, train_X_batch_new), axis=0) train_y_batch_1 = np.concatenate( (train_y_batch_rest_1, train_y_batch_new_1), axis=0) train_y_batch_2 = np.concatenate( (train_y_batch_rest_2, train_y_batch_new_2), axis=0) else: index_in_epoch += n_batch_size end = index_in_epoch train_X_batch = train_X[start:end] train_y_batch_1 = train_y_1[start:end] train_y_batch_2 = train_y_2[start:end] _, global_step_value, loss_total_value, summary_loss_total_value = \ sess.run([train_op, global_step, loss_total, summary_loss_total], feed_dict={X: standardization(train_X_batch), y_1: train_y_batch_1, y_2: train_y_batch_2, is_training: True}) if global_step_value % 100 == 0: accuracy_train_value, summary_accuracy_train_value = \ sess.run([accuracy, summary_accuracy_train], feed_dict={X: standardization(train_X_batch), y_1: train_y_batch_1, y_2: train_y_batch_2, is_training: False}) accuracy_test_value, summary_accuracy_test_value = \ sess.run([accuracy, summary_accuracy_test], feed_dict={X: normalized_test_X, y_1: test_y_1, y_2: test_y_2, is_training: False}) print(global_step_value, epoch, loss_total_value, accuracy_train_value, accuracy_test_value) # cross_stitches = tf.get_collection("cross_stitches") # print(cross_stitches[0].eval(sess)) f.add_summary(summary_loss_total_value, global_step=global_step_value) f.add_summary(summary_accuracy_train_value, global_step=global_step_value) f.add_summary(summary_accuracy_test_value, global_step=global_step_value) f.add_graph(sess.graph)
def get_optimistic_saver(ckpt_path, graph=tf.get_default_graph()): return tf.train.Saver( get_optimistic_restore_variables(ckpt_path, graph=graph))
num_epochs = 1 size_models = 16 activations = "tanh" rate = 5 result_file_path = 'result_encoder_decoder.csv' nor_data, amax, amin = data.get_goodletrace_data(path, aspects) x_train_encoder, y_train, x_test_encoder, y_test = data.get_data_samples( nor_data, n_slidings_encoder, predicted_aspect, rate) x_train_decoder, x_test_decoder = data.get_data_decoder( x_train_encoder, x_test_encoder, n_slidings_decoder) x_train_encoder, x_train_decoder, y_train, x_val_encoder, x_val_decoder, y_val = \ data.getValidationSet(x_train_encoder, x_train_decoder, y_train, 5) sess = tf.Session() path = 'model_encoder_decoder' encoder_saver = tf.train.import_meta_graph(path + '.meta') encoder_graph = tf.get_default_graph() X_encoder = encoder_graph.get_tensor_by_name('X_encoder:0') outputs_encoder = encoder_graph.get_tensor_by_name('outputs_encoder:0') last_output_encoder = outputs_encoder[:, -1, :] print(last_output_encoder.shape, outputs_encoder.shape) last_output_encoder = tf.reshape(last_output_encoder, (-1, last_output_encoder.shape[1])) print(last_output_encoder.shape) sliding_encoder = outputs_encoder.shape[1] encoder_saver.restore(sess=sess, save_path=path) outputs_encoder = sess.run(outputs_encoder, feed_dict={X_encoder: x_train_encoder}) print(outputs_encoder.shape)
import numpy as np import tensorflow as tf from shared import load_faces, reset_graph _, X_test, _, y_test = load_faces() reset_graph() saver = tf.train.import_meta_graph("./models/cnn/cnn.ckpt.meta") X = tf.get_default_graph().get_tensor_by_name("input/X:0") y = tf.get_default_graph().get_tensor_by_name("input/y:0") logits = tf.get_default_graph().get_tensor_by_name("cnn/outputs/dense/BiasAdd:0") with tf.Session() as sess: tf.global_variables_initializer().run() saver.restore(sess, "./models/cnn/cnn.ckpt") batch_size = 128 y_pred = np.zeros(len(X_test)) total_batch = len(X_test) // batch_size for i in range(total_batch): start = i * batch_size end = min((i + 1) * batch_size, len(X_test)) x_batch = X_test[start:end] y_batch = y_test[start:end] accuracy = sess.run(tf.argmax(logits, axis=1), feed_dict={X: x_batch, y: y_batch}) y_pred[start:end] = accuracy correct = (y_pred == y_test)
def main(argv=None): import os os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_list try: os.makedirs(FLAGS.output_dir) except OSError as e: if e.errno != 17: raise with tf.get_default_graph().as_default(): input_images = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_images') global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) f_score, f_geometry = model.model(input_images, is_training=False) variable_averages = tf.train.ExponentialMovingAverage( 0.997, global_step) saver = tf.train.Saver(variable_averages.variables_to_restore()) with tf.Session(config=tf.ConfigProto( allow_soft_placement=True)) as sess: ckpt_state = tf.train.get_checkpoint_state(FLAGS.checkpoint_path) model_path = os.path.join( FLAGS.checkpoint_path, os.path.basename(ckpt_state.model_checkpoint_path)) print('Restore from {}'.format(model_path)) saver.restore(sess, model_path) im_fn_list = get_images() for im_fn in im_fn_list: im = cv2.imread(im_fn)[:, :, ::-1] start_time = time.time() im_resized, (ratio_h, ratio_w) = resize_image(im) timer = {'net': 0, 'restore': 0, 'nms': 0} start = time.time() score, geometry = sess.run( [f_score, f_geometry], feed_dict={input_images: [im_resized]}) timer['net'] = time.time() - start boxes, timer = detect(score_map=score, geo_map=geometry, timer=timer) print( '{} : net {:.0f}ms, restore {:.0f}ms, nms {:.0f}ms'.format( im_fn, timer['net'] * 1000, timer['restore'] * 1000, timer['nms'] * 1000)) if boxes is not None: boxes = boxes[:, :8].reshape((-1, 4, 2)) boxes[:, :, 0] /= ratio_w boxes[:, :, 1] /= ratio_h duration = time.time() - start_time print('[timing] {}'.format(duration)) # save to file if boxes is not None: res_file = os.path.join( FLAGS.output_dir, '{}.txt'.format(os.path.basename(im_fn).split('.')[0])) with open(res_file, 'w') as f: for box in boxes: # to avoid submitting errors box = sort_poly(box.astype(np.int32)) if np.linalg.norm(box[0] - box[1]) < 5 or np.linalg.norm( box[3] - box[0]) < 5: continue f.write('{},{},{},{},{},{},{},{}\r\n'.format( box[0, 0], box[0, 1], box[1, 0], box[1, 1], box[2, 0], box[2, 1], box[3, 0], box[3, 1], )) cv2.polylines( im[:, :, ::-1], [box.astype(np.int32).reshape((-1, 1, 2))], True, color=(255, 255, 0), thickness=1) if not FLAGS.no_write_images: img_path = os.path.join(FLAGS.output_dir, os.path.basename(im_fn)) cv2.imwrite(img_path, im[:, :, ::-1])
correct = tf.equal(tf.argmax(predict, axis=1), tf.argmax(labels, axis=1)) total_correct = tf.reduce_sum(tf.cast(correct, tf.float32)) grads = tf.train.AdamOptimizer( learning_rate=0.01, beta1=0.9, beta2=0.999, epsilon=1).compute_gradients( loss=loss, var_list=[conv1, conv2, conv3, conv4, conv5, fc1, fc2, fc3]) # optimizer = tf.train.AdamOptimizer(learning_rate=0.01, beta1=0.9, beta2=0.999, epsilon=1).minimize(loss) optimizer = tf.train.GradientDescentOptimizer( learning_rate=0.01).minimize(loss) error = tf.subtract(tf.nn.softmax(fc3), labels) get_fc1_weights = tf.get_default_graph().get_tensor_by_name( os.path.split(fc1.name)[0] + '/kernel:0') get_fc1_bias = tf.get_default_graph().get_tensor_by_name( os.path.split(fc1.name)[0] + '/bias:0') get_fc2_weights = tf.get_default_graph().get_tensor_by_name( os.path.split(fc2.name)[0] + '/kernel:0') get_fc2_bias = tf.get_default_graph().get_tensor_by_name( os.path.split(fc2.name)[0] + '/bias:0') get_fc3_weights = tf.get_default_graph().get_tensor_by_name( os.path.split(fc3.name)[0] + '/kernel:0') get_fc3_bias = tf.get_default_graph().get_tensor_by_name( os.path.split(fc3.name)[0] + '/bias:0') get_conv1_weights = tf.get_default_graph().get_tensor_by_name( os.path.split(conv1.name)[0] + '/kernel:0')
def main(_): os.environ["CUDA_VISIBLE_DEVICES"] = str( FLAGS.gpu) # ----------which GPU is used----------- #modelDir = "./saveModel/model-750" # "./saveModel/model-750" https://blog.csdn.net/sjtuxx_lee/article/details/82663394 ---------------- saver = tf.train.import_meta_graph(args.modelDir + ".meta") graph = tf.get_default_graph() #tensor_name_list = [tensor.name for tensor in graph.as_graph_def().node] logits_lab = tf.get_collection( 'logits_lab_save' )[0] #------------------add for save and load model-------20191127------xiao------------ logits_ema = tf.get_collection( 'logits_ema_save' )[0] #------------------add for save and load model-------20191127------xiao------------ batch_size = tf.get_collection( 'batch_size_save' )[0] #------------------add for save and load model-------20191127------xiao------------ #dataDir = args.dataDir # csiFile = args.csiFile # labelFile = args.labelFile (testx, testy) = loadDataTest(args.dataDir, args.csiFile, args.labelFile) nr_batches_test = int(testx.shape[0] / batch_size) #----if testx.shape[0] modulo FLAGS.batch_size <> 0, there will be some samples to be left, here fill some samples to testX------begin------ #----for outputing full test samples------20191206----------- #print(testx.shape[0]/FLAGS.batch_size) modNumber = testx.shape[0] % batch_size if (modNumber != 0): testx2 = testx[0:batch_size - modNumber, :, :, :] testy2 = testy[0:batch_size - modNumber] #print(testx2.shape) testx = np.concatenate((testx, testx2), axis=0) testy = np.concatenate((testy, testy2), axis=0) #print(testx.shape) nr_batches_test += 1 #----if testx.shape[0] modulo batch_size <> 0, there will be some samples to be left, here fill some samples to testX------end-------- #print("Data:") print('test examples %d, batch %d' % (testx.shape[0], nr_batches_test)) print('histogram test ', np.histogram(testy, bins=10)[0]) print(testy) inp = graph.get_operation_by_name('labeled_data_input_pl').outputs[ 0] #inp=gragh.get_tensor_by_name('labeled_data_input_pl') lbl = graph.get_operation_by_name('lbl_input_pl').outputs[0] is_training_pl = graph.get_operation_by_name('is_training_pl').outputs[0] correct_pred = tf.equal(tf.cast(tf.argmax(logits_lab, 1), tf.int32), tf.cast(lbl, tf.int32)) accuracy_classifier = tf.reduce_mean(tf.cast(correct_pred, tf.float32)) y_predict = tf.cast(tf.argmax(logits_lab, 1), tf.int32) correct_pred_ema = tf.equal(tf.cast(tf.argmax(logits_ema, 1), tf.int32), tf.cast(lbl, tf.int32)) accuracy_ema = tf.reduce_mean(tf.cast(correct_pred_ema, tf.float32)) y_predict_ema = tf.cast(tf.argmax(logits_ema, 1), tf.int32) # --------added for computing entropy------xiao--------20191128-------begin------ #fopen = open(args.csiFile.replace('.mat','') + "_entropy", "w") #fopen_ema = open(args.csiFile.replace('.mat','') + "_entropy_ema", "w") fopen_entropy_ema = open( args.csiFile.replace('.mat', '') + "_entropy_ema", "w") softmax_out = tf.nn.softmax(logits_lab, name='softmax_out') softmax_out_ema = tf.nn.softmax(logits_ema, name='softmax_out_ema') # --------added for computing entropy------xiao--------20191128-------end-------- acc_all = acc_ema_all = f1_all = f1_ema_all = precsion_all = recall_all = 0 acc_all2 = acc_ema_all2 = f1_all2 = f1_ema_all2 = 0 #----for outputing full test samples------20191206----------- with tf.Session() as sess: begin = time.time() saver.restore( sess, args.modelDir ) #saver.restore(sess, tf.train.latest_checkpoint("./saveModel")) print('finish loading model!') for t in range(nr_batches_test): ran_from = t * batch_size ran_to = (t + 1) * batch_size feed_dict = { inp: testx[ran_from:ran_to], lbl: testy[ran_from:ran_to], is_training_pl: False } #acc, acc_ema,y_pred,y_pred_ema = sess.run([accuracy_classifier, accuracy_ema,y_predict,y_predict_ema], feed_dict=feed_dict) # correct without entropy # --------added for computing entropy------xiao--------20191128-------begin------ y_true = testy[ran_from:ran_to] acc, acc_ema, y_pred, y_pred_ema, softmax_entropy, softmax_entropy_ema = sess.run( [ accuracy_classifier, accuracy_ema, y_predict, y_predict_ema, softmax_out, softmax_out_ema ], feed_dict=feed_dict) # correct without entropy #print("softmax_out_entropy:" + str(softmax_out_entropy)) #----if testx.shape[0] modulo batch_size <> 0, there will be some samples to be left, here fill some samples to testX------begin------ entropyShape = softmax_entropy.shape[0] entropyShapeEma = softmax_entropy_ema.shape[0] if (modNumber != 0 and t == nr_batches_test - 1): entropyShape = modNumber entropyShapeEma = modNumber y_true = y_true[0:modNumber] y_pred = y_pred[0:modNumber] y_pred_ema = y_pred_ema[0:modNumber] #----if testx.shape[0] modulo batch_size <> 0, there will be some samples to be left, here fill some samples to testX------end-------- ''' for i in range(entropyShape): fopen.write(str(int(y_true[i])) + "\t" + str(y_pred[i]) + "\t" + '{:.4f}'.format(max(softmax_entropy[i])) + '\t') fopen.write(str('{:.4f}'.format(entropy(softmax_entropy[i])) ) + '\t') for j in range(softmax_entropy.shape[1]): fixFloat = '{:.4f}'.format(softmax_entropy[i][j]) fopen.write(str(fixFloat) + "\t") fopen.write("\n") for i in range(entropyShapeEma): fopen_ema.write(str(int(y_true[i])) + "\t" + str(y_pred_ema[i]) + "\t" + '{:.4f}'.format(max(softmax_entropy_ema[i])) + '\t') fopen_ema.write(str('{:.4f}'.format(entropy(softmax_entropy_ema[i])) ) + '\t') for j in range(softmax_entropy_ema.shape[1]): fixFloat = '{:.4f}'.format(softmax_entropy_ema[i][j]) fopen_ema.write(str(fixFloat) + "\t") fopen_ema.write("\n") #for i in range(entropyShapeEma): # fopen_ema.write(str(int(y_true[i])) + "\t" + str(y_pred_ema[i]) + "\t" + '{:.4f}'.format(max(softmax_entropy_ema[i])) ) # fopen_ema.write("\n") ''' for i in range(entropyShapeEma): aa = 1 - entropy(softmax_entropy_ema[i]) #print(aa) if (aa < 0): aa = 0.0001 #fopen_entropy_ema.write(str('{:.4f}'.format(entropy(softmax_entropy_ema[i])) ) + '\n') #fopen_entropy_ema.write(str('{:.4f}'.format(aa) ) + '\n') #fopen_entropy_ema.write(str('{:.4f}'.format(max(softmax_entropy_ema[i])) ) + '\n') for i in range(entropyShapeEma): fopen_entropy_ema.write( str(y_pred_ema[i] + 1) + "\t" + '{:.4f}'.format(max(softmax_entropy_ema[i])) + "\t" + str('{:.4f}'.format(entropy(softmax_entropy_ema[i]))) + "\t" + str(y_pred[i] + 1) + "\t" + '{:.4f}'.format(max(softmax_entropy[i])) + "\t" + str('{:.4f}'.format(entropy(softmax_entropy[i]))) + "\t" + str(y_true[i] + 1) + "\n") # --------added for computing entropy------xiao--------20191128-------end-------- acc2 = metrics.accuracy_score( y_true, y_pred ) #----for outputing full test samples------20191206----------- acc2_ema = metrics.accuracy_score( y_true, y_pred_ema ) #----for outputing full test samples------20191206----------- #print('acc:' + str(acc) + '\t' + 'acc2:' + str(acc2)) #print('acc_ema:' + str(acc_ema) + '\t' + 'acc2_ema:' + str(acc2_ema)) f1 = metrics.f1_score(y_true, y_pred, average="weighted") # weighted macro micro f1_ema = metrics.f1_score(y_true, y_pred_ema, average="weighted") # precsion = metrics.precision_score(y_true, y_pred, average="micro") recall = metrics.recall_score(y_true, y_pred, average="micro") acc_all2 += acc2 #----for outputing full test samples------20191206----------- f1_all2 += f1 acc_ema_all2 += acc2_ema f1_ema_all2 += f1_ema #----for outputing full test samples------20191206----------- if ( not (modNumber != 0 and t == nr_batches_test - 1) ): #----for outputing full test samples------20191206----------- acc_all += acc # excluding the last epoch if testx.shape[0]%batch_size <> 0 acc_ema_all += acc_ema # to keep the same with train result f1_all += f1 f1_ema_all += f1_ema precsion_all += precsion recall_all += recall nr_batches_test2 = nr_batches_test #----for outputing full test samples------20191206----------- if (modNumber != 0 ): #----for outputing full test samples------20191206----------- nr_batches_test -= 1 acc_all2 /= nr_batches_test2 #----for outputing full test samples------20191206----------- f1_all2 /= nr_batches_test2 #----for outputing full test samples------20191206----------- acc_ema_all2 /= nr_batches_test2 #----for outputing full test samples------20191206----------- f1_ema_all2 /= nr_batches_test2 #----for outputing full test samples------20191206----------- acc_all /= nr_batches_test acc_ema_all /= nr_batches_test f1_all /= nr_batches_test f1_ema_all /= nr_batches_test precsion_all /= nr_batches_test recall_all /= nr_batches_test #print("%ds testAcc=%.2f testF1=%0.2f testAccE=%0.2f testF1E=%0.2f" # % (time.time()-begin, acc_all*100,f1_all*100,acc_ema_all*100,f1_ema_all*100)) print( "%ds --------NoLastEpoch: testAcc =%.2f testF1 =%0.2f testAccE =%0.2f testF1E =%0.2f \n \ allData: testAcc2=%0.2f testF12=%0.2f testAcc2E=%0.2f testF12E=%0.2f" % (time.time() - begin, acc_all * 100, f1_all * 100, acc_ema_all * 100, f1_ema_all * 100, acc_all2 * 100, f1_all2 * 100, acc_ema_all2 * 100, f1_ema_all2 * 100)) # acc_all is the result excluding the last epoch if testx.shape[0]%batch_size <> 0 # acc_all2 is the result including all the epoches fopen_entropy_ema.close() #----------normalize entropy-----------------begin---------20191216---------------- '''