Reconocimiento simple de dígitos OCR en OpenCV-Python

Estoy tratando de implementar un “Reconocimiento de dígitos OCR” en OpenCV-Python (cv2). Es sólo para fines de aprendizaje. Me gustaría aprender las funciones de KNearest y SVM en OpenCV.

Tengo 100 muestras (es decir, imágenes) de cada dígito. Me gustaría entrenar con ellos.

Hay un ejemplo de letter_recog.py que viene con OpenCV sample. Pero todavía no pude averiguar cómo usarlo. No entiendo cuáles son las muestras, respuestas, etc. Además, al principio carga un archivo txt, que no entendí primero.

Más tarde, buscando un poco, pude encontrar un letter_recognition.data en muestras de cpp. Lo utilicé e hice un código para cv2.KNearest en el modelo de letter_recog.py (solo para pruebas):

 import numpy as np import cv2 fn = 'letter-recognition.data' a = np.loadtxt(fn, np.float32, delimiter=',', converters={ 0 : lambda ch : ord(ch)-ord('A') }) samples, responses = a[:,1:], a[:,0] model = cv2.KNearest() retval = model.train(samples,responses) retval, results, neigh_resp, dists = model.find_nearest(samples, k = 10) print results.ravel() 

Me dio una variedad de tamaño 20000, no entiendo lo que es.

Preguntas:

1) ¿Qué es el archivo letter_recognition.data? ¿Cómo construir ese archivo desde mi propio conjunto de datos?

2) ¿Qué denota results.reval() ?

3) ¿Cómo podemos escribir una herramienta simple de reconocimiento de dígitos usando el archivo letter_recognition.data (ya sea KNearest o SVM)?

Bueno, decidí entrenarme en mi pregunta para resolver el problema anterior. Lo que quería era implementar un OCR simple con las funciones KNearest o SVM en OpenCV. Y abajo está lo que hice y cómo. (es solo para aprender a usar KNearest para propósitos simples de OCR).

1) Mi primera pregunta fue sobre el archivo letter_recognition.data que viene con las muestras de OpenCV. Quería saber qué hay dentro de ese archivo.

Contiene una carta, junto con 16 características de esa carta.

Y this SOF me ayudó a encontrarlo. Estas 16 características se explican en el documento Letter Recognition Using Holland-Style Adaptive Classifiers . (Aunque no entendí algunas de las características al final)

2) Como sabía, sin entender todas esas características, es difícil hacer ese método. Intenté algunos otros papeles, pero todos fueron un poco difíciles para un principiante.

So I just decided to take all the pixel values as my features. (No estaba preocupado por la precisión o el rendimiento, solo quería que funcionara, al menos con la menor precisión)

Tomé la imagen de abajo para mis datos de entrenamiento:

introduzca la descripción de la imagen aquí

(Sé que la cantidad de datos de entrenamiento es menor. Pero, dado que todas las letras son de la misma fuente y tamaño, decidí probar esto).

Para preparar los datos para el entrenamiento, hice un pequeño código en OpenCV. Hace las siguientes cosas:

  1. Carga la imagen.
  2. Selecciona los dígitos (obviamente, mediante la búsqueda de contornos y la aplicación de restricciones en el área y la altura de las letras para evitar falsas detecciones).
  3. Dibuja el rectángulo delimitador alrededor de una letra y espera a que se key press manually . Esta vez presionamos la tecla de dígitos correspondiente a la letra en el cuadro.
  4. Una vez que se presiona la tecla de dígitos correspondiente, cambia el tamaño de este cuadro a 10×10 y guarda valores de 100 píxeles en una matriz (aquí, muestras) y el correspondiente dígito ingresado manualmente en otra matriz (aquí, respuestas).
  5. Luego guarde ambos arreglos en archivos de texto separados.

Al final de la clasificación manual de dígitos, todos los dígitos en los datos del tren (train.png) están etiquetados manualmente por nosotros mismos, la imagen se verá a continuación:

introduzca la descripción de la imagen aquí

