[PYTHON] Ich habe "License OCR" mit der Google Vision API ausprobiert
Einführung
Es gibt eine Technologie namens "OCR (Optical Character Recognition)", die gedruckte oder handgeschriebene Zeichen liest und in Zeichendaten umwandelt.
OCR-Dienste werden für verschiedene Dokumente wie Rechnungen, Quittungen, Visitenkarten und Lizenzen bereitgestellt. Durch die Verwendung von OCR können Sie die Eingabe von Daten reduzieren. Durch die Verknüpfung mit anderen Systemen ist es außerdem möglich, Daten effektiv zu nutzen.
Die von jedem Unternehmen bereitgestellte OCR umfasst Dienstleistungen für Unternehmen und Einzelpersonen. Als OCR, die von Einzelpersonen verwendet werden kann, gibt es "Google Vision API (im Folgenden als Vision API bezeichnet)". Vision API ist ein sehr leistungsstarker Bildanalysedienst von Google. (Klicken Sie hier, um die kostenlose Testversion aufzurufen (https://cloud.google.com/vision?hl=ja).)
Dieses Mal habe ich eine einfache OCR-Lizenz mit der Vision-API ausprobiert.
Lizenz OCR
Umgebung
Die Umgebung verwendet Google Colaboratory. Die Python-Version ist unten.
import platform
print("python " + platform.python_version())
# python 3.6.9
Bildschirm
Jetzt schreiben wir den Code. Importieren Sie zunächst die Bibliothek, die zum Anzeigen des Bildes erforderlich ist.
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib
Ich werde auch ein Beispielbild der Lizenz erstellen. Lassen Sie uns das Bild anzeigen.
img = cv2.imread(input_file) # input_Datei ist der Pfad des Bildes
plt.figure(figsize=[10,10])
plt.axis('off')
plt.imshow(img[:,:,::-1])
Vision API-Setup
Lassen Sie uns nun dieses Belegbild in die Vision-API werfen und OCR ausführen.
- Informationen zur Vision API-Preisgestaltung *
- ・ Kostenlos für die ersten 1.000 Einheiten / Monat (Stand 21. Juni 2020) *
- ・ Einzelheiten zur Gebührenstruktur finden Sie unter hier. * *
Treffen Sie zunächst die erforderlichen Vorbereitungen für die Verwendung der Vision-API. Richten Sie dies unter [hier] ein (https://cloud.google.com/vision/docs/quickstart-client-libraries?hl=JA). Sie müssen die Clientbibliothek installieren und einen Dienstkontoschlüssel ausgeben. Die Installation der Client-Bibliothek ist wie folgt.
pip install google-cloud-vision
Verwenden Sie den ausgegebenen Dienstkontoschlüssel, um Umgebungsvariablen festzulegen.
import os
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = json_path # json_Pfad ist der Pfad des Dienstkontoschlüssels
Texterkennung
Lassen Sie uns nun die Texterkennung per OCR durchführen.
Dieses Mal verwenden wir die Option Vision API DOCUMENT_TEXT_DETECTION zur Texterkennung. Weitere Informationen zur Vision-API DOCUMENT_TEXT_DETECTION finden Sie hier (https://cloud.google.com/vision/docs/pdf?hl=ja).
Anfrage an API senden / Antwort abrufen
Senden wir nun eine Anfrage an die Vision-API und erhalten eine Antwort.
import io
from google.cloud import vision
from google.cloud.vision import types
client = vision.ImageAnnotatorClient()
with io.open(input_file, 'rb') as image_file:
content = image_file.read()
image = types.Image(content=content)
response = client.document_text_detection(image=image) #Texterkennung
Wenn es fehlerfrei ausgeführt werden kann, kann die Anforderung an die API gesendet und die Antwort abgerufen werden.
Diese Antwort enthält das OCR-Ergebnis der Vision-API. Es enthält verschiedene Informationen wie gelesene Zeichen, Zeichenkoordinaten, Sicherheit und Sprachtyp. Hier überprüfen wir den gelesenen Volltext. Ich werde es neben dem Bild anzeigen.
print(response.text_annotations[0].description)
|
Name So Buch Hanako Geboren am 1. Mai 1986) Adresse Tokio 2-1-2 Kasumi, Chiyoda-ku Zugegeben am 07. Mai 2001 12345 12024 (Imawa 06) 01. Juni Inaktiv Brille etc. Lizenz Bedingungen usw. Probe Ausgezeichnet Nummer | Nr. 012345678900 | - 01. April 2003 In der Mitte Andere 01. Juni 2005 (Drei Arten 01. August 2017 Führerschein Geben Sie ein Große kleine spezielle Mittelgroßes Moped Ichiten Tentoku Fuji Große Eigenständigkeit Fuou Hiki Nakaji 00000 Kommission für öffentliche Sicherheit KA | || Q00 |
Ich konnte das Leseergebnis bestätigen.
Die Vision-API enthält zeichenweise Koordinateninformationen. Zeichnen wir jede Koordinate auf das Bild und überprüfen sie.
document = response.full_text_annotation
img_symbol = img.copy()
for page in document.pages:
for block in page.blocks:
for paragraph in block.paragraphs:
for word in paragraph.words:
for symbol in word.symbols:
bounding_box = symbol.bounding_box
xmin = bounding_box.vertices[0].x
ymin = bounding_box.vertices[0].y
xmax = bounding_box.vertices[2].x
ymax = bounding_box.vertices[2].y
cv2.rectangle(img_symbol, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=1, lineType=cv2.LINE_AA)
plt.figure(figsize=[10,10])
plt.imshow(img_symbol[:,:,::-1]);plt.title("img_symbol")
Vorlagenerstellung
Der Ort, an dem die Lizenz für jeden Artikel wie "Name", "Geburtsdatum" und "Adresse" geschrieben wird, ist festgelegt. Was wo geschrieben wird und was geschrieben wird, wird in der Terminologie der OCR-Branche als ** fest ** bezeichnet. Und die OCR eines Standards wird als ** Standard-OCR ** bezeichnet. Auf der anderen Seite werden Quittungen, Visitenkarten, Rechnungen usw., für die nicht sicher ist, wo und was geschrieben wird, als ** atypisch ** bezeichnet, und ihre OCRs werden als ** atypische OCR ** bezeichnet.
Mit der Standard-OCR können Sie Vorlagen erstellen. Durch Angabe des Bereichs für jedes Element in der Vorlage und Extrahieren der im Bereich enthaltenen OCR-Ergebnisse kann das Leseergebnis für jedes Element ausgegeben werden.
Jetzt erstellen wir eine Vorlage. Dieses Mal verwenden wir das Annotation-Tool labelImg. Annotation ist das Hinzufügen einiger Informationen zu einem Datenelement. Hier bedeutet dies, dass der vom Rahmen umgebene Bereich als "Name" oder "Geburtsdatum" gekennzeichnet ist. Das Ergebnis der Annotation mit labelImg wird als XML-Datei gespeichert.
Das folgende Beispiel zeigt die XML-Datei mit dem Anmerkungsergebnis.
<annotation>
<folder>Downloads</folder>
<filename>drivers_license.jpg</filename>
<path>/path/to/jpg_file</path>
<source>
<database>Unknown</database>
</source>
<size>
<width>681</width>
<height>432</height>
<depth>3</depth>
</size>
<segmented>0</segmented>
<object>
<name>name</name>
<pose>Unspecified</pose>
<truncated>0</truncated>
<difficult>0</difficult>
<bndbox>
<xmin>78</xmin>
<ymin>26</ymin>
<xmax>428</xmax>
<ymax>58</ymax>
</bndbox>
</object>
<object>
<name>birthday</name>
<pose>Unspecified</pose>
<truncated>0</truncated>
<difficult>0</difficult>
<bndbox>
<xmin>428</xmin>
<ymin>27</ymin>
<xmax>652</xmax>
<ymax>58</ymax>
</bndbox>
</object>
<!--Unterlassung-->
</annotation>
Laden von Vorlageninformationen
Lesen wir nun die obige XML-Datei. Versuchen Sie zur Bestätigung, den Vorlagenrahmen und die Beschriftungsinformationen auf dem Bild zu zeichnen.
import xml.etree.ElementTree as ET
tree = ET.parse(input_xml) # input_xml ist der Pfad von xml
root = tree.getroot()
img_labeled = img.copy()
for obj in root.findall("./object"):
name = obj.find('name').text
xmin = obj.find('bndbox').find('xmin').text
ymin = obj.find('bndbox').find('ymin').text
xmax = obj.find('bndbox').find('xmax').text
ymax = obj.find('bndbox').find('ymax').text
xmin, ymin, xmax, ymax = int(xmin), int(ymin), int(xmax), int(ymax)
cv2.rectangle(img_labeled, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=1, lineType=cv2.LINE_AA)
cv2.putText(img_labeled, name, (xmin, ymin), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), thickness=1)
plt.figure(figsize=[10,10])
plt.imshow(img_labeled[:,:,::-1]);plt.title("img_labeled")
Ich konnte bestätigen, dass die Vorlageninformationen richtig eingestellt wurden. Ich benutze labelImg, um die Artikel, die ich lesen möchte, wie meinen Namen und mein Geburtsdatum, zu rahmen und zu beschriften.
Vorlagenübereinstimmung
Lassen Sie uns nun die Vorlage mit dem OCR-Ergebnis abgleichen.
Klassifizieren Sie die Zeichenfolgen im Rahmen der Vorlage als Ergebnis für jedes Element. Das Ergebnis des Vorlagenabgleichs wird neben dem Bild angezeigt.
text_infos = []
document = response.full_text_annotation
for page in document.pages:
for block in page.blocks:
for paragraph in block.paragraphs:
for word in paragraph.words:
for symbol in word.symbols:
bounding_box = symbol.bounding_box
xmin = bounding_box.vertices[0].x
ymin = bounding_box.vertices[0].y
xmax = bounding_box.vertices[2].x
ymax = bounding_box.vertices[2].y
xcenter = (xmin+xmax)/2
ycenter = (ymin+ymax)/2
text = symbol.text
text_infos.append([text, xcenter, ycenter])
result_dict = {}
for obj in root.findall("./object"):
name = obj.find('name').text
xmin = obj.find('bndbox').find('xmin').text
ymin = obj.find('bndbox').find('ymin').text
xmax = obj.find('bndbox').find('xmax').text
ymax = obj.find('bndbox').find('ymax').text
xmin, ymin, xmax, ymax = int(xmin), int(ymin), int(xmax), int(ymax)
texts = ''
for text_info in text_infos:
text = text_info[0]
xcenter = text_info[1]
ycenter = text_info[2]
if xmin <= xcenter <= xmax and ymin <= ycenter <= ymax:
texts += text
result_dict[name] = texts
for k, v in result_dict.items():
print('{} : {}'.format(k, v))
|
Name: Hanako Nihon Geburtstag: Geboren am 1. Mai 1986 Adresse: 2-1-2 Kasumi, Chiyoda-ku, Tokio Ausstellungsdatum: 07. Mai 2001 12345 Ablaufdatum: 2024 (Imawa 06) 01. Juni Inaktiv Nummer: Nr. 012345678900 Führerschein: Führerschein Kommission für öffentliche Sicherheit: 00000 Kommission für öffentliche Sicherheit |
Als Ergebnis des Vorlagenabgleichs wurde bestätigt, dass die OCR-Ergebnisse nach Elementen klassifiziert werden konnten.
Gesichtserkennung
Bisher haben wir uns mit der Texterkennung durch OCR befasst.
Übrigens ist es bei der Beurteilung des Bildes eines Ausweises wie einer Lizenz auch möglich, das Gesichtsfoto zu überprüfen. Die Vision API verfügt über andere Bildanalysefunktionen als OCR, und die Gesichtserkennung ist eine davon. Weitere Informationen zur Gesichtserkennung von Vision API finden Sie hier (https://cloud.google.com/vision/docs/detecting-faces?hl=ja).
Verwenden wir nun die Vision-API, um auch die Gesichtserkennung durchzuführen.
Anfrage an API senden / Antwort abrufen
Senden wir nun wie bei der Texterkennung eine Anfrage an die Vision-API und erhalten eine Antwort.
import io
from google.cloud import vision
client = vision.ImageAnnotatorClient()
with io.open(input_file, 'rb') as image_file:
content = image_file.read()
image = types.Image(content=content)
response2 = client.face_detection(image=image) #Gesichtserkennung
Diese Antwort2 enthält das Ergebnis der Gesichtserkennung der Vision API. Es enthält verschiedene Informationen wie erkannte Gesichtskoordinaten, Merkmalspunkte, Gewissheit und die Möglichkeit von Emotionen (ob wütend oder lachend usw.).
Lassen Sie uns nun die Koordinaten des erkannten Gesichts anzeigen.
faces = response2.face_annotations
img_face = img.copy()
for face in faces:
bounding_poly = face.bounding_poly
fd_bounding_poly = face.fd_bounding_poly
xmin = bounding_poly.vertices[0].x
ymin = bounding_poly.vertices[0].y
xmax = bounding_poly.vertices[2].x
ymax = bounding_poly.vertices[2].y
cv2.rectangle(img_face, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=1, lineType=cv2.LINE_AA)
cv2.putText(img_face, 'bounding_poly', (xmin, ymin), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), thickness=1)
xmin = fd_bounding_poly.vertices[0].x
ymin = fd_bounding_poly.vertices[0].y
xmax = fd_bounding_poly.vertices[2].x
ymax = fd_bounding_poly.vertices[2].y
cv2.rectangle(img_face, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=1, lineType=cv2.LINE_AA)
cv2.putText(img_face, 'fd_bounding_poly', (xmin, ymin), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), thickness=1)
plt.figure(figsize=[10,10])
plt.imshow(img_face[:,:,::-1]);plt.title("img_face")
Ich konnte bestätigen, dass das Gesicht erkannt wurde.
Lassen Sie uns nun das Konfidenzniveau der Gesichtserkennung anzeigen. Es ist auch möglich, im Voraus einen Schwellenwert festzulegen und zu beurteilen, ob das Gesicht erkannt wurde, wenn es über dem Schwellenwert liegt. Auf diese Weise können Sie verschwommene Bilder und solche, die nicht von Gesichtsfotos unterschieden werden können, entfernen und auf nur zuverlässige Bilder eingrenzen.
for face in faces:
detection_confidence = face.detection_confidence
if detection_confidence > 0.90:
print('Face detected')
print('detection_confidence : ' + str(detection_confidence))
# Face detected
# detection_confidence : 0.953563392162323
Oben habe ich den Schwellenwert auf 0,90 gesetzt und versucht, die Zuverlässigkeit des Gesichtsfotos zu beurteilen. Der Grad der Sicherheit liegt diesmal bei 0,95, und man kann sagen, dass er als Gesichtsfoto zuverlässig ist.
Zusammenfassung
Wie war es?
Dieses Mal habe ich versucht, eine Lizenz-OCR mithilfe der Vision-API durchzuführen.
Zuerst haben wir eine Texterkennung durchgeführt. Ich habe auch eine separate Vorlage mit labelImg erstellt. Durch Abgleichen des OCR-Ergebnisses mit der Vorlage wurde das Leseergebnis für jedes Element klassifiziert. Dabei haben wir die zeichenweisen Koordinateninformationen verwendet, die als Ergebnis der Vision-API enthalten sind. Mit einer Standard-OCR wie einer Lizenz ist es möglich, eine Vorlage zu erstellen und das Ergebnis für jedes Element auszugeben, das Sie lesen möchten.
Wir haben auch eine Gesichtserkennung durchgeführt. Dieses Mal haben wir nur die erkannten Gesichtskoordinaten verwendet, aber die Antwort enthält auch die Koordinaten der Merkmalspunkte und die Möglichkeit von Emotionen. Ich denke, es wäre interessant, die Gesichtserkennung für Gesichtsfotos mit verschiedenen Gesichtsausdrücken zu versuchen.
Die Vision API ist ein Tool, mit dem verschiedene Bildanalysen durchgeführt werden können. Probieren Sie zusätzlich zu der diesmal eingeführten Texterkennung und Gesichtserkennung verschiedene Dinge aus.
Recommended Posts