Repository: deeperic/SpikeFlow Branch: master Commit: ffff4f5c479d Files: 13 Total size: 71.3 KB Directory structure: gitextract__3f2v9ps/ ├── LICENSE ├── README.md ├── receipt.gh/ │ └── find_contour_character.py ├── tf/ │ ├── convert_to_tfrecords.py │ ├── helper.py │ ├── ocr_model.py │ ├── reader.py │ ├── spikeflow.py │ ├── test_one_char.py │ └── train_model.py └── training-character.gh/ ├── labelling-character.py ├── trainLabels.csv └── valLabels.csv ================================================ FILE CONTENTS ================================================ ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2017 deeperic Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ # SpikeFlow A Chinese OCR with TensorFlow *** Warning: The source codes in this repository may not work well with the latest version of Tensorflow. *** To play around, follow these steps: 1/ Use Ocropy to generate Chinese character images. linegen is the tool used. You will need a font file. Put the images under folder training-character.gh. 2/ Run labelling-character.py to generate the labels on images. 3/ Run tf/convert-to-tfrecords.py to convert the images and labels in Tensorflow format. 4/ Modify the tf/helper.py for the characters you want to recognise. 5/ Run tf/train_model.py to train a model. The training will save a checkpoint on a regular interval. 6/ In receipt, run the find_contour_character.py to generate the images which may contain Chinese characters. You will have a "bw" folder containing all images. Run: python find_contour_character.py {image filename} 7/ Test the model by running: python test_one_char.py {the name of your model} {the image to be recognised} Blog: https://deeperic.wordpress.com/2017/02/18/chinese-ocr-tensorflow Youtube: https://youtu.be/9N9OUruPZd4 GitHub: https://github.com/deeperic/SpikeFlow ================================================ FILE: receipt.gh/find_contour_character.py ================================================ #i need this to generate chinese character images import cv2 import os import sys def createFolder(folder): if not os.path.exists(folder): os.makedirs(folder) def sort_bounding_boxes(cnts, method="left-to-right"): # initialize the reverse flag and sort index reverse = False i = 0 # handle if we need to sort in reverse if method == "right-to-left" or method == "bottom-to-top": reverse = True # handle if we are sorting against the y-coordinate rather than # the x-coordinate of the bounding box if method == "top-to-bottom" or method == "bottom-to-top": i = 1 # construct the list of bounding boxes and sort them from top to # bottom boundingBoxes = cnts (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes), key=lambda b:b[1][i], reverse=reverse)) # return the list of sorted contours and bounding boxes return (cnts, boundingBoxes) def sort_contours(cnts, method="left-to-right"): # initialize the reverse flag and sort index reverse = False i = 0 # handle if we need to sort in reverse if method == "right-to-left" or method == "bottom-to-top": reverse = True # handle if we are sorting against the y-coordinate rather than # the x-coordinate of the bounding box if method == "top-to-bottom" or method == "bottom-to-top": i = 1 # construct the list of bounding boxes and sort them from top to # bottom boundingBoxes = [cv2.boundingRect(c) for c in cnts] (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes), key=lambda b:b[1][i], reverse=reverse)) # return the list of sorted contours and bounding boxes return (cnts, boundingBoxes) def captch_ex(file_name, folder1, folder2 ): img = cv2.imread(file_name) img2 = cv2.imread(file_name) #for saving img2gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) new_img = cv2.adaptiveThreshold(img2gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 9, 10) need_img = cv2.adaptiveThreshold(img2gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, 15) kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(3 , 3)) # to manipulate the orientation of dilution , large x means horizonatally dilating more, large y means vertically dilating more dilated = cv2.dilate(new_img,kernel,iterations = 2) # dilate , more the iteration more the dilation #find section _, contours, hierarchy = cv2.findContours(dilated,cv2.RETR_LIST,cv2.CHAIN_APPROX_NONE) # get contours cnts, sorted = sort_contours(contours, "top-to-bottom") index = 0 dimension = 32 for contour in sorted: [x,y,w,h] = contour #Don't plot small false positives that aren't text if w < 50: continue #chinese is a square, so try to get a character capw = w if(h > w): capw = h # draw rectangle around contour on original image cv2.rectangle(img,(x,y),(x+capw,y+capw),(255,0,255),2) cropped = img2[y :y + capw , x : x + capw] croppedBW = need_img[y :y + capw , x : x + capw] #cropped32 = cv2.resize(cropped, (dimension, dimension)) #s = './' + folder1 + '/' + str(index) + '.png' #cv2.imwrite(s , cropped32) croppedbw32 = cv2.resize(croppedBW, (dimension, dimension)) s = './' + folder2 + '/' + str(index) + '-bw.png' cv2.imwrite(s , croppedbw32) index = index + 1 cv2.namedWindow('captcha_result', cv2.WINDOW_NORMAL) # write original image with added contours to disk #resize for display height, width, channels = img.shape print(height) ratio = height / width newheight = 900 newwidth = newheight / ratio imS = cv2.resize(img, (newheight, newwidth)) cv2.imshow('captcha_result' , imS) cv2.waitKey() #cv2.imshow('captcha_result' , new_img) #cv2.waitKey() file_name = sys.argv[1] print file_name filename_split = os.path.splitext(file_name) folder1 = filename_split[0] folder2 = filename_split[0] + 'bw' createFolder(folder1) createFolder(folder2) captch_ex(file_name, folder1, folder2) ================================================ FILE: tf/convert_to_tfrecords.py ================================================ # deeperic """Converts images and labels to TFRecords file format.""" import csv import glob import os import numpy as np import tensorflow as tf from PIL import Image import helper tf.app.flags.DEFINE_string('directory', '../tfrec', 'Directory to write the ' 'converted result') FLAGS = tf.app.flags.FLAGS def _int64_feature(value): return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def _bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def convert_to(images, labels, name): num_examples = labels.shape[0] #print('labels shape is ' + str(labels.shape[0])) if images.shape[0] != num_examples: raise ValueError("Images size %d does not match label size %d." % (images.shape[0], num_examples)) rows = images.shape[1] cols = images.shape[2] depth = images.shape[3] filename = os.path.join(FLAGS.directory, name + '.tfrecords') #print('Writing', filename) writer = tf.python_io.TFRecordWriter(filename) for index in range(num_examples): image_raw = images[index].tostring() example = tf.train.Example(features=tf.train.Features(feature={ 'height': _int64_feature(rows), 'width': _int64_feature(cols), 'depth': _int64_feature(depth), 'label': _int64_feature(int(labels[index])), 'image_raw': _bytes_feature(image_raw)})) writer.write(example.SerializeToString()) def read_images(path): print('Reading images') images = [] png_files_path = glob.glob(os.path.join(path, './', '*.[pP][nN][gG]')) for filename in png_files_path: #print('read file:' + filename) im = Image.open(filename) # .convert("L") # Convert to greyscale im = np.asarray(im, np.uint8) # get only images name, not path image_name = filename.split('/')[-1].split('.')[0] images.append([int(image_name), im]) images = sorted(images, key=lambda image: image[0]) images_only = [np.asarray(image[1], np.uint8) for image in images] # Use unint8 or you will be !!! images_only = np.array(images_only) return images_only def read_labels(path, filename): print('Reading labels') with open(os.path.join(path, filename), 'r') as dest_f: data_iter = csv.reader(dest_f) train_labels = [data for data in data_iter] # pre process labels to int train_labels = _label_to_int(train_labels) train_labels = np.array(train_labels, dtype=np.uint32) return train_labels def _label_to_int(labels): chars = helper.char_list new_labels = [] for label in labels: new_labels.append(chars.index(label[1])) return new_labels def main(argv): train_images = read_images('../training-character/train') train_labels = read_labels('../training-character', 'trainLabels.csv') validation_images = read_images('../training-character/val') validation_labels = read_labels('../training-character', 'valLabels.csv') print('train shape:' + str(train_images.shape)) print('validation shape:' + str(validation_images.shape)) convert_to(train_images, train_labels, 'train') convert_to(validation_images, validation_labels, 'validation') if __name__ == '__main__': tf.app.run() ================================================ FILE: tf/helper.py ================================================ #!/usr/bin/env python # -*- coding: UTF-8 -*- # deeperic char_list = ['cheung', 'chin2', 'chiu', 'cup', 'ho', 'ka', 'ma', 'sheung', 'shi', 'yi', 'sin', 'ngou', 'lai'] char_list_chinese = ['場', '錢', '超', '級', '號', '卡', '碼', '賞', '市', '易', '鮮', '牛', '奶'] ================================================ FILE: tf/ocr_model.py ================================================ #!/usr/bin/env python # -*- coding: UTF-8 -*- #deep eric """The network model""" import tensorflow as tf # Network Parameters IMAGE_SIZE = 32 n_input = IMAGE_SIZE * IMAGE_SIZE * 3 # (img shape: 32*32) out_conv_1 = 64 out_conv_2 = 64 n_hidden_1 = 384 n_hidden_2 = 192 dropout = 0.90 # Dropout, probability to keep units NUM_CLASSES = 13 NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN = 40000 NUM_EXAMPLES_PER_EPOCH_FOR_EVAL = 10000 # Constants describing the training process. NUM_EPOCHS_PER_DECAY = 10.0 # Epochs after which learning rate decays. LEARNING_RATE_DECAY_FACTOR = 0.60 # Learning rate decay factor. INITIAL_LEARNING_RATE = 0.001 # Initial learning rate. FLAGS = tf.app.flags.FLAGS # Create model def conv2d(img, w, b): return tf.nn.relu(tf.nn.bias_add(tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], padding='SAME'), b)) def max_pool(img, k): return tf.nn.max_pool(img, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME') def inference(images): """Build the model up to where it may be used for inference. Args: Returns: logits: Output tensor with the computed logits. """ # Reshape input picture images = tf.reshape(images, shape=[-1, IMAGE_SIZE, IMAGE_SIZE, 3]) _dropout = tf.Variable(dropout) # dropout (keep probability) #random_normal #truncated_normal # Store layers weight & bias _weights = { 'wc1': tf.Variable(tf.random_normal([5, 5, 3, out_conv_1], stddev=1e-3)), # 5x5 conv, 3 input, 64 outputs 'wc2': tf.Variable(tf.random_normal([5, 5, out_conv_1, out_conv_2], stddev=1e-3)), # 5x5 conv, 64 inputs, 64 outputs 'wd1': tf.Variable(tf.random_normal([out_conv_2 * 8 * 8, n_hidden_1], stddev=1e-3)), 'wd2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], stddev=1e-3)), 'out': tf.Variable(tf.random_normal([n_hidden_2, NUM_CLASSES], stddev=1e-3)) } _biases = { 'bc1': tf.Variable(tf.random_normal([out_conv_1])), 'bc2': tf.Variable(tf.random_normal([out_conv_2])), 'bd1': tf.Variable(tf.random_normal([n_hidden_1])), 'bd2': tf.Variable(tf.random_normal([n_hidden_2])), 'out': tf.Variable(tf.random_normal([NUM_CLASSES])) } # Convolution Layer 1 with tf.name_scope('Conv1'): conv1 = conv2d(images, _weights['wc1'], _biases['bc1']) # Max Pooling (down-sampling) conv1 = max_pool(conv1, k=2) # norm1 conv1 = tf.nn.lrn(conv1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1') # Apply Dropout conv1 = tf.nn.dropout(conv1, _dropout) # Convolution Layer 2 with tf.name_scope('Conv2'): conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2']) # norm2 conv2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2') # # Max Pooling (down-sampling) conv2 = max_pool(conv2, k=2) # Apply Dropout conv2 = tf.nn.dropout(conv2, _dropout) # Fully connected layer 1 with tf.name_scope('Dense1'): dense1 = tf.reshape(conv2, [-1, _weights['wd1'].get_shape().as_list()[0]]) # Reshape conv2 output to fit dense layer input dense1 = tf.nn.relu_layer(dense1, _weights['wd1'], _biases['bd1']) # Relu activation dense1 = tf.nn.dropout(dense1, _dropout) # Apply Dropout # Fully connected layer 2 with tf.name_scope('Dense2'): dense2 = tf.nn.relu_layer(dense1, _weights['wd2'], _biases['bd2']) # Relu activation # Output, class prediction logits = tf.add(tf.matmul(dense2, _weights['out']), _biases['out']) return logits def loss(logits, labels): """Add L2Loss to all the trainable variables. Add summary for for "Loss" and "Loss/avg". Args: logits: Logits from inference(). labels: Labels from distorted_inputs or inputs(). 1-D tensor of shape [batch_size] Returns: Loss tensor of type float. """ # Reshape the labels into a dense Tensor of # shape [batch_size, NUM_CLASSES]. sparse_labels = tf.reshape(labels, [FLAGS.batch_size, 1]) indices = tf.reshape(tf.range(0, FLAGS.batch_size), [FLAGS.batch_size, 1]) concated = tf.concat(axis=1, values=[indices, sparse_labels]) dense_labels = tf.sparse_to_dense(concated, [FLAGS.batch_size, NUM_CLASSES], 1.0, 0.0) # Calculate the average cross entropy loss across the batch. cross_entropy = tf.nn.softmax_cross_entropy_with_logits( logits=logits, labels=dense_labels, name='cross_entropy_per_example') cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy') tf.add_to_collection('losses', cross_entropy_mean) # The total loss is defined as the cross entropy loss plus all of the weight # decay terms (L2 loss). return tf.add_n(tf.get_collection('losses'), name='total_loss') def training(loss, global_step): """Sets up the training Ops. Creates a summarizer to track the loss over time in TensorBoard. Creates an optimizer and applies the gradients to all trainable variables. The Op returned by this function is what must be passed to the `sess.run()` call to cause the model to train. Args: loss: Loss tensor, from loss(). learning_rate: The learning rate to use for gradient descent. Returns: train_op: The Op for training. """ # Variables that affect learning rate. num_batches_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN / FLAGS.batch_size decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY) #print('Decay steps is: ', decay_steps) # Decay the learning rate exponentially based on the number of steps. lr = tf.train.exponential_decay(INITIAL_LEARNING_RATE, global_step, decay_steps, LEARNING_RATE_DECAY_FACTOR, staircase=True) tf.summary.scalar('learning_rate', lr) # Add a scalar summary for the snapshot loss. tf.summary.scalar(loss.op.name, loss) # Create the adam or gradient descent optimizer with the given learning rate. optimizer = tf.train.AdamOptimizer(lr) # optimizer = tf.train.GradientDescentOptimizer(lr) # Use the optimizer to apply the gradients that minimize the loss # (and also increment the global step counter) as a single training step. train_op = optimizer.minimize(loss, global_step=global_step) return train_op def evaluation(logits, labels): """Evaluate the quality of the logits at predicting the label. Args: logits: Logits tensor, float - [batch_size, NUM_CLASSES]. labels: Labels tensor, int32 - [batch_size], with values in the range [0, NUM_CLASSES). Returns: A scalar int32 tensor with the number of examples (out of batch_size) that were predicted correctly. """ print('Evaluation..') # For a classifier model, we can use the in_top_k Op. # It returns a bool tensor with shape [batch_size] that is true for # the examples where the label's is was in the top k (here k=1) # of all logits for that example. correct = tf.nn.in_top_k(logits, labels, 1) num_correct = tf.reduce_sum(tf.cast(correct, tf.float32)) acc_percent = num_correct / FLAGS.batch_size # Return the number of true entries. return acc_percent * 100.0, num_correct def main(argv=None): return 0 if __name__ == '__main__': tf.app.run() ================================================ FILE: tf/reader.py ================================================ #deeperic import os import glob import csv import tensorflow as tf import numpy as np from PIL import Image def _read_raw_images(path, is_directory=True): """Reads directory of images in tensorflow Args: path: is_directory: Returns: """ images = [] png_files = [] jpeg_files = [] reader = tf.WholeFileReader() png_files_path = glob.glob(os.path.join(path, '*.[pP][nN][gG]')) jpeg_files_path = glob.glob(os.path.join(path, '*.[jJ][pP][eE][gG]')) jpg_files_path = glob.glob(os.path.join(path, '*.[jJ][pP][gG]')) if is_directory: for filename in png_files_path: png_files.append(filename) for filename in jpeg_files_path: jpeg_files.append(filename) for filename in jpg_files_path: jpeg_files.append(filename) else: raise ValueError('Currently only batch read from directory supported') # Decode if there is a PNG file: if len(png_files) > 0: png_file_queue = tf.train.string_input_producer(png_files) pkey, pvalue = reader.read(png_file_queue) p_img = tf.image.decode_png(pvalue) if len(jpeg_files) > 0: jpeg_file_queue = tf.train.string_input_producer(jpeg_files) jkey, jvalue = reader.read(jpeg_file_queue) j_img = tf.image.decode_jpeg(jvalue) return # TODO: return normal thing def read_and_decode(filename_queue, imshape, normalize=False, flatten=True): """Reads Args: filename_queue: imshape: normalize: flatten: Returns: """ reader = tf.TFRecordReader() _, serialized_example = reader.read(filename_queue) features = tf.parse_single_example( serialized_example, features={ 'image_raw': tf.FixedLenFeature([], tf.string), 'label': tf.FixedLenFeature([], tf.int64) }) # Convert from a scalar string tensor (whose single string has # length mnist.IMAGE_PIXELS) to a uint8 tensor with shape # [mnist.IMAGE_PIXELS]. image = tf.decode_raw(features['image_raw'], tf.uint8) if flatten: num_elements = 1 for i in imshape: num_elements = num_elements * i #print num_elements image = tf.reshape(image, [num_elements]) image.set_shape(num_elements) else: image = tf.reshape(image, imshape) image.set_shape(imshape) if normalize: # Convert from [0, 255] -> [-0.5, 0.5] floats. image = tf.cast(image, tf.float32) image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # Convert label from a scalar uint8 tensor to an int32 scalar. label = tf.cast(features['label'], tf.int32) return image, label # Helper, Examples def _read_labels_csv_from(path, num_classes, one_hot=False): """Reads Args: Returns: """ print('Reading labels') with open(os.path.join(path), 'r') as dest_f: data_iter = csv.reader(dest_f) train_labels = [data for data in data_iter] train_labels = np.array(train_labels, dtype=np.uint32) if one_hot: labels_one_hot = utils.dense_to_one_hot(train_labels, num_classes) labels_one_hot = np.asarray(labels_one_hot) return labels_one_hot return train_labels def _read_pngs_from(path): """Reads directory of images. Args: path: path to the directory Returns: A list of all images in the directory in the TF format (You need to call sess.run() or .eval() to get the value). """ images = [] png_files_path = glob.glob(os.path.join(path, '*.[pP][nN][gG]')) for filename in png_files_path: im = Image.open(filename) im = np.asarray(im, np.uint8) # get only images name, not path image_name = filename.split('/')[-1].split('.')[0] images.append([int(image_name), im]) images = sorted(images, key=lambda image: image[0]) images_only = [np.asarray(image[1], np.uint8) for image in images] # Use unint8 or you will be !!! images_only = np.array(images_only) #print(images_only.shape) return images_only def read_and_decode_wholefile(filename_queue, imshape, normalize=False, flatten=True): """Reads Args: filename_queue: imshape: normalize: flatten: Returns: """ reader = tf.WholeFileReader() key, value = reader.read(filename_queue) image = tf.image.decode_png(value, channels=3) if flatten: num_elements = 1 for i in imshape: num_elements = num_elements * i #print num_elements image = tf.reshape(image, [num_elements]) image.set_shape(num_elements) else: image = tf.reshape(image, imshape) image.set_shape(imshape) if normalize: # Convert from [0, 255] -> [-0.5, 0.5] floats. image = tf.cast(image, tf.float32) image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # don't care label = 1 return image, label def dense_to_one_hot(labels_dense, num_classes): """ Convert class labels from scalars to one-hot vectors. """ num_labels = labels_dense.shape[0] index_offset = np.arange(num_labels) * num_classes labels_one_hot = np.zeros((num_labels, num_classes)) labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1 print(labels_one_hot[0]) return labels_one_hot ================================================ FILE: tf/spikeflow.py ================================================ #deeperic import convert_to_tfrecords import reader from numpy.random import shuffle import tensorflow as tf def inputs_test_files(filename, batch_size, num_epochs2, num_threads, imshape, num_examples_per_epoch=128): """Reads input tfrecord file num_epochs times. Use it for validation. Args: filename: The path to the .tfrecords file to be read batch_size: Number of examples per returned batch. num_epochs: Number of times to read the input ckpt, or 0/None to train forever. num_threads: Number of reader workers to enqueue imshape: The shape of image in the format num_examples_per_epoch: Number of images to use per epoch 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(). """ tf.local_variables_initializer() if not num_epochs2: num_epochs2 = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( #[filename], num_epochs=num_epochs2, name='string_input_producer') #['../character-data/test/170.png', #'../character-data/test/214.png', #'../character-data/test/2579.png'], ['../project/pricesplit_/0.png', '../project/pricesplit_/1.png', '../project/pricesplit_/2.png', '../project/pricesplit_/3.png', '../project/pricesplit_/4.png', '../project/pricesplit_/5.png', '../project/pricesplit_/6.png', '../project/pricesplit_/7.png'], num_epochs=num_epochs2, shuffle=False,#must be false otherwise will shuffle everytime name='string_input_producer') # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode_eric(filename_queue, imshape, normalize=True) # Convert from [0, 255] -> [-0.5, 0.5] floats. The normalize param in read_and_decode will do the same job. # image = tf.cast(image, tf.float32) # image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # 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. # Ensure that the random shuffling has good mixing properties. #min_fraction_of_examples_in_queue = 0.4 #min_queue_examples = int(num_examples_per_epoch * # min_fraction_of_examples_in_queue) #images, sparse_labels = tf.train.shuffle_batch( # [image, label], batch_size=batch_size, num_threads=num_threads, # capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # # Ensures a minimum amount of shuffling of examples. # min_after_dequeue=min_queue_examples, name='batching_shuffling') #print('erieric') images, sparse_labels = tf.train.batch( [image, label], batch_size=batch_size, num_threads=num_threads) return images, sparse_labels def inputs_test(filename, batch_size, num_epochs, num_threads, imshape, num_examples_per_epoch=128): tf.local_variables_initializer() if not num_epochs: num_epochs = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs, name='string_input_producer') image, label = reader.read_and_decode_wholefile(filename_queue, imshape, normalize=True) images, sparse_labels = tf.train.batch([image, label], batch_size=batch_size) return images, sparse_labels def inputs(filename, batch_size, num_epochs2, num_threads, imshape, num_examples_per_epoch=128): """Reads input tfrecord file num_epochs times. Use it for validation. Args: filename: The path to the .tfrecords file to be read batch_size: Number of examples per returned batch. num_epochs: Number of times to read the input ckpt, or 0/None to train forever. num_threads: Number of reader workers to enqueue imshape: The shape of image in the format num_examples_per_epoch: Number of images to use per epoch 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(). """ tf.local_variables_initializer() if not num_epochs2: num_epochs2 = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs2, name='string_input_producer') # Even when reading in multiple threads, share the filename # queue. #image, label = reader.read_and_decode(filename_queue, imshape, normalize=True, flatten=False) image, label = reader.read_and_decode(filename_queue, imshape, normalize=True) # Convert from [0, 255] -> [-0.5, 0.5] floats. The normalize param in read_and_decode will do the same job. # image = tf.cast(image, tf.float32) # image = tf.cast(image, tf.float32) * (1. / 255) - 0.5 # 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. # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch( [image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name='batching_shuffling') return images, sparse_labels def _random_brightness_helper(image): return tf.image.random_brightness(image, max_delta=63) def _random_contrast_helper(image): return tf.image.random_contrast(image, lower=0.2, upper=1.8) def distorted_inputs(filename, batch_size, num_epochs, num_threads, imshape, num_examples_per_epoch=128, flatten=True): """Construct distorted input for training using the Reader ops. Raises: ValueError: if no data_dir Args: filename: The name of the file containing the images batch_size: The number of images per batch num_epochs: The number of epochs passed to string_input_producer num_threads: The number of threads passed to shuffle_batch imshape: Shape of image in [height, width, n_channels] format num_examples_per_epoch: Number of images to use per epoch flatten: Whether to flatten image after image transformations Returns: images: Images. 4D tensor of [batch_size, IMAGE_SIZE, IMAGE_SIZE, 3] size. labels: Labels. 1D tensor of [batch_size] size. """ tf.local_variables_initializer() tf.global_variables_initializer() if not num_epochs: num_epochs = None with tf.name_scope('input'): filename_queue = tf.train.string_input_producer( [filename], num_epochs=num_epochs, name='string_DISTORTED_input_producer') # Even when reading in multiple threads, share the filename # queue. image, label = reader.read_and_decode(filename_queue, imshape) # Reshape to imshape as distortion methods need this shape image = tf.reshape(image, imshape) # Image processing for training the network. Note the many random # distortions applied to the image. # Removed random_crop in new TensorFlow release. # Randomly crop a [height, width] section of the image. # distorted_image = tf.image.random_crop(image, [height, width]) # # Randomly flip the image horizontally. distorted_image = tf.image.random_flip_left_right(image) # # Randomly apply image transformations in random_functions list random_functions = [_random_brightness_helper, _random_contrast_helper] shuffle(random_functions) for fcn in random_functions: distorted_image = fcn(distorted_image) # # Subtract off the mean and divide by the variance of the pixels. float_image = tf.image.per_image_standardization(distorted_image) if flatten: num_elements = 1 for i in imshape: num_elements = num_elements * i image = tf.reshape(float_image, [num_elements]) else: image = float_image # Ensure that the random shuffling has good mixing properties. min_fraction_of_examples_in_queue = 0.4 min_queue_examples = int(num_examples_per_epoch * min_fraction_of_examples_in_queue) images, sparse_labels = tf.train.shuffle_batch([image, label], batch_size=batch_size, num_threads=num_threads, capacity=min_queue_examples + 3 * batch_size, enqueue_many=False, # Ensures a minimum amount of shuffling of examples. min_after_dequeue=min_queue_examples, name='batching_shuffling_distortion') return images, sparse_labels ================================================ FILE: tf/test_one_char.py ================================================ #!/usr/bin/env python # -*- coding: UTF-8 -*- #deeperic import os.path import time from datetime import datetime import numpy as np import tensorflow as tf import glob from PIL import Image import sys import spikeflow import ocr_model import helper #import input_data # Basic model parameters as external flags. flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_integer('num_epochs', 50000, 'Number of epochs to run trainer.') flags.DEFINE_integer('batch_size', 32, 'Batch size.') IMAGE_PIXELS = 32 * 32 * 3 def placeholder_inputs(batch_size): """Generate placeholder variables to represent the the input tensors. These placeholders are used as inputs by the rest of the model building code and will be fed from the downloaded ckpt in the .run() loop, below. Args: batch_size: The batch size will be baked into both placeholders. Returns: images_placeholder: Images placeholder. labels_placeholder: Labels placeholder. """ # Note that the shapes of the placeholders match the shapes of the full # image and label tensors, except the first dimension is now batch_size # rather than the full size of the train or test ckpt sets. # batch_size = -1 images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS)) labels_placeholder = tf.placeholder(tf.int32, shape=batch_size) return images_placeholder, labels_placeholder def test(argv): with tf.Graph().as_default(): global_step = tf.Variable(0, trainable=False) images_placeholder, labels_placeholder = placeholder_inputs(FLAGS.batch_size) test_images, test_labels = spikeflow.inputs_test(filename=argv[1], batch_size=FLAGS.batch_size, num_epochs=FLAGS.num_epochs, num_threads=5, imshape=[32, 32, 3]) # Build a Graph that computes the logits predictions from the inference model. logits = ocr_model.inference(images_placeholder) # Create a saver. saver = tf.train.Saver() init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # Start running operations on the Graph. NUM_CORES = 5 # Choose how many cores to use. sess = tf.Session(config=tf.ConfigProto(inter_op_parallelism_threads=NUM_CORES, intra_op_parallelism_threads=NUM_CORES)) sess.run(init) # Start the queue runners. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) #print('Model:' + argv[0]) saver.restore(sess, argv[0]) #print('Model Restored!') images_test_r, labels_test_r = sess.run([test_images, test_labels]) val_feed_test = {images_placeholder: images_test_r, labels_placeholder: labels_test_r} acc_r = sess.run(tf.argmax(logits,1), feed_dict=val_feed_test) chars = helper.char_list_chinese print('The character is: ' + str(chars[acc_r[0]])) #print predictions prediction=tf.argmax(logits,1) print "Predictions:", prediction.eval(feed_dict=val_feed_test, session=sess)[0] #print probabilities probabilities=logits print "Probabilities:", probabilities.eval(feed_dict=val_feed_test, session=sess)[0] coord.request_stop() coord.join(threads) sess.close() def main(argv=None): #python test_one_char.py {model_name} {image_name} test(sys.argv[1:]) #predict if __name__ == '__main__': tf.app.run() ================================================ FILE: tf/train_model.py ================================================ #!/usr/bin/env python # -*- coding: UTF-8 -*- #deeperic """Training the model""" import os.path import time from datetime import datetime import numpy as np import tensorflow as tf import glob from PIL import Image import spikeflow import ocr_model #import input_data # Basic model parameters as external flags. flags = tf.app.flags FLAGS = flags.FLAGS flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.') flags.DEFINE_integer('num_epochs', 50000, 'Number of epochs to run trainer.') flags.DEFINE_integer('batch_size', 32, 'Batch size.') FLAGS = tf.app.flags.FLAGS tf.app.flags.DEFINE_string('model_dir', '../tmp/my-model', """Directory where to write model proto """ """ to import in c++""") tf.app.flags.DEFINE_string('train_dir', '../tmp/log', """Directory where to write event logs """ """and checkpoint.""") tf.app.flags.DEFINE_integer('max_steps', 100000, """Number of batches to run.""") tf.app.flags.DEFINE_string('checkpoint_dir', '../checkpoint', """Directory where to read/write model checkpoints.""") # Parameters display_step = 100 val_step = 500 save_step = 500 PIXEL_DIM = 32 IMAGE_PIXELS = PIXEL_DIM * PIXEL_DIM * 3 NEW_LINE = '\n' def placeholder_inputs(batch_size): """Generate placeholder variables to represent the the input tensors. These placeholders are used as inputs by the rest of the model building code and will be fed from the downloaded ckpt in the .run() loop, below. Args: batch_size: The batch size will be baked into both placeholders. Returns: images_placeholder: Images placeholder. labels_placeholder: Labels placeholder. """ # Note that the shapes of the placeholders match the shapes of the full # image and label tensors, except the first dimension is now batch_size # rather than the full size of the train or test ckpt sets. # batch_size = -1 images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS)) labels_placeholder = tf.placeholder(tf.int32, shape=batch_size) return images_placeholder, labels_placeholder def train(continue_from_pre = False): with tf.Graph().as_default(): global_step = tf.Variable(0, trainable=False) images_placeholder, labels_placeholder = placeholder_inputs(FLAGS.batch_size) #read the TF Records images, labels = spikeflow.inputs(filename='../tfrec/train.tfrecords', batch_size=FLAGS.batch_size, num_epochs2=FLAGS.num_epochs, num_threads=5, imshape=[PIXEL_DIM, PIXEL_DIM, 3]) val_images, val_labels = spikeflow.inputs(filename='../tfrec/validation.tfrecords', batch_size=FLAGS.batch_size, num_epochs2=FLAGS.num_epochs, num_threads=5, imshape=[PIXEL_DIM, PIXEL_DIM, 3]) # Build a Graph that computes the logits predictions from the inference model. logits = ocr_model.inference(images_placeholder) # Calculate loss. loss = ocr_model.loss(logits, labels_placeholder) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. train_op = ocr_model.training(loss, global_step) # Calculate accuracy # acc, n_correct = ocr_model.evaluation(logits, labels_placeholder) # Create a saver. saver = tf.train.Saver() tf.summary.scalar('Acc', acc) tf.summary.scalar('Loss', loss) # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() # Build an initialization operation to run below. init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) # Start running operations on the Graph. NUM_CORES = 5 # Choose how many cores to use. sess = tf.Session(config=tf.ConfigProto(inter_op_parallelism_threads=NUM_CORES, intra_op_parallelism_threads=NUM_CORES)) sess.run(init) # Write all terminal output results here val_f = open("../tmp/val.txt", "ab") # Start the queue runners. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) summary_writer = tf.summary.FileWriter(FLAGS.train_dir, graph=sess.graph) # Export graph to import it later in c++ # tf.train.write_graph(sess.graph, FLAGS.model_dir, 'train.pbtxt') # TODO: uncomment to get graph and use in c++ #reload previous saved check points continue_from_pre = False if continue_from_pre: ckpt = tf.train.get_checkpoint_state(checkpoint_dir=FLAGS.checkpoint_dir) print ckpt.model_checkpoint_path if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print('Session Restored!') try: while not coord.should_stop(): for step in xrange(FLAGS.max_steps): images_r, labels_r = sess.run([images, labels]) images_val_r, labels_val_r = sess.run([val_images, val_labels]) train_feed = {images_placeholder: images_r, labels_placeholder: labels_r} val_feed = {images_placeholder: images_val_r, labels_placeholder: labels_val_r} start_time = time.time() _, loss_value = sess.run([train_op, loss], feed_dict=train_feed) duration = time.time() - start_time assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % display_step == 0: num_examples_per_step = FLAGS.batch_size examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ('%s: step %d, loss = %.6f (%.1f examples/sec; %.3f ' 'sec/batch)') print_str_loss = format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch) print (print_str_loss) val_f.write(print_str_loss + NEW_LINE) summary_str = sess.run([summary_op], feed_dict=train_feed) summary_writer.add_summary(summary_str[0], step) if step % val_step == 0: acc_value, num_corroect = sess.run([acc, n_correct], feed_dict=train_feed) format_str = '%s: step %d, train acc = %.2f, n_correct= %d' print_str_train = format_str % (datetime.now(), step, acc_value, num_corroect) val_f.write(print_str_train + NEW_LINE) print (print_str_train) # Save the model checkpoint periodically. if step % save_step == 0 or (step + 1) == FLAGS.max_steps: val_acc_r, val_n_correct_r = sess.run([acc, n_correct], feed_dict=val_feed) frmt_str = '%s: step %d, Val Acc = %.2f, num correct = %d' print_str_val = frmt_str % (datetime.now(), step, val_acc_r, val_n_correct_r) val_f.write(print_str_val + NEW_LINE) print(print_str_val) checkpoint_path = os.path.join(FLAGS.checkpoint_dir, 'model.ckpt') savedpath = saver.save(sess, checkpoint_path, global_step=step) print('model saved: ' + savedpath) except tf.errors.OutOfRangeError: print ('Done training -- epoch limit reached') finally: # When done, ask the threads to stop. val_f.write(NEW_LINE + NEW_LINE + '############################ FINISHED ############################' + NEW_LINE) val_f.close() coord.request_stop() # Wait for threads to finish. coord.join(threads) sess.close() def main(argv=None): train() if __name__ == '__main__': tf.app.run() ================================================ FILE: training-character.gh/labelling-character.py ================================================ import os from shutil import copyfile import cv2 aggregatedPath = 'train' trainPath = 'train' valPath = 'val' imagesPath = ['cheung', 'chin2', 'chiu', 'cup', 'ho', 'ka', 'ma', 'sheung', 'shi', 'yi', 'sin', 'ngou', 'lai'] labelsFileTrain = './trainLabels.csv' labelsFileVal = './valLabels.csv' numVal = 160 #200 images, 80% training, 20% validation f = open(labelsFileTrain,'w') f2 = open(labelsFileVal,'w') aggregatedPath = trainPath #init with train path writeFile = f count = 0 eachClassCount = 0 for imagedir in imagesPath: print(imagedir) aggregatedPath = trainPath #init with train path writeFile = f eachClassCount = 0 for fileName in os.listdir(imagedir): print(fileName) if(fileName == ".DS_Store"): continue filename_split = os.path.splitext(fileName) if eachClassCount >= numVal: #validation files aggregatedPath = valPath writeFile = f2 oldFileName = imagedir + "/" + fileName newFileOnlyName = '{0:05d}'.format(count) + "." + "png" newFileName = "./" + aggregatedPath + "/" + newFileOnlyName print(oldFileName) print(newFileName) copyfile(oldFileName, newFileName) writeFile.write('{0:05d}'.format(count) + "," + imagedir + '\n') count = count + 1 eachClassCount = eachClassCount + 1 f.close() f2.close() def resizeme(path): #resize 32x32 for fileName in os.listdir(path): if(fileName == ".DS_Store"): continue print("resize:" + fileName) image = cv2.imread(path + "/" + fileName) resized_image = cv2.resize(image, (32, 32)) cv2.imwrite(path + "/" + fileName, resized_image) resizeme(trainPath) resizeme(valPath) ================================================ FILE: training-character.gh/trainLabels.csv ================================================ 00000,cheung 00001,cheung 00002,cheung 00003,cheung 00004,cheung 00005,cheung 00006,cheung 00007,cheung 00008,cheung 00009,cheung 00010,cheung 00011,cheung 00012,cheung 00013,cheung 00014,cheung 00015,cheung 00016,cheung 00017,cheung 00018,cheung 00019,cheung 00020,cheung 00021,cheung 00022,cheung 00023,cheung 00024,cheung 00025,cheung 00026,cheung 00027,cheung 00028,cheung 00029,cheung 00030,cheung 00031,cheung 00032,cheung 00033,cheung 00034,cheung 00035,cheung 00036,cheung 00037,cheung 00038,cheung 00039,cheung 00040,cheung 00041,cheung 00042,cheung 00043,cheung 00044,cheung 00045,cheung 00046,cheung 00047,cheung 00048,cheung 00049,cheung 00050,cheung 00051,cheung 00052,cheung 00053,cheung 00054,cheung 00055,cheung 00056,cheung 00057,cheung 00058,cheung 00059,cheung 00060,cheung 00061,cheung 00062,cheung 00063,cheung 00064,cheung 00065,cheung 00066,cheung 00067,cheung 00068,cheung 00069,cheung 00070,cheung 00071,cheung 00072,cheung 00073,cheung 00074,cheung 00075,cheung 00076,cheung 00077,cheung 00078,cheung 00079,cheung 00080,cheung 00081,cheung 00082,cheung 00083,cheung 00084,cheung 00085,cheung 00086,cheung 00087,cheung 00088,cheung 00089,cheung 00090,cheung 00091,cheung 00092,cheung 00093,cheung 00094,cheung 00095,cheung 00096,cheung 00097,cheung 00098,cheung 00099,cheung 00100,cheung 00101,cheung 00102,cheung 00103,cheung 00104,cheung 00105,cheung 00106,cheung 00107,cheung 00108,cheung 00109,cheung 00110,cheung 00111,cheung 00112,cheung 00113,cheung 00114,cheung 00115,cheung 00116,cheung 00117,cheung 00118,cheung 00119,cheung 00120,cheung 00121,cheung 00122,cheung 00123,cheung 00124,cheung 00125,cheung 00126,cheung 00127,cheung 00128,cheung 00129,cheung 00130,cheung 00131,cheung 00132,cheung 00133,cheung 00134,cheung 00135,cheung 00136,cheung 00137,cheung 00138,cheung 00139,cheung 00140,cheung 00141,cheung 00142,cheung 00143,cheung 00144,cheung 00145,cheung 00146,cheung 00147,cheung 00148,cheung 00149,cheung 00150,cheung 00151,cheung 00152,cheung 00153,cheung 00154,cheung 00155,cheung 00156,cheung 00157,cheung 00158,cheung 00159,cheung 00200,chin2 00201,chin2 00202,chin2 00203,chin2 00204,chin2 00205,chin2 00206,chin2 00207,chin2 00208,chin2 00209,chin2 00210,chin2 00211,chin2 00212,chin2 00213,chin2 00214,chin2 00215,chin2 00216,chin2 00217,chin2 00218,chin2 00219,chin2 00220,chin2 00221,chin2 00222,chin2 00223,chin2 00224,chin2 00225,chin2 00226,chin2 00227,chin2 00228,chin2 00229,chin2 00230,chin2 00231,chin2 00232,chin2 00233,chin2 00234,chin2 00235,chin2 00236,chin2 00237,chin2 00238,chin2 00239,chin2 00240,chin2 00241,chin2 00242,chin2 00243,chin2 00244,chin2 00245,chin2 00246,chin2 00247,chin2 00248,chin2 00249,chin2 00250,chin2 00251,chin2 00252,chin2 00253,chin2 00254,chin2 00255,chin2 00256,chin2 00257,chin2 00258,chin2 00259,chin2 00260,chin2 00261,chin2 00262,chin2 00263,chin2 00264,chin2 00265,chin2 00266,chin2 00267,chin2 00268,chin2 00269,chin2 00270,chin2 00271,chin2 00272,chin2 00273,chin2 00274,chin2 00275,chin2 00276,chin2 00277,chin2 00278,chin2 00279,chin2 00280,chin2 00281,chin2 00282,chin2 00283,chin2 00284,chin2 00285,chin2 00286,chin2 00287,chin2 00288,chin2 00289,chin2 00290,chin2 00291,chin2 00292,chin2 00293,chin2 00294,chin2 00295,chin2 00296,chin2 00297,chin2 00298,chin2 00299,chin2 00300,chin2 00301,chin2 00302,chin2 00303,chin2 00304,chin2 00305,chin2 00306,chin2 00307,chin2 00308,chin2 00309,chin2 00310,chin2 00311,chin2 00312,chin2 00313,chin2 00314,chin2 00315,chin2 00316,chin2 00317,chin2 00318,chin2 00319,chin2 00320,chin2 00321,chin2 00322,chin2 00323,chin2 00324,chin2 00325,chin2 00326,chin2 00327,chin2 00328,chin2 00329,chin2 00330,chin2 00331,chin2 00332,chin2 00333,chin2 00334,chin2 00335,chin2 00336,chin2 00337,chin2 00338,chin2 00339,chin2 00340,chin2 00341,chin2 00342,chin2 00343,chin2 00344,chin2 00345,chin2 00346,chin2 00347,chin2 00348,chin2 00349,chin2 00350,chin2 00351,chin2 00352,chin2 00353,chin2 00354,chin2 00355,chin2 00356,chin2 00357,chin2 00358,chin2 00359,chin2 00400,chiu 00401,chiu 00402,chiu 00403,chiu 00404,chiu 00405,chiu 00406,chiu 00407,chiu 00408,chiu 00409,chiu 00410,chiu 00411,chiu 00412,chiu 00413,chiu 00414,chiu 00415,chiu 00416,chiu 00417,chiu 00418,chiu 00419,chiu 00420,chiu 00421,chiu 00422,chiu 00423,chiu 00424,chiu 00425,chiu 00426,chiu 00427,chiu 00428,chiu 00429,chiu 00430,chiu 00431,chiu 00432,chiu 00433,chiu 00434,chiu 00435,chiu 00436,chiu 00437,chiu 00438,chiu 00439,chiu 00440,chiu 00441,chiu 00442,chiu 00443,chiu 00444,chiu 00445,chiu 00446,chiu 00447,chiu 00448,chiu 00449,chiu 00450,chiu 00451,chiu 00452,chiu 00453,chiu 00454,chiu 00455,chiu 00456,chiu 00457,chiu 00458,chiu 00459,chiu 00460,chiu 00461,chiu 00462,chiu 00463,chiu 00464,chiu 00465,chiu 00466,chiu 00467,chiu 00468,chiu 00469,chiu 00470,chiu 00471,chiu 00472,chiu 00473,chiu 00474,chiu 00475,chiu 00476,chiu 00477,chiu 00478,chiu 00479,chiu 00480,chiu 00481,chiu 00482,chiu 00483,chiu 00484,chiu 00485,chiu 00486,chiu 00487,chiu 00488,chiu 00489,chiu 00490,chiu 00491,chiu 00492,chiu 00493,chiu 00494,chiu 00495,chiu 00496,chiu 00497,chiu 00498,chiu 00499,chiu 00500,chiu 00501,chiu 00502,chiu 00503,chiu 00504,chiu 00505,chiu 00506,chiu 00507,chiu 00508,chiu 00509,chiu 00510,chiu 00511,chiu 00512,chiu 00513,chiu 00514,chiu 00515,chiu 00516,chiu 00517,chiu 00518,chiu 00519,chiu 00520,chiu 00521,chiu 00522,chiu 00523,chiu 00524,chiu 00525,chiu 00526,chiu 00527,chiu 00528,chiu 00529,chiu 00530,chiu 00531,chiu 00532,chiu 00533,chiu 00534,chiu 00535,chiu 00536,chiu 00537,chiu 00538,chiu 00539,chiu 00540,chiu 00541,chiu 00542,chiu 00543,chiu 00544,chiu 00545,chiu 00546,chiu 00547,chiu 00548,chiu 00549,chiu 00550,chiu 00551,chiu 00552,chiu 00553,chiu 00554,chiu 00555,chiu 00556,chiu 00557,chiu 00558,chiu 00559,chiu 00600,cup 00601,cup 00602,cup 00603,cup 00604,cup 00605,cup 00606,cup 00607,cup 00608,cup 00609,cup 00610,cup 00611,cup 00612,cup 00613,cup 00614,cup 00615,cup 00616,cup 00617,cup 00618,cup 00619,cup 00620,cup 00621,cup 00622,cup 00623,cup 00624,cup 00625,cup 00626,cup 00627,cup 00628,cup 00629,cup 00630,cup 00631,cup 00632,cup 00633,cup 00634,cup 00635,cup 00636,cup 00637,cup 00638,cup 00639,cup 00640,cup 00641,cup 00642,cup 00643,cup 00644,cup 00645,cup 00646,cup 00647,cup 00648,cup 00649,cup 00650,cup 00651,cup 00652,cup 00653,cup 00654,cup 00655,cup 00656,cup 00657,cup 00658,cup 00659,cup 00660,cup 00661,cup 00662,cup 00663,cup 00664,cup 00665,cup 00666,cup 00667,cup 00668,cup 00669,cup 00670,cup 00671,cup 00672,cup 00673,cup 00674,cup 00675,cup 00676,cup 00677,cup 00678,cup 00679,cup 00680,cup 00681,cup 00682,cup 00683,cup 00684,cup 00685,cup 00686,cup 00687,cup 00688,cup 00689,cup 00690,cup 00691,cup 00692,cup 00693,cup 00694,cup 00695,cup 00696,cup 00697,cup 00698,cup 00699,cup 00700,cup 00701,cup 00702,cup 00703,cup 00704,cup 00705,cup 00706,cup 00707,cup 00708,cup 00709,cup 00710,cup 00711,cup 00712,cup 00713,cup 00714,cup 00715,cup 00716,cup 00717,cup 00718,cup 00719,cup 00720,cup 00721,cup 00722,cup 00723,cup 00724,cup 00725,cup 00726,cup 00727,cup 00728,cup 00729,cup 00730,cup 00731,cup 00732,cup 00733,cup 00734,cup 00735,cup 00736,cup 00737,cup 00738,cup 00739,cup 00740,cup 00741,cup 00742,cup 00743,cup 00744,cup 00745,cup 00746,cup 00747,cup 00748,cup 00749,cup 00750,cup 00751,cup 00752,cup 00753,cup 00754,cup 00755,cup 00756,cup 00757,cup 00758,cup 00759,cup 00800,ho 00801,ho 00802,ho 00803,ho 00804,ho 00805,ho 00806,ho 00807,ho 00808,ho 00809,ho 00810,ho 00811,ho 00812,ho 00813,ho 00814,ho 00815,ho 00816,ho 00817,ho 00818,ho 00819,ho 00820,ho 00821,ho 00822,ho 00823,ho 00824,ho 00825,ho 00826,ho 00827,ho 00828,ho 00829,ho 00830,ho 00831,ho 00832,ho 00833,ho 00834,ho 00835,ho 00836,ho 00837,ho 00838,ho 00839,ho 00840,ho 00841,ho 00842,ho 00843,ho 00844,ho 00845,ho 00846,ho 00847,ho 00848,ho 00849,ho 00850,ho 00851,ho 00852,ho 00853,ho 00854,ho 00855,ho 00856,ho 00857,ho 00858,ho 00859,ho 00860,ho 00861,ho 00862,ho 00863,ho 00864,ho 00865,ho 00866,ho 00867,ho 00868,ho 00869,ho 00870,ho 00871,ho 00872,ho 00873,ho 00874,ho 00875,ho 00876,ho 00877,ho 00878,ho 00879,ho 00880,ho 00881,ho 00882,ho 00883,ho 00884,ho 00885,ho 00886,ho 00887,ho 00888,ho 00889,ho 00890,ho 00891,ho 00892,ho 00893,ho 00894,ho 00895,ho 00896,ho 00897,ho 00898,ho 00899,ho 00900,ho 00901,ho 00902,ho 00903,ho 00904,ho 00905,ho 00906,ho 00907,ho 00908,ho 00909,ho 00910,ho 00911,ho 00912,ho 00913,ho 00914,ho 00915,ho 00916,ho 00917,ho 00918,ho 00919,ho 00920,ho 00921,ho 00922,ho 00923,ho 00924,ho 00925,ho 00926,ho 00927,ho 00928,ho 00929,ho 00930,ho 00931,ho 00932,ho 00933,ho 00934,ho 00935,ho 00936,ho 00937,ho 00938,ho 00939,ho 00940,ho 00941,ho 00942,ho 00943,ho 00944,ho 00945,ho 00946,ho 00947,ho 00948,ho 00949,ho 00950,ho 00951,ho 00952,ho 00953,ho 00954,ho 00955,ho 00956,ho 00957,ho 00958,ho 00959,ho 01000,ka 01001,ka 01002,ka 01003,ka 01004,ka 01005,ka 01006,ka 01007,ka 01008,ka 01009,ka 01010,ka 01011,ka 01012,ka 01013,ka 01014,ka 01015,ka 01016,ka 01017,ka 01018,ka 01019,ka 01020,ka 01021,ka 01022,ka 01023,ka 01024,ka 01025,ka 01026,ka 01027,ka 01028,ka 01029,ka 01030,ka 01031,ka 01032,ka 01033,ka 01034,ka 01035,ka 01036,ka 01037,ka 01038,ka 01039,ka 01040,ka 01041,ka 01042,ka 01043,ka 01044,ka 01045,ka 01046,ka 01047,ka 01048,ka 01049,ka 01050,ka 01051,ka 01052,ka 01053,ka 01054,ka 01055,ka 01056,ka 01057,ka 01058,ka 01059,ka 01060,ka 01061,ka 01062,ka 01063,ka 01064,ka 01065,ka 01066,ka 01067,ka 01068,ka 01069,ka 01070,ka 01071,ka 01072,ka 01073,ka 01074,ka 01075,ka 01076,ka 01077,ka 01078,ka 01079,ka 01080,ka 01081,ka 01082,ka 01083,ka 01084,ka 01085,ka 01086,ka 01087,ka 01088,ka 01089,ka 01090,ka 01091,ka 01092,ka 01093,ka 01094,ka 01095,ka 01096,ka 01097,ka 01098,ka 01099,ka 01100,ka 01101,ka 01102,ka 01103,ka 01104,ka 01105,ka 01106,ka 01107,ka 01108,ka 01109,ka 01110,ka 01111,ka 01112,ka 01113,ka 01114,ka 01115,ka 01116,ka 01117,ka 01118,ka 01119,ka 01120,ka 01121,ka 01122,ka 01123,ka 01124,ka 01125,ka 01126,ka 01127,ka 01128,ka 01129,ka 01130,ka 01131,ka 01132,ka 01133,ka 01134,ka 01135,ka 01136,ka 01137,ka 01138,ka 01139,ka 01140,ka 01141,ka 01142,ka 01143,ka 01144,ka 01145,ka 01146,ka 01147,ka 01148,ka 01149,ka 01150,ka 01151,ka 01152,ka 01153,ka 01154,ka 01155,ka 01156,ka 01157,ka 01158,ka 01159,ka 01200,ma 01201,ma 01202,ma 01203,ma 01204,ma 01205,ma 01206,ma 01207,ma 01208,ma 01209,ma 01210,ma 01211,ma 01212,ma 01213,ma 01214,ma 01215,ma 01216,ma 01217,ma 01218,ma 01219,ma 01220,ma 01221,ma 01222,ma 01223,ma 01224,ma 01225,ma 01226,ma 01227,ma 01228,ma 01229,ma 01230,ma 01231,ma 01232,ma 01233,ma 01234,ma 01235,ma 01236,ma 01237,ma 01238,ma 01239,ma 01240,ma 01241,ma 01242,ma 01243,ma 01244,ma 01245,ma 01246,ma 01247,ma 01248,ma 01249,ma 01250,ma 01251,ma 01252,ma 01253,ma 01254,ma 01255,ma 01256,ma 01257,ma 01258,ma 01259,ma 01260,ma 01261,ma 01262,ma 01263,ma 01264,ma 01265,ma 01266,ma 01267,ma 01268,ma 01269,ma 01270,ma 01271,ma 01272,ma 01273,ma 01274,ma 01275,ma 01276,ma 01277,ma 01278,ma 01279,ma 01280,ma 01281,ma 01282,ma 01283,ma 01284,ma 01285,ma 01286,ma 01287,ma 01288,ma 01289,ma 01290,ma 01291,ma 01292,ma 01293,ma 01294,ma 01295,ma 01296,ma 01297,ma 01298,ma 01299,ma 01300,ma 01301,ma 01302,ma 01303,ma 01304,ma 01305,ma 01306,ma 01307,ma 01308,ma 01309,ma 01310,ma 01311,ma 01312,ma 01313,ma 01314,ma 01315,ma 01316,ma 01317,ma 01318,ma 01319,ma 01320,ma 01321,ma 01322,ma 01323,ma 01324,ma 01325,ma 01326,ma 01327,ma 01328,ma 01329,ma 01330,ma 01331,ma 01332,ma 01333,ma 01334,ma 01335,ma 01336,ma 01337,ma 01338,ma 01339,ma 01340,ma 01341,ma 01342,ma 01343,ma 01344,ma 01345,ma 01346,ma 01347,ma 01348,ma 01349,ma 01350,ma 01351,ma 01352,ma 01353,ma 01354,ma 01355,ma 01356,ma 01357,ma 01358,ma 01359,ma 01400,sheung 01401,sheung 01402,sheung 01403,sheung 01404,sheung 01405,sheung 01406,sheung 01407,sheung 01408,sheung 01409,sheung 01410,sheung 01411,sheung 01412,sheung 01413,sheung 01414,sheung 01415,sheung 01416,sheung 01417,sheung 01418,sheung 01419,sheung 01420,sheung 01421,sheung 01422,sheung 01423,sheung 01424,sheung 01425,sheung 01426,sheung 01427,sheung 01428,sheung 01429,sheung 01430,sheung 01431,sheung 01432,sheung 01433,sheung 01434,sheung 01435,sheung 01436,sheung 01437,sheung 01438,sheung 01439,sheung 01440,sheung 01441,sheung 01442,sheung 01443,sheung 01444,sheung 01445,sheung 01446,sheung 01447,sheung 01448,sheung 01449,sheung 01450,sheung 01451,sheung 01452,sheung 01453,sheung 01454,sheung 01455,sheung 01456,sheung 01457,sheung 01458,sheung 01459,sheung 01460,sheung 01461,sheung 01462,sheung 01463,sheung 01464,sheung 01465,sheung 01466,sheung 01467,sheung 01468,sheung 01469,sheung 01470,sheung 01471,sheung 01472,sheung 01473,sheung 01474,sheung 01475,sheung 01476,sheung 01477,sheung 01478,sheung 01479,sheung 01480,sheung 01481,sheung 01482,sheung 01483,sheung 01484,sheung 01485,sheung 01486,sheung 01487,sheung 01488,sheung 01489,sheung 01490,sheung 01491,sheung 01492,sheung 01493,sheung 01494,sheung 01495,sheung 01496,sheung 01497,sheung 01498,sheung 01499,sheung 01500,sheung 01501,sheung 01502,sheung 01503,sheung 01504,sheung 01505,sheung 01506,sheung 01507,sheung 01508,sheung 01509,sheung 01510,sheung 01511,sheung 01512,sheung 01513,sheung 01514,sheung 01515,sheung 01516,sheung 01517,sheung 01518,sheung 01519,sheung 01520,sheung 01521,sheung 01522,sheung 01523,sheung 01524,sheung 01525,sheung 01526,sheung 01527,sheung 01528,sheung 01529,sheung 01530,sheung 01531,sheung 01532,sheung 01533,sheung 01534,sheung 01535,sheung 01536,sheung 01537,sheung 01538,sheung 01539,sheung 01540,sheung 01541,sheung 01542,sheung 01543,sheung 01544,sheung 01545,sheung 01546,sheung 01547,sheung 01548,sheung 01549,sheung 01550,sheung 01551,sheung 01552,sheung 01553,sheung 01554,sheung 01555,sheung 01556,sheung 01557,sheung 01558,sheung 01559,sheung 01600,shi 01601,shi 01602,shi 01603,shi 01604,shi 01605,shi 01606,shi 01607,shi 01608,shi 01609,shi 01610,shi 01611,shi 01612,shi 01613,shi 01614,shi 01615,shi 01616,shi 01617,shi 01618,shi 01619,shi 01620,shi 01621,shi 01622,shi 01623,shi 01624,shi 01625,shi 01626,shi 01627,shi 01628,shi 01629,shi 01630,shi 01631,shi 01632,shi 01633,shi 01634,shi 01635,shi 01636,shi 01637,shi 01638,shi 01639,shi 01640,shi 01641,shi 01642,shi 01643,shi 01644,shi 01645,shi 01646,shi 01647,shi 01648,shi 01649,shi 01650,shi 01651,shi 01652,shi 01653,shi 01654,shi 01655,shi 01656,shi 01657,shi 01658,shi 01659,shi 01660,shi 01661,shi 01662,shi 01663,shi 01664,shi 01665,shi 01666,shi 01667,shi 01668,shi 01669,shi 01670,shi 01671,shi 01672,shi 01673,shi 01674,shi 01675,shi 01676,shi 01677,shi 01678,shi 01679,shi 01680,shi 01681,shi 01682,shi 01683,shi 01684,shi 01685,shi 01686,shi 01687,shi 01688,shi 01689,shi 01690,shi 01691,shi 01692,shi 01693,shi 01694,shi 01695,shi 01696,shi 01697,shi 01698,shi 01699,shi 01700,shi 01701,shi 01702,shi 01703,shi 01704,shi 01705,shi 01706,shi 01707,shi 01708,shi 01709,shi 01710,shi 01711,shi 01712,shi 01713,shi 01714,shi 01715,shi 01716,shi 01717,shi 01718,shi 01719,shi 01720,shi 01721,shi 01722,shi 01723,shi 01724,shi 01725,shi 01726,shi 01727,shi 01728,shi 01729,shi 01730,shi 01731,shi 01732,shi 01733,shi 01734,shi 01735,shi 01736,shi 01737,shi 01738,shi 01739,shi 01740,shi 01741,shi 01742,shi 01743,shi 01744,shi 01745,shi 01746,shi 01747,shi 01748,shi 01749,shi 01750,shi 01751,shi 01752,shi 01753,shi 01754,shi 01755,shi 01756,shi 01757,shi 01758,shi 01759,shi 01800,yi 01801,yi 01802,yi 01803,yi 01804,yi 01805,yi 01806,yi 01807,yi 01808,yi 01809,yi 01810,yi 01811,yi 01812,yi 01813,yi 01814,yi 01815,yi 01816,yi 01817,yi 01818,yi 01819,yi 01820,yi 01821,yi 01822,yi 01823,yi 01824,yi 01825,yi 01826,yi 01827,yi 01828,yi 01829,yi 01830,yi 01831,yi 01832,yi 01833,yi 01834,yi 01835,yi 01836,yi 01837,yi 01838,yi 01839,yi 01840,yi 01841,yi 01842,yi 01843,yi 01844,yi 01845,yi 01846,yi 01847,yi 01848,yi 01849,yi 01850,yi 01851,yi 01852,yi 01853,yi 01854,yi 01855,yi 01856,yi 01857,yi 01858,yi 01859,yi 01860,yi 01861,yi 01862,yi 01863,yi 01864,yi 01865,yi 01866,yi 01867,yi 01868,yi 01869,yi 01870,yi 01871,yi 01872,yi 01873,yi 01874,yi 01875,yi 01876,yi 01877,yi 01878,yi 01879,yi 01880,yi 01881,yi 01882,yi 01883,yi 01884,yi 01885,yi 01886,yi 01887,yi 01888,yi 01889,yi 01890,yi 01891,yi 01892,yi 01893,yi 01894,yi 01895,yi 01896,yi 01897,yi 01898,yi 01899,yi 01900,yi 01901,yi 01902,yi 01903,yi 01904,yi 01905,yi 01906,yi 01907,yi 01908,yi 01909,yi 01910,yi 01911,yi 01912,yi 01913,yi 01914,yi 01915,yi 01916,yi 01917,yi 01918,yi 01919,yi 01920,yi 01921,yi 01922,yi 01923,yi 01924,yi 01925,yi 01926,yi 01927,yi 01928,yi 01929,yi 01930,yi 01931,yi 01932,yi 01933,yi 01934,yi 01935,yi 01936,yi 01937,yi 01938,yi 01939,yi 01940,yi 01941,yi 01942,yi 01943,yi 01944,yi 01945,yi 01946,yi 01947,yi 01948,yi 01949,yi 01950,yi 01951,yi 01952,yi 01953,yi 01954,yi 01955,yi 01956,yi 01957,yi 01958,yi 01959,yi 02000,sin 02001,sin 02002,sin 02003,sin 02004,sin 02005,sin 02006,sin 02007,sin 02008,sin 02009,sin 02010,sin 02011,sin 02012,sin 02013,sin 02014,sin 02015,sin 02016,sin 02017,sin 02018,sin 02019,sin 02020,sin 02021,sin 02022,sin 02023,sin 02024,sin 02025,sin 02026,sin 02027,sin 02028,sin 02029,sin 02030,sin 02031,sin 02032,sin 02033,sin 02034,sin 02035,sin 02036,sin 02037,sin 02038,sin 02039,sin 02040,sin 02041,sin 02042,sin 02043,sin 02044,sin 02045,sin 02046,sin 02047,sin 02048,sin 02049,sin 02050,sin 02051,sin 02052,sin 02053,sin 02054,sin 02055,sin 02056,sin 02057,sin 02058,sin 02059,sin 02060,sin 02061,sin 02062,sin 02063,sin 02064,sin 02065,sin 02066,sin 02067,sin 02068,sin 02069,sin 02070,sin 02071,sin 02072,sin 02073,sin 02074,sin 02075,sin 02076,sin 02077,sin 02078,sin 02079,sin 02080,sin 02081,sin 02082,sin 02083,sin 02084,sin 02085,sin 02086,sin 02087,sin 02088,sin 02089,sin 02090,sin 02091,sin 02092,sin 02093,sin 02094,sin 02095,sin 02096,sin 02097,sin 02098,sin 02099,sin 02100,sin 02101,sin 02102,sin 02103,sin 02104,sin 02105,sin 02106,sin 02107,sin 02108,sin 02109,sin 02110,sin 02111,sin 02112,sin 02113,sin 02114,sin 02115,sin 02116,sin 02117,sin 02118,sin 02119,sin 02120,sin 02121,sin 02122,sin 02123,sin 02124,sin 02125,sin 02126,sin 02127,sin 02128,sin 02129,sin 02130,sin 02131,sin 02132,sin 02133,sin 02134,sin 02135,sin 02136,sin 02137,sin 02138,sin 02139,sin 02140,sin 02141,sin 02142,sin 02143,sin 02144,sin 02145,sin 02146,sin 02147,sin 02148,sin 02149,sin 02150,sin 02151,sin 02152,sin 02153,sin 02154,sin 02155,sin 02156,sin 02157,sin 02158,sin 02159,sin 02200,ngou 02201,ngou 02202,ngou 02203,ngou 02204,ngou 02205,ngou 02206,ngou 02207,ngou 02208,ngou 02209,ngou 02210,ngou 02211,ngou 02212,ngou 02213,ngou 02214,ngou 02215,ngou 02216,ngou 02217,ngou 02218,ngou 02219,ngou 02220,ngou 02221,ngou 02222,ngou 02223,ngou 02224,ngou 02225,ngou 02226,ngou 02227,ngou 02228,ngou 02229,ngou 02230,ngou 02231,ngou 02232,ngou 02233,ngou 02234,ngou 02235,ngou 02236,ngou 02237,ngou 02238,ngou 02239,ngou 02240,ngou 02241,ngou 02242,ngou 02243,ngou 02244,ngou 02245,ngou 02246,ngou 02247,ngou 02248,ngou 02249,ngou 02250,ngou 02251,ngou 02252,ngou 02253,ngou 02254,ngou 02255,ngou 02256,ngou 02257,ngou 02258,ngou 02259,ngou 02260,ngou 02261,ngou 02262,ngou 02263,ngou 02264,ngou 02265,ngou 02266,ngou 02267,ngou 02268,ngou 02269,ngou 02270,ngou 02271,ngou 02272,ngou 02273,ngou 02274,ngou 02275,ngou 02276,ngou 02277,ngou 02278,ngou 02279,ngou 02280,ngou 02281,ngou 02282,ngou 02283,ngou 02284,ngou 02285,ngou 02286,ngou 02287,ngou 02288,ngou 02289,ngou 02290,ngou 02291,ngou 02292,ngou 02293,ngou 02294,ngou 02295,ngou 02296,ngou 02297,ngou 02298,ngou 02299,ngou 02300,ngou 02301,ngou 02302,ngou 02303,ngou 02304,ngou 02305,ngou 02306,ngou 02307,ngou 02308,ngou 02309,ngou 02310,ngou 02311,ngou 02312,ngou 02313,ngou 02314,ngou 02315,ngou 02316,ngou 02317,ngou 02318,ngou 02319,ngou 02320,ngou 02321,ngou 02322,ngou 02323,ngou 02324,ngou 02325,ngou 02326,ngou 02327,ngou 02328,ngou 02329,ngou 02330,ngou 02331,ngou 02332,ngou 02333,ngou 02334,ngou 02335,ngou 02336,ngou 02337,ngou 02338,ngou 02339,ngou 02340,ngou 02341,ngou 02342,ngou 02343,ngou 02344,ngou 02345,ngou 02346,ngou 02347,ngou 02348,ngou 02349,ngou 02350,ngou 02351,ngou 02352,ngou 02353,ngou 02354,ngou 02355,ngou 02356,ngou 02357,ngou 02358,ngou 02359,ngou 02400,lai 02401,lai 02402,lai 02403,lai 02404,lai 02405,lai 02406,lai 02407,lai 02408,lai 02409,lai 02410,lai 02411,lai 02412,lai 02413,lai 02414,lai 02415,lai 02416,lai 02417,lai 02418,lai 02419,lai 02420,lai 02421,lai 02422,lai 02423,lai 02424,lai 02425,lai 02426,lai 02427,lai 02428,lai 02429,lai 02430,lai 02431,lai 02432,lai 02433,lai 02434,lai 02435,lai 02436,lai 02437,lai 02438,lai 02439,lai 02440,lai 02441,lai 02442,lai 02443,lai 02444,lai 02445,lai 02446,lai 02447,lai 02448,lai 02449,lai 02450,lai 02451,lai 02452,lai 02453,lai 02454,lai 02455,lai 02456,lai 02457,lai 02458,lai 02459,lai 02460,lai 02461,lai 02462,lai 02463,lai 02464,lai 02465,lai 02466,lai 02467,lai 02468,lai 02469,lai 02470,lai 02471,lai 02472,lai 02473,lai 02474,lai 02475,lai 02476,lai 02477,lai 02478,lai 02479,lai 02480,lai 02481,lai 02482,lai 02483,lai 02484,lai 02485,lai 02486,lai 02487,lai 02488,lai 02489,lai 02490,lai 02491,lai 02492,lai 02493,lai 02494,lai 02495,lai 02496,lai 02497,lai 02498,lai 02499,lai 02500,lai 02501,lai 02502,lai 02503,lai 02504,lai 02505,lai 02506,lai 02507,lai 02508,lai 02509,lai 02510,lai 02511,lai 02512,lai 02513,lai 02514,lai 02515,lai 02516,lai 02517,lai 02518,lai 02519,lai 02520,lai 02521,lai 02522,lai 02523,lai 02524,lai 02525,lai 02526,lai 02527,lai 02528,lai 02529,lai 02530,lai 02531,lai 02532,lai 02533,lai 02534,lai 02535,lai 02536,lai 02537,lai 02538,lai 02539,lai 02540,lai 02541,lai 02542,lai 02543,lai 02544,lai 02545,lai 02546,lai 02547,lai 02548,lai 02549,lai 02550,lai 02551,lai 02552,lai 02553,lai 02554,lai 02555,lai 02556,lai 02557,lai 02558,lai 02559,lai ================================================ FILE: training-character.gh/valLabels.csv ================================================ 00160,cheung 00161,cheung 00162,cheung 00163,cheung 00164,cheung 00165,cheung 00166,cheung 00167,cheung 00168,cheung 00169,cheung 00170,cheung 00171,cheung 00172,cheung 00173,cheung 00174,cheung 00175,cheung 00176,cheung 00177,cheung 00178,cheung 00179,cheung 00180,cheung 00181,cheung 00182,cheung 00183,cheung 00184,cheung 00185,cheung 00186,cheung 00187,cheung 00188,cheung 00189,cheung 00190,cheung 00191,cheung 00192,cheung 00193,cheung 00194,cheung 00195,cheung 00196,cheung 00197,cheung 00198,cheung 00199,cheung 00360,chin2 00361,chin2 00362,chin2 00363,chin2 00364,chin2 00365,chin2 00366,chin2 00367,chin2 00368,chin2 00369,chin2 00370,chin2 00371,chin2 00372,chin2 00373,chin2 00374,chin2 00375,chin2 00376,chin2 00377,chin2 00378,chin2 00379,chin2 00380,chin2 00381,chin2 00382,chin2 00383,chin2 00384,chin2 00385,chin2 00386,chin2 00387,chin2 00388,chin2 00389,chin2 00390,chin2 00391,chin2 00392,chin2 00393,chin2 00394,chin2 00395,chin2 00396,chin2 00397,chin2 00398,chin2 00399,chin2 00560,chiu 00561,chiu 00562,chiu 00563,chiu 00564,chiu 00565,chiu 00566,chiu 00567,chiu 00568,chiu 00569,chiu 00570,chiu 00571,chiu 00572,chiu 00573,chiu 00574,chiu 00575,chiu 00576,chiu 00577,chiu 00578,chiu 00579,chiu 00580,chiu 00581,chiu 00582,chiu 00583,chiu 00584,chiu 00585,chiu 00586,chiu 00587,chiu 00588,chiu 00589,chiu 00590,chiu 00591,chiu 00592,chiu 00593,chiu 00594,chiu 00595,chiu 00596,chiu 00597,chiu 00598,chiu 00599,chiu 00760,cup 00761,cup 00762,cup 00763,cup 00764,cup 00765,cup 00766,cup 00767,cup 00768,cup 00769,cup 00770,cup 00771,cup 00772,cup 00773,cup 00774,cup 00775,cup 00776,cup 00777,cup 00778,cup 00779,cup 00780,cup 00781,cup 00782,cup 00783,cup 00784,cup 00785,cup 00786,cup 00787,cup 00788,cup 00789,cup 00790,cup 00791,cup 00792,cup 00793,cup 00794,cup 00795,cup 00796,cup 00797,cup 00798,cup 00799,cup 00960,ho 00961,ho 00962,ho 00963,ho 00964,ho 00965,ho 00966,ho 00967,ho 00968,ho 00969,ho 00970,ho 00971,ho 00972,ho 00973,ho 00974,ho 00975,ho 00976,ho 00977,ho 00978,ho 00979,ho 00980,ho 00981,ho 00982,ho 00983,ho 00984,ho 00985,ho 00986,ho 00987,ho 00988,ho 00989,ho 00990,ho 00991,ho 00992,ho 00993,ho 00994,ho 00995,ho 00996,ho 00997,ho 00998,ho 00999,ho 01160,ka 01161,ka 01162,ka 01163,ka 01164,ka 01165,ka 01166,ka 01167,ka 01168,ka 01169,ka 01170,ka 01171,ka 01172,ka 01173,ka 01174,ka 01175,ka 01176,ka 01177,ka 01178,ka 01179,ka 01180,ka 01181,ka 01182,ka 01183,ka 01184,ka 01185,ka 01186,ka 01187,ka 01188,ka 01189,ka 01190,ka 01191,ka 01192,ka 01193,ka 01194,ka 01195,ka 01196,ka 01197,ka 01198,ka 01199,ka 01360,ma 01361,ma 01362,ma 01363,ma 01364,ma 01365,ma 01366,ma 01367,ma 01368,ma 01369,ma 01370,ma 01371,ma 01372,ma 01373,ma 01374,ma 01375,ma 01376,ma 01377,ma 01378,ma 01379,ma 01380,ma 01381,ma 01382,ma 01383,ma 01384,ma 01385,ma 01386,ma 01387,ma 01388,ma 01389,ma 01390,ma 01391,ma 01392,ma 01393,ma 01394,ma 01395,ma 01396,ma 01397,ma 01398,ma 01399,ma 01560,sheung 01561,sheung 01562,sheung 01563,sheung 01564,sheung 01565,sheung 01566,sheung 01567,sheung 01568,sheung 01569,sheung 01570,sheung 01571,sheung 01572,sheung 01573,sheung 01574,sheung 01575,sheung 01576,sheung 01577,sheung 01578,sheung 01579,sheung 01580,sheung 01581,sheung 01582,sheung 01583,sheung 01584,sheung 01585,sheung 01586,sheung 01587,sheung 01588,sheung 01589,sheung 01590,sheung 01591,sheung 01592,sheung 01593,sheung 01594,sheung 01595,sheung 01596,sheung 01597,sheung 01598,sheung 01599,sheung 01760,shi 01761,shi 01762,shi 01763,shi 01764,shi 01765,shi 01766,shi 01767,shi 01768,shi 01769,shi 01770,shi 01771,shi 01772,shi 01773,shi 01774,shi 01775,shi 01776,shi 01777,shi 01778,shi 01779,shi 01780,shi 01781,shi 01782,shi 01783,shi 01784,shi 01785,shi 01786,shi 01787,shi 01788,shi 01789,shi 01790,shi 01791,shi 01792,shi 01793,shi 01794,shi 01795,shi 01796,shi 01797,shi 01798,shi 01799,shi 01960,yi 01961,yi 01962,yi 01963,yi 01964,yi 01965,yi 01966,yi 01967,yi 01968,yi 01969,yi 01970,yi 01971,yi 01972,yi 01973,yi 01974,yi 01975,yi 01976,yi 01977,yi 01978,yi 01979,yi 01980,yi 01981,yi 01982,yi 01983,yi 01984,yi 01985,yi 01986,yi 01987,yi 01988,yi 01989,yi 01990,yi 01991,yi 01992,yi 01993,yi 01994,yi 01995,yi 01996,yi 01997,yi 01998,yi 01999,yi 02160,sin 02161,sin 02162,sin 02163,sin 02164,sin 02165,sin 02166,sin 02167,sin 02168,sin 02169,sin 02170,sin 02171,sin 02172,sin 02173,sin 02174,sin 02175,sin 02176,sin 02177,sin 02178,sin 02179,sin 02180,sin 02181,sin 02182,sin 02183,sin 02184,sin 02185,sin 02186,sin 02187,sin 02188,sin 02189,sin 02190,sin 02191,sin 02192,sin 02193,sin 02194,sin 02195,sin 02196,sin 02197,sin 02198,sin 02199,sin 02360,ngou 02361,ngou 02362,ngou 02363,ngou 02364,ngou 02365,ngou 02366,ngou 02367,ngou 02368,ngou 02369,ngou 02370,ngou 02371,ngou 02372,ngou 02373,ngou 02374,ngou 02375,ngou 02376,ngou 02377,ngou 02378,ngou 02379,ngou 02380,ngou 02381,ngou 02382,ngou 02383,ngou 02384,ngou 02385,ngou 02386,ngou 02387,ngou 02388,ngou 02389,ngou 02390,ngou 02391,ngou 02392,ngou 02393,ngou 02394,ngou 02395,ngou 02396,ngou 02397,ngou 02398,ngou 02399,ngou 02560,lai 02561,lai 02562,lai 02563,lai 02564,lai 02565,lai 02566,lai 02567,lai 02568,lai 02569,lai 02570,lai 02571,lai 02572,lai 02573,lai 02574,lai 02575,lai 02576,lai 02577,lai 02578,lai 02579,lai 02580,lai 02581,lai 02582,lai 02583,lai 02584,lai 02585,lai 02586,lai 02587,lai 02588,lai 02589,lai 02590,lai 02591,lai 02592,lai 02593,lai 02594,lai 02595,lai 02596,lai 02597,lai 02598,lai 02599,lai