A continuación se muestra el código que usé para el propósito anterior (por supuesto, no tan limpio):

 import sys import numpy as np import cv2 im = cv2.imread('pitrain.png') im3 = im.copy() gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY) blur = cv2.GaussianBlur(gray,(5,5),0) thresh = cv2.adaptiveThreshold(blur,255,1,1,11,2) ################# Now finding Contours ################### contours,hierarchy = cv2.findContours(thresh,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE) samples = np.empty((0,100)) responses = [] keys = [i for i in range(48,58)] for cnt in contours: if cv2.contourArea(cnt)>50: [x,y,w,h] = cv2.boundingRect(cnt) if h>28: cv2.rectangle(im,(x,y),(x+w,y+h),(0,0,255),2) roi = thresh[y:y+h,x:x+w] roismall = cv2.resize(roi,(10,10)) cv2.imshow('norm',im) key = cv2.waitKey(0) if key == 27: # (escape to quit) sys.exit() elif key in keys: responses.append(int(chr(key))) sample = roismall.reshape((1,100)) samples = np.append(samples,sample,0) responses = np.array(responses,np.float32) responses = responses.reshape((responses.size,1)) print "training complete" np.savetxt('generalsamples.data',samples) np.savetxt('generalresponses.data',responses) 

Ahora entramos a la parte de entrenamiento y pruebas.

Para la parte de prueba que usé debajo de la imagen, que tiene el mismo tipo de letras que entrené.

introduzca la descripción de la imagen aquí

Para el entrenamiento hacemos lo siguiente :

  1. Cargue los archivos txt que ya hemos guardado anteriormente.
  2. creamos una instancia de clasificador que estamos usando (aquí, es KNearest)
  3. Luego usamos la función KNearest.train para entrenar los datos

Para propósitos de prueba, hacemos lo siguiente:

  1. Cargamos la imagen utilizada para la prueba.
  2. Procese la imagen como antes y extraiga cada dígito utilizando métodos de contorno.
  3. Dibuje un cuadro delimitador para él, luego redimensione a 10×10 y almacene sus valores de píxeles en una matriz como se hizo anteriormente.
  4. Luego usamos la función KNearest.find_nearest () para encontrar el elemento más cercano al que le dimos. (Si tiene suerte, reconoce el dígito correcto.)

Incluí los dos últimos pasos (entrenamiento y pruebas) en el siguiente código:

 import cv2 import numpy as np ####### training part ############### samples = np.loadtxt('generalsamples.data',np.float32) responses = np.loadtxt('generalresponses.data',np.float32) responses = responses.reshape((responses.size,1)) model = cv2.KNearest() model.train(samples,responses) ############################# testing part ######################### im = cv2.imread('pi.png') out = np.zeros(im.shape,np.uint8) gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY) thresh = cv2.adaptiveThreshold(gray,255,1,1,11,2) contours,hierarchy = cv2.findContours(thresh,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: if cv2.contourArea(cnt)>50: [x,y,w,h] = cv2.boundingRect(cnt) if h>28: cv2.rectangle(im,(x,y),(x+w,y+h),(0,255,0),2) roi = thresh[y:y+h,x:x+w] roismall = cv2.resize(roi,(10,10)) roismall = roismall.reshape((1,100)) roismall = np.float32(roismall) retval, results, neigh_resp, dists = model.find_nearest(roismall, k = 1) string = str(int((results[0][0]))) cv2.putText(out,string,(x,y+h),0,1,(0,255,0)) cv2.imshow('im',im) cv2.imshow('out',out) cv2.waitKey(0) 

Y funcionó, abajo está el resultado que obtuve:

introduzca la descripción de la imagen aquí


Aquí funcionó con 100% de precisión. Supongo que esto se debe a que todos los dígitos son del mismo tipo y tamaño.

Pero de todos modos, este es un buen comienzo para los principiantes (espero que sí).

Para aquellos que estén interesados ​​en el código C ++ pueden consultar el siguiente código. Gracias Abid Rahman por la bonita explicación.


El procedimiento es el mismo que el anterior, pero la búsqueda de contorno usa solo el primer nivel de jerarquía, de modo que el algoritmo solo usa el contorno exterior para cada dígito.

