def main(_): if not FLAGS.output_file: raise ValueError( 'You must supply the path to save to with --output_file') tf.logging.set_verbosity(tf.logging.INFO) with tf.Graph().as_default() as graph: shape = input_size shape = (int(shape[0]), int(shape[1]), int(shape[2])) img_input = tf.placeholder(name='input_tensor', dtype=tf.float32, shape=(None, input_size[1], input_size[0], int(shape[2]))) img_input = img_input * (1. / 255) - 0.5 batch_input = tf.placeholder(name='input_batch_size', dtype=tf.int32, shape=()) #img_4d = tf.expand_dims(img_input, 0) print(img_input) # Create network. crnn_params = model.CRNNNet.default_params._replace( imgH=input_size[1])._replace( seq_length=SEQ_LEN) # ,seq_length=int(width/4+1) crnn = model.CRNNNet(crnn_params) logits, inputs, seq_len, W, b = crnn.net(img_input, batch_input) decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False) indices = tf.cast(decoded[0].indices, tf.int32, name='sparse_tensor_indices') values = tf.cast(decoded[0].values, tf.int32, name='sparse_tensor_values') dense_shape = tf.cast(decoded[0].dense_shape, tf.int32, name='sparse_tensor_shape') print(indices, values, dense_shape) tf.constant(shape, name='input_plate_size') tf.constant(alphabet, dtype=tf.string, name='alphabet') print(alphabet) tf.constant(["sparse_tensor"], name="output_names") tf.constant(['input_tensor'], name='input_name') graph_def = graph.as_graph_def() with gfile.GFile(FLAGS.output_file, 'wb') as f: f.write(graph_def.SerializeToString()) print('Successfull written to', FLAGS.output_file)
def load_from_checkpoint(shape, checkpoint_dir): #width_input = tf.placeholder(tf.int32, shape=()) img_input = tf.placeholder(tf.float32, shape=(None, shape[1], shape[0], shape[2])) input_batch = tf.placeholder(tf.int32, shape=()) img_input = img_input * (1. / 255) - 0.5 #img_4d = tf.expand_dims(img_input, 0) # define the crnn net SEQ_LEN = int(shape[0]/4+1) crnn_params = model.CRNNNet.default_params._replace(seq_length = SEQ_LEN)._replace(imgH = shape[1]) # ,seq_length=int(width/4+1) crnn = model.CRNNNet(crnn_params) logits, inputs, seq_len, W, b = crnn.net(img_input, input_batch) decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False) val_predict = tf.cast(decoded[0], tf.int32) saver = tf.train.Saver() sess = tf.Session() dir = tf.train.latest_checkpoint(checkpoint_dir) saver.restore(sess, dir) sess.run(tf.local_variables_initializer()) print("Model restore!") return sess, val_predict, img_input, input_batch
def main(_): tf.logging.set_verbosity(tf.logging.DEBUG)#设置显示的log的阈值 with tf.Graph().as_default(): deploy_config = model_deploy.DeploymentConfig() # Create global_step. global_step = tf.Variable(0,name='global_step',trainable=False) file_name = os.path.join("./tfrecord", "mjtrain_690_999.tfrecords") starter_learning_rate = 0.1 learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 100000, 0.96, staircase=True) tf.summary.scalar("learning_rate",learning_rate) sh_images, sh_labels, sh_length= read_utils.inputs( filename = file_name,batch_size=batch_size, num_epochs=num_epochs) crnn = model.CRNNNet() logits, inputs, seq_len, W, b = crnn.net(sh_images) cost = crnn.losses(sh_labels,logits, seq_len) optimizer = tf.train.AdadeltaOptimizer(learning_rate = learning_rate).minimize(loss=cost,global_step=global_step) tf.summary.scalar("cost",cost) decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False) acc = tf.reduce_mean(tf.edit_distance(tf.cast(decoded[0], tf.int32), sh_labels)) tf.summary.scalar("edit_distance",acc) sess = tf.Session() save = tf.train.Saver(max_to_keep=2) if tf.train.latest_checkpoint(checkpoint_dir) is None: init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) # Start input enqueue threads. else: save.restore(sess,tf.train.latest_checkpoint(checkpoint_dir)) sess.run(tf.local_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) #sess = tf_debug.LocalCLIDebugWrapperSession(sess) merged = tf.summary.merge_all() file_writer = tf.summary.FileWriter('./tmp/my-model', sess.graph) try: step = global_step while not coord.should_stop(): start_time = time.time() _,merged_t,val_cost, val_ler, lr, step = sess.run([optimizer,merged,cost, acc, learning_rate, global_step]) duration = time.time() - start_time print("cost", val_cost) file_writer.add_summary(merged_t,step) # Print an overview fairly often. if step % 10 == 0: print('Step %d: acc %.3f (%.3f sec)' % (step,val_ler,duration)) save.save(sess,"./tmp/crnn-model.ckpt",global_step = global_step) step += 1 except tf.errors.OutOfRangeError: print('Done training for %d epochs, %d steps.' % (num_epochs, step)) finally: # When done, ask the threads to stop. coord.request_stop() # Wait for threads to finish. coord.join(threads) sess.close()
# first load image and label image_raw, width = load_image(img_dir, crop_size=input_size) label = load_label_from_img_dir(img_dir) label = label.lower() return image_raw, label, width batch_input = tf.placeholder(tf.int32, shape=()) img_input = tf.placeholder(tf.float32, shape=(input_size[1], input_size[0], 1)) img_input = img_input * (1. / 255) - 0.5 img_4d = tf.expand_dims(img_input, 0) # define the crnn net #crnn_params = model.CRNNNet.default_params._replace(batch_size=1)._replace(seq_length = SEQ_LEN)._replace(imgH = input_size[1]) # ,seq_length=int(width/4+1) crnn_params = crnn_params._replace(batch_size=1) crnn = model.CRNNNet(crnn_params) logits, inputs, seq_len, W, b = crnn.net(img_4d, batch_input) decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False) val_predict = tf.cast(decoded[0], tf.int32) saver = tf.train.Saver() sess = tf.Session() dir = tf.train.latest_checkpoint(checkpoint_dir) saver.restore(sess, dir) sess.run(tf.local_variables_initializer()) print("Model restore!")
def run(): tf.logging.set_verbosity(tf.logging.DEBUG) with tf.Graph().as_default(): deploy_config = model_deploy.DeploymentConfig() # Create global_step global_step = tf.Variable(0, name='global_step', trainable=False) file_name = os.path.join("dataset/data", "train2.tfrecords") train_images, train_labels, train_path = read_utils.inputs( filename=file_name, batch_size=batch_size, num_epochs=num_epochs, crop_size=model_size) coord = tf.train.Coordinator() crnn = model.CRNNNet(crnn_params) logits, inputs, seq_len, W, b = crnn.net(train_images) cost = crnn.losses(train_labels, logits, seq_len) learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 2000, 0.9, staircase=True) tf.summary.scalar("learning_rate", learning_rate) #optimizer = tf.train.AdadeltaOptimizer(learning_rate = learning_rate).minimize(loss=cost,global_step=global_step) optimizer = tf.train.RMSPropOptimizer( learning_rate=learning_rate).minimize(loss=cost, global_step=global_step) tf.summary.scalar("cost", cost) decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False) pred = tf.cast(decoded[0], tf.int32) acc = tf.reduce_mean(tf.edit_distance(pred, train_labels)) tf.summary.scalar("edit_distance", acc) ################################## sess = tf.Session() save = tf.train.Saver(max_to_keep=20) if tf.train.latest_checkpoint(checkpoint_dir) is None: init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) # Start input enqueue threads. else: save.restore(sess, tf.train.latest_checkpoint(checkpoint_dir)) sess.run(tf.local_variables_initializer()) threads = tf.train.start_queue_runners(sess=sess, coord=coord) #sess = tf_debug.LocalCLIDebugWrapperSession(sess) merged = tf.summary.merge_all() file_writer = tf.summary.FileWriter(checkpoint_dir + 'my-model', sess.graph) ################################## try: step = global_step while not coord.should_stop(): start_time = time.time() _, merged_t, train_cost, train_accuracy, lr, step, val_lbls, val_pred, paths = sess.run( [ optimizer, merged, cost, acc, learning_rate, global_step, train_labels, pred, train_path ]) duration = time.time() - start_time print("## Step: %d Cost: %.3f" % (step, train_cost)) # Print an overview fairly often. if step % 10 == 0: str_gt = sparse_tensor_to_str(val_lbls) str_pred = sparse_tensor_to_str(val_pred) for i in range(num_to_show): print(" true: ", str_gt[i], " result: ", str_pred[i], " img_path: ", paths[i]) print('Step: %d train_acc: %.3f (%.3f sec)' % (step, train_accuracy, duration)) print('Current lr: %.8f' % lr) if step % 100 == 0: save.save(sess, checkpoint_dir + "crnn-model.ckpt", global_step=global_step) file_writer.add_summary(merged_t, step) step += 1 except tf.errors.OutOfRangeError: print('Done training for %d epochs, %d steps.' % (num_epochs, step)) finally: # When done, ask the threads to stop. coord.request_stop() # Wait for threads to finish. coord.join(threads) sess.close()
def main(_): tf.logging.set_verbosity(tf.logging.DEBUG) #设置显示的log的阈值 with tf.Graph().as_default(): # Config model_deploy. Keep TF Slim Models structure. # Useful if want to need multiple GPUs and/or servers in the future. deploy_config = model_deploy.DeploymentConfig() # Create global_step. with tf.device(deploy_config.variables_device()): global_step = slim.create_global_step() file_name = os.path.join("../tfrecord", "train.tfrecords") def read_and_decode(filename, num_epochs): # read iris_contact.tfrecords filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs) reader = tf.TFRecordReader() print(filename_queue) _, serialized_example = reader.read( filename_queue) # return file_name and file features = tf.parse_single_example( serialized_example, features={ 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), # 三个参数:shape,type,default_value 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/shape': tf.FixedLenFeature([2], tf.int64), 'label': tf.FixedLenFeature((), tf.string, default_value='unknow'), 'index': tf.FixedLenFeature([1], tf.int64) }) # return image and label # img = tf.decode_raw(features['image/encoded'], tf.uint8) img = tf.image.decode_jpeg(features['image/encoded']) shape = features["image/shape"] img = tf.reshape(img, [32, 100, 3]) # reshape image to 512*80*3 img = tf.cast(img, tf.float32) * (1. / 255) - 0.5 # throw img tensor label = features['label'] # throw label tensor index = features["index"] return img, label, shape, index def preprocess(image_raw): image = tf.image.decode_jpeg(tf.image.encode_jpeg(image_raw)) return resize_image(image, (100, 32)) def inputs(batch_size, num_epochs, filename): """Reads input data num_epochs times. Args: train: Selects between the training (True) and validation (False) data. batch_size: Number of examples per returned batch. num_epochs: Number of times to read the input data, or 0/None to train forever. Returns: A tuple (images, labels), where: * images is a float tensor with shape [batch_size, mnist.IMAGE_PIXELS] in the range [-0.5, 0.5]. * labels is an int32 tensor with shape [batch_size] with the true label, a number in the range [0, mnist.NUM_CLASSES). Note that an tf.train.QueueRunner is added to the graph, which must be run using e.g. tf.train.start_queue_runners(). """ if not num_epochs: num_epochs = None #filename = os.path.join(file_dir) with tf.name_scope('input'): # Even when reading in multiple threads, share the filename # queue. image, label, shape, index = read_and_decode( filename, num_epochs) #image = preprocess(image) # Shuffle the examples and collect them into batch_size batches. # (Internally uses a RandomShuffleQueue.) # We run this in two threads to avoid being a bottleneck. images, shuffle_labels, sshape, sindex = tf.train.shuffle_batch( [image, label, shape, index], batch_size=batch_size, num_threads=2, capacity=1000 + 3 * batch_size, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=100) return images, shuffle_labels, sshape, sindex with tf.Graph().as_default(): # Input images and labels. starter_learning_rate = 0.1 learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 100000, 0.96, staircase=True) images, shuffle_labels, sshape, sindex = inputs( filename=file_name, batch_size=batch_size, num_epochs=num_epochs) crnn = model.CRNNNet() logits, inputs, seq_len, W, b = crnn.net(images) shuffle_labels = ['123456', '123', '12342'] labels = shuffle_labels def sparse_tuple_from(sequences, dtype=np.int32): """Create a sparse representention of x. Args: sequences: a list of lists of type dtype where each element is a sequence Returns: A tuple with (indices, values, shape) """ indices = [] values = [] for n, seq in enumerate(sequences): indices.extend(zip([n] * len(seq), range(len(seq)))) values.extend(seq) indices = np.asarray(indices, dtype=np.int64) values = np.asarray(values, dtype=dtype) shape = np.asarray( [len(sequences), np.asarray(indices).max(0)[1] + 1], dtype=np.int64) return indices, values, shape sparse_labels = sparse_tuple_from(labels) cost = crnn.losses(sparse_labels, logits, seq_len) optimizer = tf.train.AdadeltaOptimizer( learning_rate=learning_rate).minimize(loss=cost, global_step=global_step) # Option 2: tf.contrib.ctc.ctc_beam_search_decoder # (it's slower but you'll get better results) decoded, log_prob = tf.nn.ctc_beam_search_decoder( logits, seq_len, merge_repeated=False) # Accuracy: label error rate acc = tf.reduce_mean( tf.edit_distance(tf.cast(decoded[0], tf.int32), sparse_labels)) sess = tf.Session() init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) # Start input enqueue threads. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) #sess = tf_debug.LocalCLIDebugWrapperSession(sess) try: step = 0 while not coord.should_stop(): start_time = time.time() # Run one step of the model. The return values are # the activations from the `train_op` (which is # discarded) and the `loss` op. To inspect the values # of your ops or variables, you may include them in # the list passed to sess.run() and the value tensors # will be returned in the tuple from the call. #timages, tsparse_labels, tsshape, tsindex = sess.run([images, sparse_labels, sshape, sindex]) val_cost, val_ler, lr, step = sess.run( [cost, acc, learning_rate, global_step]) duration = time.time() - start_time print(val_cost) # Print an overview fairly often. if step % 10 == 0: print('Step %d: (%.3f sec)' % (step, duration)) step += 1 except tf.errors.OutOfRangeError: print('Done training for %d epochs, %d steps.' % (num_epochs, step)) finally: # When done, ask the threads to stop. coord.request_stop() # Wait for threads to finish. coord.join(threads) sess.close()