Clever Geek Handbook

Computer Vision schützt die Privatsphäre





Prävention ist unser Alles. Ein kompetenter Schutz vor Datenlecks trägt dazu bei, negative Folgen zu vermeiden, die Verluste in Höhe von mehreren Millionen Dollar zur Folge haben können. In der modernen Welt verarbeitet und speichert jedes Unternehmen vertrauliche Informationen. Bei großen Unternehmen ist das Volumen an vertraulichen Informationen enorm. Der "Sicherheitszustand" eines Computers ist ein konzeptionelles Ideal, das erreicht wird, wenn jeder Benutzer alle Regeln zur Informationssicherheit einhält.



Im Büro verlässt jeder Mitarbeiter von Zeit zu Zeit seinen Computer, und der eingeschaltete Computer ist unbeaufsichtigt, häufig mit Dateien und Ordnern, die für den Zugriff geöffnet sind, da viele Mitarbeiter einfach vergessen, ihren PC zu sperren, oder dies nicht absichtlich tun, wenn sie sich an einem ähnlichen Satz orientieren - "Ich bin fünf Meter zurückgegangen, warum sollte ich es blockieren?" Leider können andere an den Materialien interessierte Mitarbeiter solche Momente nutzen.







Wie können Sie in solchen Situationen die Datensicherheit gewährleisten? Eine Möglichkeit wäre die Verwendung biometrischer Authentifizierungstechnologien, um Benutzer an ihren Gesichtern zu erkennen.



Die Gesichtserkennung ist kein neues Konzept, und derzeit gibt es viele Tools, um diese Aufgabe zu erfüllen. Wenn Sie sich mit Methoden und Werkzeugen zur Gesichtserkennung nicht besonders auskennen, ist die Verwendung der Open-Source-Computer-Vision-Bibliothek (Open-Source-Computer-Vision-Bibliothek) und der Programmiersprache Python eine hervorragende Lösung, mit der Sie Ihr Ziel so schnell wie möglich erreichen können.







Wir haben uns für die Software entschieden, wir brauchen noch eine Hardware - eine Webkamera. Wie richten Sie jetzt die Gesichtserkennung ein? Zuerst müssen Sie das Gesicht im Rahmen erkennen. Eine der Methoden zur Erkennung von Gesichtern ist die Viola-Jones-Methode, die bereits 2001 beschrieben wurde. Da wir uns mehr für die Praxis interessieren, werden wir nicht auf theoretische Details eingehen, sondern nur erwähnen, dass die Methode auf Grundprinzipien wie der Umwandlung eines Bildes in eine integrale Darstellung, der Scanfenstermethode und der Verwendung von Haar-Merkmalen basiert. Sie können die Beschreibung der Methode lesen und Informationen zur Installation von OpenCV auf der offiziellen Website finden . Unten finden Sie den Python-Code, mit dem wir Gesichter aus einem Webcam-Videostream erkennen können: 



import cv2 as cv
import numpy as np

face_cascade = 'haarcascade_frontalface_default.xml'
cam = 1

classifier = cv.CascadeClassifier(face_cascade)

video_stream = cv.VideoCapture(cam)
while True:
    retval, frame = video_stream.read()
    gray_frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
    found_faces = classifier.detectMultiScale(gray_frame, 1.2, 5, minSize=(197, 197))

    for x, y, w, h in found_faces:
        cv.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

    cv.namedWindow('Stream', cv.WINDOW_NORMAL)
    cv.imshow('Stream', frame)

    k = cv.waitKey(30) & 0xFF
    if k == 27:
        break

video_stream.release()
cv.destroyAllWindows()


Im obigen Code importieren wir zuerst die beiden Module, die für die Arbeit benötigt werden: cv2 (Computer Vision) und numpy (Arbeiten mit Matrizen). Speichern Sie in der Variablen face_cascade den Pfad zur XML-Datei mit Haar-Kaskaden. Diese und andere Dateien, zum Beispiel zur Augenerkennung, finden Sie auf der Github- Seite .



In die variable Kamera schreiben wir die Nummer der Webkamera. Wenn mehrere verbunden sind, ist die Nummer der einzigen verbundenen Kamera standardmäßig 0. Als Nächstes wird mit der CascadeClassifier-Methode ein Klassifikatorobjekt erstellt und die Verbindung zur Kamera wird mit cv.VideoCapture (cam) hergestellt. Dann lesen wir in einer Schleife die Bilder Frame für Frame mit der read () -Methode in die Frame-Variable. Der Klassifizierer verarbeitet das Bild in Graustufen. Daher transformieren wir das Bild mithilfe der cvtColor-Methode in die gewünschte Form. Die Methode detectMultiScale gibt eine Liste mit Parametern aller erkannten Flächen zurück, bei denen es sich um ein Rechteck handelt - die Scheitelpunktkoordinate (x, y) sowie die Breite und Höhe des Rechtecks ​​(w, h). Die folgenden Zeilen sind optional, damit das Programm funktioniert, aber nützlich für das Debuggen - die Rechteckmethode fügt dem Quellframe an der Position des erkannten Gesichts einen Frame hinzu und zeigt ein Fenster mit einem Videostream an.



