Solucionador de ecuaciones manuscritas en Python

Adquisición de datos de entrenamiento

Descargando conjunto de datos

Extracción de características

Invierta la imagen y luego conviértala en una imagen binaria porque la extracción de contorno da el mejor resultado cuando el objeto es blanco y el entorno es negro.
Para encontrar contornos use la función ‘findContour’. Para las características, obtenga el rectángulo delimitador del contorno utilizando la función ‘boundingRect’ (el rectángulo delimitador es el rectángulo horizontal más pequeño que encierra todo el contorno).
Dado que cada imagen en nuestro conjunto de datos contiene solo un símbolo/dígito, solo necesitamos el rectángulo delimitador de tamaño máximo. Para este propósito, calculamos el área del rectángulo delimitador de cada contorno y seleccionamos el rectángulo con el área máxima.
Ahora, cambie el tamaño del rectángulo delimitador del área máxima a 28 por 28. Modifique su forma a 784 por 1. Por lo tanto, ahora habrá valores o características de 784 píxeles. Ahora, asígnele la etiqueta correspondiente (por ejemplo, para 0–9 imágenes, la misma etiqueta que su dígito, para – asigne la etiqueta 10, para + asigne la etiqueta 11, para veces asigne la etiqueta 12). Así que ahora nuestro conjunto de datos contiene 784 columnas de características y una columna de etiquetas. Después de extraer las funciones, guarde los datos en un archivo CSV.

Datos de entrenamiento usando una red neuronal convolucional

Dado que la red neuronal convolucional funciona con datos bidimensionales y nuestro conjunto de datos tiene la forma de 785 por 1. Por lo tanto, debemos remodelarlo. En primer lugar, asigne la columna de etiquetas en nuestro conjunto de datos a la variable y_train. Luego suelte la columna de etiquetas del conjunto de datos y luego remodele el conjunto de datos a 28 por 28. Ahora, nuestro conjunto de datos está listo para CNN.

Construcción de una red neuronal convolucional

Para hacer CNN, importe todas las bibliotecas necesarias.

import pandas as pd
import numpy as np
import pickle
np.random.seed(1212)
import keras
from keras.models import Model
from keras.layers import * from keras import optimizers
from keras.layers import Input, Dense
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K
K.set_image_dim_ordering('th')
from keras.utils.np_utils import to_categorical
from keras.models import model_from_json

Convierta los datos de y_train en datos categóricos usando la función ‘to_categorical’. Para hacer el modelo, use la siguiente línea de código.

model = Sequential()
model.add(Conv2D(30, (5, 5), input_shape =(1, 28, 28), activation ='relu'))
model.add(MaxPooling2D(pool_size =(2, 2)))
model.add(Conv2D(15, (3, 3), activation ='relu'))
model.add(MaxPooling2D(pool_size =(2, 2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation ='relu'))
model.add(Dense(50, activation ='relu'))
model.add(Dense(13, activation ='softmax'))
# Compile model
model.compile(loss ='categorical_crossentropy', 
              optimizer ='adam', metrics =['accuracy'])

Ajuste del modelo a los datos

Para ajustar CNN a los datos, use las siguientes líneas de código.

model.fit(np.array(l), cat, epochs = 10, batch_size = 200, 
          shuffle = True, verbose = 1)

Tomará alrededor de tres horas entrenar nuestro modelo con una precisión del 98.46%. Después del entrenamiento, podemos guardar nuestro modelo como archivo json para uso futuro, de modo que no tengamos que entrenar nuestro modelo y esperar tres horas cada vez. Para guardar nuestro modelo, podemos usar la siguiente línea de códigos.

model_json = model.to_json()
with open("model_final.json", "w") as json_file:
    json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model_final.h5")

Probando nuestro modelo o resolviendo la ecuación usándolo

En primer lugar, importe nuestro modelo guardado utilizando la siguiente línea de códigos.

json_file = open('model_final.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("model_final.h5")

Ahora, ingrese una imagen que contenga una ecuación escrita a mano. Convierta la imagen en una imagen binaria y luego invierta la imagen (si los dígitos/símbolos están en negro).

Ahora obtenga los contornos de la imagen, por defecto obtendrá los contornos de izquierda a derecha.

Obtenga un rectángulo delimitador para cada contorno.

A veces, resultará en dos o más contornos para el mismo dígito/símbolo. Para evitar eso, verifique si el rectángulo delimitador de esos dos contornos se superpone o no. Si se superponen, descarta el rectángulo más pequeño.

Ahora, cambie el tamaño de todo el rectángulo delimitador restante a 28 por 28.

Usando el modelo, prediga el dígito/símbolo correspondiente para cada rectángulo delimitador y guárdelo en una string.

Después de eso, use la función ‘eval’ en la string para resolver la ecuación.

aquí

Publicación traducida automáticamente

Artículo escrito por vipul73921 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta