def main(_): if not tf.gfile.Exists(FLAGS.eval_log_dir): tf.gfile.MakeDirs(FLAGS.eval_log_dir) dataset = common_flags.create_dataset(FLAGS.dataset_name, FLAGS.dataset_split_name) model = common_flags.create_model(num_classes=FLAGS.num_classes) data = data_provider.get_data(dataset, FLAGS.model_name, FLAGS.batch_size, is_training=False, height=FLAGS.height, width=FLAGS.width) logits, endpoints = model.create_model(data.images, num_classes=FLAGS.num_classes, is_training=False) eval_ops = model.create_summary(data, logits, is_training=False) slim.get_or_create_global_step() session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True slim.evaluation.evaluation_loop( master=FLAGS.master, checkpoint_dir=FLAGS.train_dir, logdir=FLAGS.eval_log_dir, eval_op=eval_ops, num_evals=FLAGS.num_evals, eval_interval_secs=FLAGS.eval_interval_secs, max_number_of_evaluations=FLAGS.number_of_steps, session_config=session_config)
def main(_): prepare_training_dir() dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. device_setter = tf.train.replica_device_setter(FLAGS.ps_tasks, merge_devices=True) with tf.device(device_setter): data = data_provider.get_data( dataset, FLAGS.batch_size, augment=hparams.use_augment_input, central_crop_size=common_flags.get_crop_size()) endpoints = model.create_base(data.images, data.labels_one_hot) total_loss = model.create_loss(data, endpoints) model.create_summaries(data, endpoints, dataset.charset, is_training=True) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint, FLAGS.checkpoint_inception) if FLAGS.show_graph_stats: tf.logging.info('Total number of weights in the graph: %s', calculate_graph_metrics()) train(total_loss, init_fn, hparams)
def main(_): if not tf.gfile.Exists(FLAGS.eval_log_dir): tf.gfile.MakeDirs(FLAGS.eval_log_dir) dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) data = data_provider.get_data( dataset, FLAGS.batch_size, augment=False, central_crop_size=common_flags.get_crop_size()) endpoints = model.create_base(data.images, labels_one_hot=None) model.create_loss(data, endpoints) eval_ops = model.create_summaries(data, endpoints, dataset.charset, is_training=False) slim.get_or_create_global_step() session_config = tf.ConfigProto(device_count={"GPU": 0}) ### session_config.gpu_options.allow_growth = True session_config.log_device_placement = False ### slim.evaluation.evaluation_loop( master=FLAGS.master, checkpoint_dir=FLAGS.train_log_dir, logdir=FLAGS.eval_log_dir, eval_op=eval_ops, num_evals=FLAGS.num_batches, eval_interval_secs=FLAGS.eval_interval_secs, max_number_of_evaluations=1, session_config=session_config)
def main(_): if not tf.gfile.Exists(FLAGS.eval_log_dir): tf.gfile.MakeDirs(FLAGS.eval_log_dir) dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) data = data_provider.get_data( dataset, FLAGS.batch_size, augment=False, central_crop_size=common_flags.get_crop_size()) print("JIBIRI!") print(data.images) endpoints = model.create_base(data.images, labels_one_hot=None) model.create_loss(data, endpoints) eval_ops = model.create_summaries(data, endpoints, dataset.charset, is_training=False) slim.get_or_create_global_step() session_config = tf.ConfigProto(device_count={"GPU": 0}) checkpoint_path = "%s/model.ckpt-90482" % FLAGS.train_log_dir eval_result = slim.evaluation.evaluate_once( master=FLAGS.master, checkpoint_path=checkpoint_path, logdir=FLAGS.eval_log_dir, eval_op=eval_ops, session_config=session_config)
def initial(self): dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code, charset=dataset.charset) data = data_provider.get_data( dataset, FLAGS.batch_size, augment=False, central_crop_size=common_flags.get_crop_size()) self.image_height = int(data.images.shape[1]) self.image_width = int(data.images.shape[2]) self.image_channel = int(data.images.shape[3]) self.num_of_view = dataset.num_of_views placeholder_shape = (1, self.image_height, self.image_width, self.image_channel) print placeholder_shape self.placeholder = tf.placeholder(tf.float32, shape=placeholder_shape) self.endpoint = model.create_base(self.placeholder, labels_one_hot=None) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint) self.sess = tf.Session(config=config) tf.tables_initializer().run(session=self.sess) init_fn(self.sess)
def main(_): prepare_training_dir() logging.info('dataset_name: {}, split_name: {}'.format( FLAGS.dataset_name, FLAGS.dataset_split_name)) dataset = common_flags.create_dataset(FLAGS.dataset_name, FLAGS.dataset_split_name) model = common_flags.create_model(num_classes=FLAGS.num_classes) data = data_provider.get_data(dataset, FLAGS.model_name, batch_size=FLAGS.batch_size, is_training=True, height=FLAGS.height, width=FLAGS.width) logits, endpoints = model.create_model(data.images, num_classes=dataset.num_classes, weight_decay=FLAGS.weight_decay, is_training=True) total_loss = model.create_loss(logits, endpoints, data.labels_one_hot, FLAGS.label_smoothing) model.create_summary(data, logits, is_training=True) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint_path, FLAGS.checkpoint_inception, FLAGS.checkpoint_exclude_scopes) variables_to_train = model.get_variables_to_train(FLAGS.trainable_scopes) if FLAGS.show_graph_state: logging.info('Total number of weights in the graph: %s', utils.calculate_graph_metrics()) train(total_loss, init_fn, variables_to_train)
def main(_): if not tf.gfile.Exists(FLAGS.eval_log_dir): tf.gfile.MakeDirs(FLAGS.eval_log_dir) dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) data = data_provider.get_data( dataset, FLAGS.batch_size, augment=False, central_crop_size=common_flags.get_crop_size()) endpoints = model.create_base(data.images, labels_one_hot=None) model.create_loss(data, endpoints) eval_ops = model.create_summaries( data, endpoints, dataset.charset, is_training=False) slim.get_or_create_global_step() session_config = tf.ConfigProto(device_count={"GPU": 0}) slim.evaluation.evaluation_loop( master=FLAGS.master, checkpoint_dir=FLAGS.train_log_dir, logdir=FLAGS.eval_log_dir, eval_op=eval_ops, num_evals=FLAGS.num_batches, eval_interval_secs=FLAGS.eval_interval_secs, max_number_of_evaluations=FLAGS.number_of_steps, session_config=session_config)
def main(_): prepare_training_dir() num_char_classes = 74 max_sequence_length = 37 num_of_views = 4 null_code = 2 model = common_flags.create_model(num_char_classes, max_sequence_length, num_of_views,null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. device_setter = tf.train.replica_device_setter( FLAGS.ps_tasks, merge_devices=True) with tf.device(device_setter): images_orig = tf.placeholder(tf.float32, [32, 150, 600,3], name='image_orig') labels = tf.placeholder(tf.int32, [32,37, ], name='label') data = data_provider.get_data( images_orig,labels, num_of_views, num_char_classes) #augment=hparams.use_augment_input, #central_crop_size=None) endpoints = model.create_base(data.images,data.labels_one_hot) saver = tf.train.Saver() with tf.Session() as sess: tf.global_variables_initializer().run() saver.restore(sess,'./trained/my-model-240') filelist = os.listdir('./real_train') # print(filelist[:10]) rates = list() for num in range(20): images = list() for i in range(32): image = np.resize(np.array(Image.open(os.path.join('./real_train',filelist[i+32*num]))),(150,600,3)) images.append(image) images = np.array(images) y = np.array(np.random.randint(10, size=[32,37, ]), dtype=np.int32) result = sess.run(endpoints.predicted_chars,feed_dict={images_orig:images,labels:y}) f = open('./vocab.txt') line = f.readline() f.close() rate = 0 for i in range(32): words = idx_to_words(list(result[i])) # print(filelist[i][:-4]) # print(''.join(words)) rate += distance.levenshtein(filelist[i+32*num][:-4],words)/float(len(filelist[i+32*num][:-4])) rate = 1 - float(rate) / 32 # print(rate) rates.append(rate) print(sum(rates)/20)
def load_model(checkpoint, batch_size, dataset_name): width, height = get_dataset_image_size(dataset_name) dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model( num_char_classes=dataset.num_char_classes, seq_length=dataset.max_sequence_length, num_views=dataset.num_of_views, null_code=dataset.null_code, charset=dataset.charset) images_placeholder = tf.placeholder(tf.float32, shape=[batch_size, height, width, 3]) endpoints = model.create_base(images_placeholder, labels_one_hot=None) init_fn = model.create_init_fn_to_restore(checkpoint) return images_placeholder, endpoints, init_fn
def create_model(batch_size, dataset_name): width, height = get_dataset_image_size(dataset_name) dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model( num_char_classes=dataset.num_char_classes, seq_length=dataset.max_sequence_length, num_views=dataset.num_of_views, null_code=dataset.null_code, charset=dataset.charset) raw_images = tf.placeholder(tf.uint8, shape=[batch_size, height, width, 3]) images = tf.map_fn(data_provider.preprocess_image, raw_images, dtype=tf.float32) endpoints = model.create_base(images, labels_one_hot=None) return raw_images, endpoints
def main(_): dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) raw_images = tf.placeholder( dtype=tf.uint8, shape=[1, 50, 750, 3]) # fix here (batch_size, height, width, channel) images = tf.map_fn(data_provider.preprocess_image, raw_images, dtype=tf.float32) endpoints = model.create_base(images, labels_one_hot=None) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, FLAGS.checkpoint) print(raw_images, endpoints.predicted_chars) tf.train.write_graph(sess.graph_def, '.', 'train.pbtxt') saver.save(sess, 'ckpt/model')
def main(_): dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code, charset=dataset.charset) data = data_provider.get_data( dataset, FLAGS.batch_size, augment=False, central_crop_size=common_flags.get_crop_size()) input_image = Image.open(FLAGS.input_image).convert("RGB").resize((data.images.shape[2] / dataset.num_of_views, data.images.shape[1])) input_array = np.array(input_image).astype(np.float32) #input_array = np.concatenate((input_array, input_array, input_array, input_array), axis=1) #Image.fromarray(input_array.astype(np.uint8), "RGB").save("test_input_1.jpg") input_array = np.expand_dims(input_array, axis=0) print input_array.shape print input_array.dtype #input_image.save("test_input.jpg") #return placeholder_shape = (1, data.images.shape[1], data.images.shape[2], data.images.shape[3]) print placeholder_shape image_placeholder = tf.placeholder(tf.float32, shape=placeholder_shape) endpoints = model.create_base(image_placeholder, labels_one_hot=None) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint) with tf.Session() as sess: tf.tables_initializer().run() # required by the CharsetMapper init_fn(sess) predictions = sess.run(endpoints.predicted_text, feed_dict={image_placeholder: input_array}) print("Predicted strings:") for line in predictions: print(line)
def main(_): # 检查训练目录 prepare_training_dir() # 建立数据集 split_name: train test dataset = common_flags.create_dataset(split_name=FLAGS.split_name) # 建立模型 max_sequence_length: 37, num_of_views: 4, null_code:133 # 这里还没有创建模型,只是返回了模型类,和初始化了模型相关参数 model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. device_setter = tf.train.replica_device_setter(FLAGS.ps_tasks, merge_devices=True) with tf.device(device_setter): # 获得训练数据 data = data_provider.get_data( dataset, FLAGS.batch_size, augment=hparams.use_augment_input, central_crop_size=common_flags.get_crop_size()) # 打印 dataset 的数据,看一下 # print("#######################") # print("images:", data.images) # print("labels:", data.labels) # print(dir(data.labels)) # print("labels_one_hot:", data.labels_one_hot.shape) # print("labels_0:", data.labels[0]) # print("labels_one_host_0:", data.labels_one_hot[0]) # print("#######################") # init = tf.global_variables_initializer() # with tf.Session() as session: # session.run(init) # coord = tf.train.Coordinator() # threads = tf.train.start_queue_runners(coord=coord) # labels = session.run(data.labels) # print(labels[0]) # labels = session.run(data.labels_one_hot) # print(labels[0]) # coord.request_stop() # coord.join(threads) # return # 创建模型 endpoints = model.create_base(data.images, data.labels_one_hot) # 创建损失函数 total_loss = model.create_loss(data, endpoints) model.create_summaries(data, endpoints, dataset.charset, is_training=True) # 恢复数据 init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint, FLAGS.checkpoint_inception) if FLAGS.show_graph_stats: logging.info('Total number of weights in the graph: %s', calculate_graph_metrics()) train(total_loss, init_fn, hparams)
def export_model(export_dir, export_for_serving, batch_size=None, crop_image_width=None, crop_image_height=None): """Exports a model to the named directory. Note that --datatset_name and --checkpoint are required and parsed by the underlying module common_flags. Args: export_dir: The output dir where model is exported to. export_for_serving: If True, expects a serialized image as input and attach image normalization as part of exported graph. batch_size: For non-serving export, the input batch_size needs to be specified. crop_image_width: Width of the input image. Uses the dataset default if None. crop_image_height: Height of the input image. Uses the dataset default if None. Returns: Returns the model signature_def. """ # Dataset object used only to get all parameters for the model. dataset = common_flags.create_dataset(split_name='test') model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code, charset=dataset.charset) dataset_image_height, dataset_image_width, image_depth = dataset.image_shape # Add check for charmap file if not os.path.exists(dataset.charset_file): raise ValueError('No charset defined at {}: export will fail'.format( dataset.charset)) # Default to dataset dimensions, otherwise use provided dimensions. image_width = crop_image_width or dataset_image_width image_height = crop_image_height or dataset_image_height if export_for_serving: images_orig = tf.placeholder(tf.string, shape=[batch_size], name='tf_example') images_orig_float = model_export_lib.generate_tfexample_image( images_orig, image_height, image_width, image_depth, name='float_images') else: images_shape = (batch_size, image_height, image_width, image_depth) images_orig = tf.placeholder(tf.uint8, shape=images_shape, name='original_image') images_orig_float = tf.image.convert_image_dtype(images_orig, dtype=tf.float32, name='float_images') endpoints = model.create_base(images_orig_float, labels_one_hot=None) sess = tf.Session() saver = tf.train.Saver(slim.get_variables_to_restore(), sharded=True) saver.restore(sess, get_checkpoint_path()) tf.logging.info('Model restored successfully.') # Create model signature. if export_for_serving: input_tensors = { tf.saved_model.signature_constants.CLASSIFY_INPUTS: images_orig } else: input_tensors = {'images': images_orig} signature_inputs = model_export_lib.build_tensor_info(input_tensors) # NOTE: Tensors 'image_float' and 'chars_logit' are used by the inference # or to compute saliency maps. output_tensors = { 'images_float': images_orig_float, 'predictions': endpoints.predicted_chars, 'scores': endpoints.predicted_scores, 'chars_logit': endpoints.chars_logit, 'predicted_length': endpoints.predicted_length, 'predicted_text': endpoints.predicted_text, 'predicted_conf': endpoints.predicted_conf, 'normalized_seq_conf': endpoints.normalized_seq_conf } for i, t in enumerate( model_export_lib.attention_ocr_attention_masks( dataset.max_sequence_length)): output_tensors['attention_mask_%d' % i] = t signature_outputs = model_export_lib.build_tensor_info(output_tensors) signature_def = tf.saved_model.signature_def_utils.build_signature_def( signature_inputs, signature_outputs, tf.saved_model.signature_constants.CLASSIFY_METHOD_NAME) # Save model. builder = tf.saved_model.builder.SavedModelBuilder(export_dir) builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING], signature_def_map={ tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature_def }, main_op=tf.tables_initializer(), strip_default_attrs=True) builder.save() tf.logging.info('Model has been exported to %s' % export_dir) return signature_def
def main(_): prepare_training_dir() num_char_classes = 3215 #less than 37 max_sequence_length = 37 num_of_views = 4 # null_code = 42 null_code = 2 model = common_flags.create_model(num_char_classes, max_sequence_length, num_of_views, null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. device_setter = tf.train.replica_device_setter(FLAGS.ps_tasks, merge_devices=True) with tf.device(device_setter): images_orig = tf.placeholder(tf.float32, [32, 150, 600, 3], name='image_orig') labels = tf.placeholder(tf.int32, [ 32, max_sequence_length, ], name='label') data = data_provider.get_data(images_orig, labels, num_of_views, num_char_classes) # augment=hparams.use_augment_input, # central_crop_size=None) endpoints = model.create_base(data.images, data.labels_one_hot) total_loss = model.create_loss(labels, endpoints) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint, FLAGS.checkpoint_inception) train_op = train(total_loss, init_fn, hparams) saver = tf.train.Saver() with tf.Session() as sess: tf.global_variables_initializer().run() filelist = os.listdir('./chinese_data/ad_flag') f = open('./chinese_data/chinese_vocab.txt') char_list = f.readline() f.close() count = 0 for epoch in range(10): random.shuffle(filelist) for step in range(len(filelist) / 32): count += 1 images_permutation, labels_permutation = handle_data( filelist[step * 32:(step + 1) * 32], char_list) result, loss, _ = sess.run( [endpoints.predicted_chars, total_loss, train_op], feed_dict={ images_orig: images_permutation, labels: labels_permutation }) if step % 2 == 0: print(loss) target = labels_permutation leven_distance = list() for h_shape in range(result.shape[0]): tmp_result = list(result[h_shape]) target_result = list(target[h_shape]) target_start = target_result.index(1) + 1 target_end = target_result.index(2) divide = float(target_end - target_start) if 1 not in tmp_result and 2 not in tmp_result: leven_distance.append( (target_end - target_start) / divide) if 1 in tmp_result and 2 not in tmp_result: leven_distance.append( distance.levenshtein( tmp_result[tmp_result.index(1) + 1:], target_result[target_start:target_end]) / divide) if 1 not in tmp_result and 2 in tmp_result: leven_distance.append( distance.levenshtein( tmp_result[:tmp_result.index(2)], target_result[target_start:target_end]) / divide) if 1 in tmp_result and 2 in tmp_result: if (tmp_result.index(1) < tmp_result.index(2)): leven_distance.append( distance.levenshtein( tmp_result[tmp_result.index(1) + 1:tmp_result.index(2)], target_result[ target_start:target_end]) / divide) else: leven_distance.append( (target_end - target_start) / divide) summary = sum(leven_distance) / 32 print(summary) f = open('chinese_result.txt', 'a+') f.write(str(loss) + '\n') f.write(str(summary) + '\n') f.close() if count % 10000 == 0: saver.save(sess, './chinese_trained/my-model', global_step=count)
def main(_): prepare_training_dir() dataset = common_flags.create_dataset(split_name=FLAGS.split_name) model = common_flags.create_model(dataset.num_char_classes, dataset.max_sequence_length, dataset.num_of_views, dataset.null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. #device_setter = tf.train.replica_device_setter( # FLAGS.ps_tasks, merge_devices=True) with tf.device("/cpu:0"): provider = data_provider.get_data( dataset, FLAGS.batch_size, augment=hparams.use_augment_input, central_crop_size=common_flags.get_crop_size()) batch_queue = slim.prefetch_queue.prefetch_queue([ provider.images, provider.images_orig, provider.labels, provider.labels_one_hot ], capacity=2 * FLAGS.num_clones) losses = [] for i in xrange(FLAGS.num_clones): with tf.name_scope("clone_{0}".format(i)): with tf.device("/gpu:{0}".format(i)): #if i == 1: # continue images, images_orig, labels, labels_one_hot = batch_queue.dequeue( ) if i == 0: endpoints = model.create_base(images, labels_one_hot) else: endpoints = model.create_base(images, labels_one_hot, reuse=True) init_fn = model.create_init_fn_to_restore( FLAGS.checkpoint, FLAGS.checkpoint_inception) if FLAGS.show_graph_stats: logging.info('Total number of weights in the graph: %s', calculate_graph_metrics()) data = InputEndpoints(images=images, images_orig=images_orig, labels=labels, labels_one_hot=labels_one_hot) total_loss, single_model_loss = model.create_loss( data, endpoints) losses.append((single_model_loss, i)) with tf.device("/cpu:0"): tf.summary.scalar('model_loss'.format(i), single_model_loss) model.create_summaries_multigpu(data, endpoints, dataset.charset, i, is_training=True) train_multigpu(losses, init_fn, hparams)
def main(_): prepare_training_dir() num_char_classes = 77 #less than 37 max_sequence_length = 25 num_of_views = 4 # null_code = 42 null_code = 2 model = common_flags.create_model(num_char_classes, max_sequence_length, num_of_views,null_code) hparams = get_training_hparams() # If ps_tasks is zero, the local device is used. When using multiple # (non-local) replicas, the ReplicaDeviceSetter distributes the variables # across the different devices. device_setter = tf.train.replica_device_setter( FLAGS.ps_tasks, merge_devices=True) with tf.device(device_setter): images_orig = tf.placeholder(tf.float32, [64, 150, 600,3], name='image_orig') labels = tf.placeholder(tf.int32, [64,max_sequence_length, ], name='label') data = data_provider.get_data( images_orig,labels, num_of_views, num_char_classes) # augment=hparams.use_augment_input, # central_crop_size=None) endpoints = model.create_base(data.images,data.labels_one_hot) total_loss = model.create_loss(labels, endpoints) init_fn = model.create_init_fn_to_restore(FLAGS.checkpoint, FLAGS.checkpoint_inception) train_op = train(total_loss, init_fn, hparams) saver = tf.train.Saver() with tf.Session() as sess: tf.global_variables_initializer().run() images_dataset,labels_dataset = prehandle_data.get_data() print('data prepared') for epoch in range(400): ids = np.random.permutation(images_dataset.shape[0]) images_permutation = images_dataset[ids] labels_permutation = labels_dataset[ids] for step in range(images_dataset.shape[0] / 64): result, loss, _ = sess.run([endpoints.predicted_chars,total_loss,train_op],feed_dict={images_orig:images_permutation[step*64:(step+1)*64],labels:labels_permutation[step*64:(step+1)*64]}) # print(loss) if step % 200 == 0: print(loss) target = labels_permutation[step*64:(step+1)*64] leven_distance = list() count = 0 for h_shape in range(result.shape[0]): tmp_result = list(result[h_shape]) target_result = list(target[h_shape]) if count < 5: f = open('./aaa.txt','a+') f.write(''.join(idx_to_words(tmp_result))+'\n') f.write(''.join(idx_to_words(target_result))+'\n') f.write('--------------------------------------'+'\n') f.close() count += 1 target_start = target_result.index(1)+1 target_end = target_result.index(2) divide = float(target_end - target_start) if 1 not in tmp_result and 2 not in tmp_result: leven_distance.append((target_end-target_start)/divide) if 1 in tmp_result and 2 not in tmp_result: leven_distance.append(distance.levenshtein(tmp_result[tmp_result.index(1)+1:],target_result[target_start:target_end])/divide) if 1 not in tmp_result and 2 in tmp_result: leven_distance.append(distance.levenshtein(tmp_result[:tmp_result.index(2)],target_result[target_start:target_end])/divide) if 1 in tmp_result and 2 in tmp_result: if(tmp_result.index(1) < tmp_result.index(2)): leven_distance.append(distance.levenshtein(tmp_result[tmp_result.index(1)+1:tmp_result.index(2)],target_result[target_start:target_end])/divide) else: leven_distance.append((target_end-target_start)/divide) summary = sum(leven_distance) / 64 print(summary) f = open('result_1.txt','a+') f.write(str(loss)+'\n') f.write(str(summary)+'\n') f.close() if epoch % 40 == 0: saver.save(sess,'./trained/my-model',global_step=epoch)