Das Extrahieren von Text aus Bildern ist seit langem ein beliebtes Problem in der Softwareentwicklung. Die optische Zeichenerkennung (Optical Character Recognition, OCR) ist eine Pioniertechnologie, die häufig zur Lösung dieses Problems eingesetzt wird. Mit ihrer Fähigkeit, Bilder, die Text enthalten, in maschinenlesbare Daten umzuwandeln, hat die OCR verschiedene Branchen revolutioniert, von der Automatisierung der Dokumentenverarbeitung bis hin zur Sprachübersetzung.
Es gibt zwar kommerzielle OCR-Lösungen, aber wenn du deine eigene OCR-API in der vielseitigen und leistungsstarken Programmiersprache Python erstellst, hast du mehrere Vorteile, z. B. die Möglichkeit der Anpassung, die Kontrolle über den Datenschutz und das Potenzial für Kosteneinsparungen.
Dieser Leitfaden führt dich durch die Erstellung deiner eigenen OCR-API mit Python. Es werden die notwendigen Bibliotheken, Techniken und Überlegungen für die Entwicklung einer effektiven OCR-API vorgestellt, damit du die Leistungsfähigkeit von OCR für deine Anwendungen nutzen kannst.
Voraussetzungen
Du brauchst ein grundlegendes Verständnis von Python und Flask und eine lokal installierte Version von Python auf deinem System.
Erstellen der OCR-API
In dieser Anleitung lernst du, wie du eine Flask-Anwendung erstellst, die es Nutzern ermöglicht, Bilder über einen POST-Endpunkt hochzuladen, die dann mit Pillow geladen und mit dem PyTesseract-Wrapper (für die Tesseract OCR-Engine) verarbeitet werden. Schließlich wird der extrahierte Text als Antwort auf die Anfrage zurückgegeben.
Du kannst diese API weiter anpassen, um Optionen wie die vorlagenbasierte Klassifizierung (Extraktion von Rechnungsposten, Eingaben in Steuerformularen usw.) oder die Auswahl von OCR-Engines zu ermöglichen (weitere OCR-Engines findest du hier).
Um zu beginnen, erstelle ein neues Verzeichnis für dein Projekt. Richte dann eine neue virtuelle Umgebung in diesem Ordner ein, indem du die folgenden Befehle ausführst:
python3 -m venv env
source env/bin/activateAls nächstes installierst du Flask, PyTesseract, Gunicorn und Pillow, indem du den folgenden Befehl ausführst:
pip3 install pytesseract flask pillow gunicornSobald diese Programme installiert sind, musst du die OCR-Engine von Tesseract auf deinem Host-Rechner installieren. Die Installationsanweisungen für Tesseract variieren je nach Betriebssystem deines Hostrechners. Du findest die entsprechenden Anleitungen hier.
Unter MacOS kannst du Tesseract zum Beispiel mit Homebrew installieren, indem du den folgenden Befehl ausführst:
brew install tesseractSobald dies geschehen ist, kann der PyTesseract-Wrapper mit der OCR-Engine kommunizieren und OCR-Anfragen verarbeiten.
Jetzt bist du bereit, die Flask-Anwendung zu schreiben. Erstelle ein neues Verzeichnis namens ocrapi und eine neue Datei in diesem Verzeichnis mit dem Namen main.py. Speichere den folgenden Inhalt darin:
from flask import Flask, request, jsonify
from PIL import Image
import pytesseract
app = Flask(__name__)
@app.route('/ocr', methods=['POST'])
def ocr_process():
if request.method == 'POST':
image_file = request.files['image']
image_data = Image.open(image_file)
# Perform OCR using PyTesseract
text = pytesseract.image_to_string(image_data)
response = {
'status': 'success',
'text': text
}
return jsonify(response)Der obige Code erstellt eine einfache Flask-Anwendung, die einen Endpunkt hat –/ocr. Wenn du eine POST-Anfrage mit einer Bilddatei an diesen Endpunkt sendest, wird die Datei extrahiert, der pytesseract Wrapper verwendet, um OCR mit der Methode code_to_string() durchzuführen, und der extrahierte Text wird als Teil der Antwort zurückgeschickt.
Erstelle eine wsgi.py-Datei im gleichen ocrapi-Verzeichnis und speichere den folgenden Inhalt darin:
from ocrapi.main import app as application
if __name__ == "__main__":
application.run()
Du kannst die Anwendung nun mit dem folgenden Befehl ausführen:
gunicorn ocrapi.wsgiDeine grundlegende OCR-API ist fertig und es ist Zeit, sie zu testen!
Testen der OCR-API vor Ort
Du kannst die integrierte cURL CLI verwenden, um Anfragen an deine API zu senden, oder zu einem detaillierten API-Testtool wie Postman wechseln. Um die API zu testen, musst du ein Beispielbild herunterladen, das Text enthält. Du kannst dieses einfache Bild oder dieses gekritzelte Bild verwenden.
Lade eines von beiden in das Projektverzeichnis herunter und gib ihm einen einfachen Namen, z. B. simple-image.png oder scribbled-image.png, je nachdem, für welches Bild du dich entscheidest.
Öffne als Nächstes dein Terminal und navigiere in das Verzeichnis deines Projekts. Führe den folgenden Befehl aus, um die API zu testen:
curl -X POST -F “[email protected]” localhost:5000/ocrDieser sendet eine Anfrage an deine OCR-API und gibt eine entsprechende Antwort zurück:
{
"status": "success",
"text": "This looks like it was written in a hucrynn"
}Dies bestätigt, dass deine OCR-API richtig eingerichtet wurde. Du kannst es auch mit dem einfachen Bild versuchen, und so sollte die Antwort aussehen:
{
"status": "success",
"text": "This looks like it was written with a steady handnn"
}Dies zeigt auch die Genauigkeit der Tesseract OCR Engine. Jetzt kannst du deine OCR-API auf dem Kinsta Anwendungs-Hosting hosten, damit sie online zugänglich ist.
Bereitstellen deiner OCR-API
Um deine Anwendung auf Kinsta bereitzustellen, musst du zuerst deinen Projektcode zu einem Git-Anbieter (Bitbucket, GitHub oder GitLab) pushen.
Bevor du deinen Code veröffentlichst, musst du Tesseract separat auf deinem Host-System einrichten, damit du den PyTesseract-Wrapper verwenden kannst. Um den Wrapper auf der Kinsta-Anwendungsplattform (oder generell in jeder anderen Umgebung) verwenden zu können, musst du ihn auch dort einrichten.
Wenn du mit remoten Compute-Instanzen (wie AWS EC2) arbeitest, kannst du dich per SSH in die Compute-Instanz einwählen und den entsprechenden Befehl zur Installation des Pakets ausführen.
Bei Anwendungsplattformen hast du jedoch keinen direkten Zugriff auf den Host. Du musst eine Lösung wie Nixpacks, Buildpacks oder Dockerfiles verwenden, um die anfänglichen Anforderungen an die Umgebungen deiner Anwendung einzurichten (wozu auch das lokale Einrichten des Tesseract-Pakets gehört) und dann die Anwendung zu installieren.
Füge eine Datei nixpacks.toml mit folgendem Inhalt in das Verzeichnis deines Projekts ein:
# nixpacks.toml
providers = ["python"]
[phases.setup]
nixPkgs = ["...", "tesseract"]
[phases.build]
cmds = ["echo building!", "pip install -r requirements.txt", "..."]
[start]
cmd = "gunicorn ocrapi.wsgi"Damit weist du die Build-Plattform an
- Die Python-Laufzeit zu verwenden, um deine Anwendung zu bauen und auszuführen
- Richte das Tesseract-Paket im Container deiner Anwendung ein.
- Starte die Anwendung mit
gunicorn.
Führe außerdem den folgenden Befehl aus, um eine requirements.txt-Datei zu erstellen, die die Anwendungsplattform verwenden kann, um die erforderlichen Python-Pakete während des Builds zu installieren:
pip3 freeze > requirements.txtSobald dein Git-Repository fertig ist, befolge diese Schritte, um deine OCR-API auf Kinsta bereitzustellen:
- Melde dich an oder erstelle ein Konto, um dein MyKinsta-Dashboard zu sehen.
- Autorisiere Kinsta mit deinem Git-Anbieter.
- Klicke in der linken Seitenleiste auf Anwendungen und dann auf Anwendung hinzufügen.
- Wähle das Repository und den Zweig aus, von dem aus du deployen möchtest.
- Wähle einen der verfügbaren Rechenzentrumsstandorte aus der Liste der 37 Optionen aus. Kinsta erkennt die Build-Einstellungen für deine Anwendungen automatisch über deine Nixpack-Datei – lass also das Feld für den Startbefehl leer.
- Wähle deine Anwendungsressourcen, wie z.B. RAM und Festplattenplatz.
- Klicke auf Anwendung erstellen.
Sobald die Bereitstellung abgeschlossen ist, kopierst du den Link der bereitgestellten Anwendung und führst den folgenden Befehl in deinem CLI aus:
curl -x POST -F “[email protected]” <your-deployed-app-link>/ocrDu solltest die gleiche Antwort erhalten, die du lokal erhalten hast:
{"status":"success","text":"This looks like it was written with a steady handnn"}Du kannst auch Postman verwenden, um die API zu testen.
Damit ist die Entwicklung einer einfachen OCR-API abgeschlossen. Du kannst den kompletten Code für dieses Projekt auf GitHub einsehen.
Zusammenfassung
Du hast jetzt eine funktionierende, selbst gehostete OCR-API, die du nach deinen Wünschen anpassen kannst! Diese API kann Text aus Bildern extrahieren und ist damit ein wertvolles Werkzeug für die Datenextraktion, die Digitalisierung von Dokumenten und andere Anwendungen.
Wenn du deine OCR-API weiter entwickelst und verfeinerst, solltest du fortgeschrittene Funktionen wie die Unterstützung mehrerer Sprachen, Bildvorverarbeitungstechniken und die Integration mit Cloud-Speicherdiensten zum Speichern und Abrufen von Bildern in Betracht ziehen.
Welche Funktion ist deiner Meinung nach für eine selbst gehostete OCR-API unverzichtbar? Lass es uns in den Kommentaren wissen!
Kumar is a software developer and a technical author based in India. He specializes in JavaScript and DevOps. You can learn more about his work on his website.
Schreibe einen Kommentar