Hier ist alles ganz einfach, aber weiter interessanter. Jetzt müssen wir das Gesicht erkennen. Wie kann man es machen? OpenCV enthält mehrere Methoden zur Gesichtserkennung, darunter die LBPH-Methode (Local Binary Patterns Histograms). Hier werden wir näher darauf eingehen und ein wenig verstehen, wie es funktioniert.



Im Allgemeinen werden die Helligkeitswerte des Bildpixels und acht weitere Pixel, die das Original umgeben, aufgenommen. Es ergibt sich eine 3x3-Tabelle mit Pixelhelligkeitswerten. Dann werden 0 oder 1 in dieselbe Tabelle geschrieben. Wenn der Helligkeitswert des äußersten Pixels den Helligkeitswert des zentralen Pixels überschreitet, wird 1 gesetzt, andernfalls - 0. Dann wird der resultierende Code im Uhrzeigersinn aus der oberen linken Zelle gelesen, in eine Dezimalzahl umgewandelt und diese Zahl wird geschrieben in eine bildgroße Matrix an der entsprechenden Position. Und so für jedes Pixel.







Die Matrix wird in eine bestimmte Anzahl von Segmenten unterteilt (standardmäßig ist es ein 8 × 8-Raster), für jedes Segment wird ein Histogramm erstellt, und am Ende wird durch Verketten der Histogramme eine resultierende Charakterisierung des gesamten Bildes erhalten. Während der Erkennung wird für das untersuchte Bild dasselbe Histogramm aufgezeichnet, das dann mit den Trainingsdaten verglichen wird.







Wir werden diese Methode verwenden, aber zuerst müssen Sie einen weiteren wichtigen Schritt ausführen - eine Basis mit Gesichtern erstellen. Im Allgemeinen sieht die Struktur der Datenbank folgendermaßen aus: 



--Storage\\
	--Person_1\\
		--img_1.jpg
		--img_2.jpg
		…
		--img_n.jpg
	…
	--Person_m\\
                --img_1.jpg
		--img_2.jpg
		…
		--img_n.jpg


Ok, wir haben eine Basis mit Bildern von Gesichtern. Jetzt müssen Sie die Basis für das Training oder das Training des Algorithmus irgendwie verarbeiten. Die Verarbeitung läuft darauf hinaus, eine Liste aller Bilder und eine Liste der IDs oder Tags für jede Person zu generieren. Der einfachste Code für diese Aktion könnte folgendermaßen aussehen: 



storage = 'storage'
images = []
labels = []
names = {}
id = 0

for subdir in os.scandir(storage):
    names[id] = subdir.name
    subdir_path = os.path.join(storage, subdir.name)

    for file in os.scandir(subdir_path):
        if file.name.split('.')[-1].lower() not in ['png', 'bmp', 'jpeg', 'gif']:
            continue
        file_path = os.path.join(subdir_path, file.name)
        image = cv.imread(file_path, 0)
        label = id
        images.append(image)
        labels.append(label)
    id += 1


Auch hier ist alles ziemlich einfach. Die Speichervariable speichert den Pfad zu dem Ordner, der die Ordner mit Bildern der Gesichter von Personen enthält, dann eine Liste für Bilder, eine Liste für Tags und ein Wörterbuch mit Namen. So funktioniert es: Alle Bilder aus dem Ordner einer bestimmten Person werden zur Liste der Bilder hinzugefügt. Es gibt beispielsweise 15 davon. Wenn dies der erste Ordner aus dem Speicher ist, ist das Etikett gleich 0, sodass 0 bis zu 15 Mal gleichzeitig zur Liste der Etiketten hinzugefügt werden Im Namenswörterbuch wird ein Datensatz erstellt, in dem der Schlüssel die Bezeichnung und der Wert der Name der Person ist (der Name des Ordners mit den Bildern einer bestimmten Person). Und so für den gesamten Speicher. Im obigen Code sollten Sie auf die Linie mit der Imread-Methode achten - hier wird das Bild gelesen und als Matrix der Pixelhelligkeit dargestellt und in die Bildvariable geschrieben.



Jetzt trainiert der unterhaltsame Teil den Algorithmus: 



recognizer = cv.face.LBPHFaceRecognizer_create(1, 8, 8, 8, 130) 
recognizer.train(images, np.array(labels))