Código para crear muestras y datos de tags.

 //Process image to extract contour Mat thr,gray,con; Mat src=imread("digit.png",1); cvtColor(src,gray,CV_BGR2GRAY); threshold(gray,thr,200,255,THRESH_BINARY_INV); //Threshold to find contour thr.copyTo(con); // Create sample and label data vector< vector  > contours; // Vector for storing contour vector< Vec4i > hierarchy; Mat sample; Mat response_array; findContours( con, contours, hierarchy,CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); //Find contour for( int i = 0; i< contours.size(); i=hierarchy[i][0] ) // iterate through first hierarchy level contours { Rect r= boundingRect(contours[i]); //Find bounding rect for each contour rectangle(src,Point(rx,ry), Point(r.x+r.width,r.y+r.height), Scalar(0,0,255),2,8,0); Mat ROI = thr(r); //Crop the image Mat tmp1, tmp2; resize(ROI,tmp1, Size(10,10), 0,0,INTER_LINEAR ); //resize to 10X10 tmp1.convertTo(tmp2,CV_32FC1); //convert to float sample.push_back(tmp2.reshape(1,1)); // Store sample data imshow("src",src); int c=waitKey(0); // Read corresponding label for contour from keyoard c-=0x30; // Convert ascii to intiger value response_array.push_back(c); // Store label to a mat rectangle(src,Point(rx,ry), Point(r.x+r.width,r.y+r.height), Scalar(0,255,0),2,8,0); } // Store the data to file Mat response,tmp; tmp=response_array.reshape(1,1); //make continuous tmp.convertTo(response,CV_32FC1); // Convert to float FileStorage Data("TrainingData.yml",FileStorage::WRITE); // Store the sample data in a file Data << "data" << sample; Data.release(); FileStorage Label("LabelData.yml",FileStorage::WRITE); // Store the label data in a file Label << "label" << response; Label.release(); cout<<"Training and Label data created successfully....!! "< 

Código de entrenamiento y pruebas.

 Mat thr,gray,con; Mat src=imread("dig.png",1); cvtColor(src,gray,CV_BGR2GRAY); threshold(gray,thr,200,255,THRESH_BINARY_INV); // Threshold to create input thr.copyTo(con); // Read stored sample and label for training Mat sample; Mat response,tmp; FileStorage Data("TrainingData.yml",FileStorage::READ); // Read traing data to a Mat Data["data"] >> sample; Data.release(); FileStorage Label("LabelData.yml",FileStorage::READ); // Read label data to a Mat Label["label"] >> response; Label.release(); KNearest knn; knn.train(sample,response); // Train with sample and responses cout<<"Training compleated.....!!"< > contours; // Vector for storing contour vector< Vec4i > hierarchy; //Create input sample by contour finding and cropping findContours( con, contours, hierarchy,CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); Mat dst(src.rows,src.cols,CV_8UC3,Scalar::all(0)); for( int i = 0; i< contours.size(); i=hierarchy[i][0] ) // iterate through each contour for first hierarchy level . { Rect r= boundingRect(contours[i]); Mat ROI = thr(r); Mat tmp1, tmp2; resize(ROI,tmp1, Size(10,10), 0,0,INTER_LINEAR ); tmp1.convertTo(tmp2,CV_32FC1); float p=knn.find_nearest(tmp2.reshape(1,1), 1); char name[4]; sprintf(name,"%d",(int)p); putText( dst,name,Point(rx,r.y+r.height) ,0,1, Scalar(0, 255, 0), 2, 8 ); } imshow("src",src); imshow("dst",dst); imwrite("dest.jpg",dst); waitKey(); 

Resultado

En el resultado, el punto en la primera línea se detecta como 8 y no hemos entrenado para el punto. También estoy considerando cada contorno en el primer nivel jerárquico como la entrada de muestra, el usuario puede evitarlo al calcular el área.

Resultados

Si está interesado en el estado del arte en Aprendizaje automático, debe buscar en Aprendizaje profundo. Debe tener una CUDA que admita GPU o, alternativamente, utilizar la GPU en los servicios web de Amazon.

Google Udacity tiene un buen tutorial sobre esto usando Tensor Flow . Este tutorial le enseñará cómo entrenar su propio clasificador en dígitos escritos a mano. Obtuve una precisión de más del 97% en el conjunto de pruebas mediante redes convolucionales.