![](\"https://media-exp1.licdn.com/dms/image/C4E12AQH04kcWT-WgHg/article-inline_image-shrink_1000_1488/0?e=1587600000&v=beta&t=UFRHUOCDUQGLPgRX0qywCt3ytjnsA4kM-W4zqvJ2gWk\")
\nLa inteligencia artificial permite actuar sobre muchos campos empresariales, y automatizar de manera eficaz procesos de negocio, en este articulo se propone una tarea simple de extracción de texto de una imagen similar a una placa mediante la aplicación de redes convolucionales y recurrentes que basándose en una imagen de entrada predice el texto en la misma. Para esto es necesario tener un conjunto de datos, que dentro del campo del deep learning es la materia prima para poder generar modelos precisos.
\nTodo el código de este articulo se lo puede encontrar en el repositorio: (https://github.com/FabianBG/plate_recognition)
\nComo principal materia prima para el modelo que se entrenará, se procede con un generador de imágenes que cumplirá la función de crear un conjunto de imágenes al azar, para esto en nuestro código definimos un generador que cree imágenes basados en el formato de una placa de automóvil (No seremos estrictos con la validación de las mismas).
\n# Python3\n# plate_recognition/src/ocr_plate.py\n\ndef random_plate():\n\t size = randint(plate_min, plate_max)\n\t letter = ""\n\t number = ""\n\t for _ in range(size):\n\t letter = letter +\n chr(big_letters[randint(0, len(big_letters) - 1)])\n\t number = number + chr(digits[randint(0, len(digits) - 1)])\n\t return letter + "-" + number\n\ndef get_plate(size, empty=False):\n\t plate = random_plate()\n\t font = ImageFont.truetype(font_path, 30)\n\t img = Image.new('RGB', size, (0,0,0))\n\t draw = ImageDraw.Draw(img)\n\t rounded_rectangle(draw, ((0, 0), size), 20,\n fill=(255, 255, 255), outline=(255, 255, 255))\n\t draw.text((25,10), plate, font=font, fill=(0,0,0))\n\t img = np.array(img.convert('L'))\n\t img = img.astype(np.float32) / 255\n\t img = np.expand_dims(img, 0)\n\t return img, plate\n\t\n\n\t\n\n\t\n\n\tdef image_generator(size, img_w, img_h, downsample_factor):\n\t if K.image_data_format() == 'channels_first':\n\t X_data = np.ones([size, 1, img_w, img_h])\n\t else:\n\t X_data = np.ones([size, img_w, img_h, 1])\n\t labels = np.ones([size, absolute_max_string_len])\n\t input_length = np.zeros([size, 1])\n\t label_length = np.zeros([size, 1])\n\t source_str = []\n\t for i in range(size):\n\t data, world = get_plate(image_size, True)\n\t if K.image_data_format() == 'channels_first':\n\t X_data[i, 0, 0:img_w, :] = np.array(data).T\n\t else:\n\t X_data[i, 0:img_w, :, 0] = data[0, :, :].T\n\t labels[i] = np.ones(absolute_max_string_len) * -1\n\t labels[i, 0:len(world)] = text_to_labels(world)\n\t input_length[i] = img_w // downsample_factor - 2\n\t label_length[i] = [len(world)]\n\t source_str.append(world)\n\t inputs = {'input': X_data,\n\t 'labels': labels,\n\t 'input_length': input_length,\n\t 'label_length': label_length,\n\t 'source_str': source_str\n\t }\n\t outputs = {'ctc': np.zeros([size])}\n\t return (inputs, outputs)En el fragmento de código anterior se muestra las funciones principales para generar conjuntos de imágenes. Principalmente se obtiene una cadena de texto con el texto de la placa a generar esto mediante la función random_plate() esta función proporciona al azar una serie de 3 o 4 letras separadas por un guion y otra serie de 3 o 4 números.
\nUna vez proporcionado el texto a dibujar la función get_plate() se encarga de pintar una imagen, que a su vez es usada por la función image_generator() que se encarga de modelar la estructura de datos para nuestro modelo.
\nLa estructura de entrada consta de 4 elementos:
\nAl final se define un generador que constantemente esta alimentando el modelo:
\n# Python3\n# plate_recognition/src/ocr_plate.py\n\ndef batch_generator(size):while 1:\n data = image_generator(size, img_w=200, img_h=50, downsample_factor=4)\n yield dataEste recibe un tamaño de conjunto para generar el mismo.
\nUna lista la materia prima del modelo, se genera un modelo compuesto principalmente de dos tipos de capas:
\nEl modelo es generado mediante el siguiente fragmento de codigo:
\n# Python3\n# plate_recognition/src/ocr_plate.py\n\ndef model(input_shape, output_shape, absolute_max_string_len):# Input Parameters\n img_h = input_shape[1]\n img_w = input_shape[0]\n \n # Network parameters\n conv_filters = 16\n kernel_size = (3, 3)\n pool_size = 2\n time_dense_size = 32\n rnn_size = 512\n\n\n if K.image_data_format() == 'channels_first':\n input_shape = (1, img_w, img_h)\n else:\n input_shape = (img_w, img_h, 1)\n\n\n act = 'relu'\n input_data = Input(name='input', shape=input_shape, dtype='float32')\n inner = Conv2D(conv_filters, kernel_size, padding='same',\n activation=act, kernel_initializer='he_normal',\n name='conv1')(input_data)\n inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)\n inner = Conv2D(conv_filters, kernel_size, padding='same',\n activation=act, kernel_initializer='he_normal',\n name='conv2')(inner)\n inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner)\n\n\n conv_to_rnn_dims = (img_w // (pool_size ** 2),\n (img_h // (pool_size ** 2)) * conv_filters)\n inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner)\n inner = Dense(time_dense_size, activation=act, name='dense1')(inner)\n gru_1 = GRU(rnn_size, return_sequences=True,\n kernel_initializer='he_normal', name='gru1')(inner)\n gru_1b = GRU(rnn_size, return_sequences=True,\n go_backwards=True, kernel_initializer='he_normal',\n name='gru1_b')(inner)\n gru1_merged = add([gru_1, gru_1b])\n gru_2 = GRU(rnn_size, return_sequences=True,\n kernel_initializer='he_normal', name='gru2')(gru1_merged)\n gru_2b = GRU(rnn_size, return_sequences=True, go_backwards=True,\n kernel_initializer='he_normal', name='gru2_b')(gru1_merged)\n inner = Dense(output_shape, kernel_initializer='he_normal',\n name='dense2')(concatenate([gru_2, gru_2b]))\n \n y_pred = Activation('softmax', name='softmax')(inner)\n Model(inputs=input_data, outputs=y_pred).summary()\n\n\n labels = Input(name='labels',\n shape=[absolute_max_string_len], dtype='float32')\n input_length = Input(name='input_length', shape=[1], dtype='int64')\n label_length = Input(name='label_length', shape=[1], dtype='int64')\n loss_out = Lambda(\n ctc_lambda_func, output_shape=(1,),\n name='ctc')([y_pred, labels, input_length, label_length])\n test_func = K.function([input_data], [y_pred])\n sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)\n model = Model(inputs=[input_data, labels, input_length, label_length],\n outputs=[loss_out, y_pred])\n model.compile(loss={'ctc': ctc, 'ctc': ctc}, optimizer=sgd)\n\n\n return model, test_funcQue de forma más simplificada consta del siguiente resumen:
\n# model.summary()\n\nTensorFlow version: 1.12.0\nKeras version: 2.2.4\n__________________________________________________________________________________________________\nLayer (type) Output Shape Param # Connected to \n==================================================================================================\ninput (InputLayer) (None, 200, 50, 1) 0 \n__________________________________________________________________________________________________\nconv1 (Conv2D) (None, 200, 50, 16) 160 input[0][0] \n__________________________________________________________________________________________________\nmax1 (MaxPooling2D) (None, 100, 25, 16) 0 conv1[0][0] \n__________________________________________________________________________________________________\nconv2 (Conv2D) (None, 100, 25, 16) 2320 max1[0][0] \n__________________________________________________________________________________________________\nmax2 (MaxPooling2D) (None, 50, 12, 16) 0 conv2[0][0] \n__________________________________________________________________________________________________\nreshape (Reshape) (None, 50, 192) 0 max2[0][0] \n__________________________________________________________________________________________________\ndense1 (Dense) (None, 50, 32) 6176 reshape[0][0] \n__________________________________________________________________________________________________\ngru1 (GRU) (None, 50, 512) 837120 dense1[0][0] \n__________________________________________________________________________________________________\ngru1_b (GRU) (None, 50, 512) 837120 dense1[0][0] \n__________________________________________________________________________________________________\nadd_1 (Add) (None, 50, 512) 0 gru1[0][0] \n gru1_b[0][0] \n__________________________________________________________________________________________________\ngru2 (GRU) (None, 50, 512) 1574400 add_1[0][0] \n__________________________________________________________________________________________________\ngru2_b (GRU) (None, 50, 512) 1574400 add_1[0][0] \n__________________________________________________________________________________________________\nconcatenate_1 (Concatenate) (None, 50, 1024) 0 gru2[0][0] \n gru2_b[0][0] \n__________________________________________________________________________________________________\ndense2 (Dense) (None, 50, 38) 38950 concatenate_1[0][0] \n__________________________________________________________________________________________________\nsoftmax (Activation) (None, 50, 38) 0 dense2[0][0] \n==================================================================================================\nTotal params: 4,870,646\nTrainable params: 4,870,646\nNon-trainable params: 0\n__________________________________________________________________________________________________El modelo hace uso de la implementación de redes recurrentes GRU, que en este caso resultan más eficientes que las LSTM.
\nEn resumen el modelo recibe una imagen de entrada y mediante las capas de convolución extrae las principales características que a su vez son la entrada de las capas recurrentes las cuales generan las predicciones basándose en un máximo tamaño permitido.
\nDentro de cualquier problema de deep learning tiene que existir un objetivo o función a optimizar, ya sea el caso de una regresión que busca predecir numéricamente un valor o una clasificación que pretende predecir una clase, lo que se busca es optimizar una función, para este caso en particular lo que se busca es que la salida que es una matriz la cual consta de 2 dimensiones, en la que la primera es el tamaño máximo de la cadena que puede predecir el modelo y la segunda el alfabeto.
\nEn la siguiente imagen se puede apreciar una representación simple de la matriz de salida.
\n\nPara poder optimizar esta matriz y decidir el camino correcto en que los pesos del modelo se ajustan las funciones de perdida comúnmente conocidas no ayudan, pero para este caso en particular se usa una función de perdida especial conocida como CTC(Connectionism Temporal Classification) que en resumen se encarga de definir una especie de camino desde la predicción inicial hasta la final.
\nEl entrenamiento del modelo se lo realizó por 20 ciclos o epochs con un batch_size de 64, sobre un equipo que cuenta con tarjeta grafica NVIDIA 1060, aproximadamente el entrenamiento duro 15 a 20 minutos y el modelo se entreno hasta que el error se redujo a menos de 1.
\nPara iniciar el entrenamiento del modelo simplemente iniciar dentro del directorio del código:
\n# Python3\n\npython3 main.py train![](\"https://media-exp1.licdn.com/dms/image/C4E12AQE7Eg0K1VR01A/article-inline_image-shrink_1000_1488/0?e=1587600000&v=beta&t=syiJB5QpkeKlcZ99QOUTC8Ut2wPp7NC5ZmScgqg48ZI\")
\nUna vez se entrenaron los modelos, estos se guardan automáticamente cada 2 epochs, en el mismo directorio del código fuente.
\n![](\"https://media-exp1.licdn.com/dms/image/C4E12AQErvABpFlU_Rw/article-inline_image-shrink_1000_1488/0?e=1587600000&v=beta&t=RtDc9wVNH35-DXDzn5TeVAIzHsnL_Lk0UXom4wl0Ea0\")
\n# Python3\n\n# python3 main.py [numero_epoch]\n\npython3 main.py 06![](\"https://media-exp1.licdn.com/dms/image/C4E12AQHeTQFbdmocOw/article-inline_image-shrink_1000_1488/0?e=1587600000&v=beta&t=GkV4GgbipdBa6vjzwZf5rL7x2NgMu7nC2cPCH563GXo\")
\n![](\"https://media-exp1.licdn.com/dms/image/C4E12AQE624rhwaMQqw/article-inline_image-shrink_1000_1488/0?e=1587600000&v=beta&t=hT3NEY773bUd4cxpnlwDtul5V-v3l_suWm_BWnSApck\")
\nDe manera rápida y simple se puede generar un modelo que permita automatizar un proceso y generar valar a una empresa, y gracias a las herramientas actuales muchas partes de la programación están abstraídas y permiten un rápido desarrollo.
\nEl modelo es una demostración simple ya que para que sea un modelo final que sea viable se tiene que mejorar el conjunto de datos y la variedad de ejemplos ya que como se sabe en el mundo real no todo esta estático y perfectamente retratado.
\nKeras OCR Sample (https://keras.io/examples/image_ocr/)
","fields":{"slug":"/posts/plate-recognition-tutorial","tagSlugs":["/tag/tutorial/","/tag/tensorflow-keras/","/tag/ai/","/tag/image-detection/"]},"frontmatter":{"date":"2019-04-10T10:40:32.169Z","description":"Tutorial para reconocer placas mediante inteligencia artificial","tags":["Tutorial","Tensorflow Keras","AI","Image detection"],"title":"Reconocimiento de placas con inteligencia artificial","socialImage":"https://media-exp1.licdn.com/dms/image/C4E12AQE8mRZaamYaWQ/article-cover_image-shrink_720_1280/0?e=1587600000&v=beta&t=xzDzkvKlrdeUh19RQMxvNYx7tPffSRcMzhHWdmbzZZw"}}},"pageContext":{"slug":"/posts/plate-recognition-tutorial"}}}