In der ersten Codezeile initialisieren wir den Algorithmus mit der LBPHFaceRecognizer_create-Methode. Erinnern Sie sich an die Beschreibung des LBPH-Algorithmus? Die Parameter der genannten Funktion enthalten nur das, worüber wir gesprochen haben: den Radius, entlang dessen Rand die Pixel um den gewünschten herum genommen werden, die Anzahl der Pixel aus dem durch den Radius gebildeten "Kreis", die Anzahl der Segmente horizontal und vertikal und den Schwellenwert, der die Erkennungsentscheidung beeinflusst Personen, dh je strenger die Anforderungen, desto niedriger die Schwelle. Als nächstes nennen wir die Zugmethode für das Training und übergeben die Listen der Bilder und Beschriftungen als Argumente. Jetzt hat der Algorithmus die Gesichter aus der Datenbank gespeichert und kann sie erkennen. Die Sache ist klein, es bleibt ein paar Zeilen zum ersten Code in der Schleife hinzuzufügen (für x, y, w, h in found_faces): Nachdem wir ein Gesicht erkannt haben, müssen wir es erkennen, und wenn das Gesicht nicht erkannt wird,oder eine andere Person erkannt wird, dann sofort den Computer sperren! 



roi = gray_frame[y:y+h, x:x+w]
name, dist = recognizer.predict(roi)
cv.putText(frame, '%s - %.0f' % (names[name], dist), (x, y), cv.FONT_HERSHEY_DUPLEX, 1, (0, 255, 0), 3)
if names[name] != "Ivan Petrov":
    ctypes.windll.user32.LockWorkStation()


In der ersten Zeile ist roi (aus dem interessierenden Bereich) eine Variable, in die wir ein Fragment des Bildes schreiben, das das erkannte Gesicht enthält. Die nächste Zeile erkennt das Gesicht direkt, wenn die Vorhersagemethode aufgerufen wird. Diese Methode gibt eine Beschriftung zurück, die dem erkannten Gesicht entspricht, und einen Wert, der den Grad der Diskrepanz zwischen dem erkannten und dem erkannten Gesicht kennzeichnet (je kleiner es ist, desto höher ist der Grad der Sicherheit, dass das richtige Gesicht erkannt wurde). Fügen Sie als Nächstes zum Debuggen mit der putText-Methode erneut Text mit dem Namen der erkannten Person zum Frame hinzu. Und schließlich überprüfen wir die einfachste Bedingung: Wenn ein Nicht-Besitzer des PCs erkannt wurde (hier wurde ein Wörterbuch mit Namen benötigt), sperren Sie den Computer. Wie Sie sehen, ist die Zeile ctypes.windll.user32.LockWorkStation () für das Blockieren verantwortlich. Damit es funktioniertmuss das ctypes-Modul neben cv2 und numpy importieren.



Infolgedessen wird der PC blockiert, sobald das Gesicht einer anderen Person erkannt wurde oder es im Prinzip nicht erkannt wurde. Nach dem Entsperren des PCs läuft das Programm weiter. Sie können auch eine PC-Sperre hinzufügen, wenn ein Mitarbeiter seinen Arbeitsplatz verlässt. Sie müssen nicht lange nachdenken, um zu verstehen, dass es hier einige Nuancen gibt. Was ist zum Beispiel, wenn im Hintergrund ein anderes Gesicht erkannt wird? In dieser Situation können Sie die Mindestgröße eines Objekts festlegen, das wie ein Gesicht aussieht. Gesichter im Hintergrund werden dann ignoriert (dazu gibt es in der Methode detectMultiScale einen Parameter minSize). In anderen Situationen können auf Wunsch auch gute Lösungen gefunden werden.



Einer der wichtigsten Faktoren für die ordnungsgemäße Blockierung ist die Qualität der Bilder in der Fotodatenbank. Erstens ist es wünschenswert, dass es viele von ihnen für eine bestimmte Person gibt, mit unterschiedlichen Winkeln und Gesichtsausdrücken. Zweitens nimmt die Beleuchtung ihre eigenen Anpassungen vor. Es lohnt sich daher, diesen Punkt zu berücksichtigen und Bilder zu verwenden, die unter verschiedenen Lichtbedingungen aufgenommen wurden. Und drittens sollten Sie Bilder von der Webcam am Arbeitsplatz des Mitarbeiters aufzeichnen. Es gibt auch eine Methode zum Speichern von Bildern in OpenCV. Der Code wird mit Sicherheit erweitert und es werden zusätzliche Funktionen hinzugefügt, sodass er mithilfe von Klassen in Funktionen „eingeschlossen“ werden kann. Der Perfektion sind keine Grenzen gesetzt! Die Hauptsache ist, sich an die Reihenfolge der Programmaktionen zu erinnern: Verarbeiten der Datenbank mit Fotos, Training, Erkennung, Erkennung.



Beim Webinar 03.09.2020 10-00 Uhr Moskauer Zeit stellen die Referenten eine praktische Methode zum Trainieren eines neuronalen Netzwerks zur Erkennung von Objekten mit dem verwendeten Quellcode und den verwendeten Technologien vor und beantworten auch Ihre Fragen. Sie können sich unter folgendem Link registrieren: newtechaudit.ru/vebinar-computer-vision





More articles:


All Articles