Schutz von Menschen vor Gefahrenbereichen durch virtuelle Grenzen mit Computer Vision

Da Unternehmen autonomere Roboter und andere schwere Geräte am Arbeitsplatz begrüßen, müssen wir sicherstellen, dass Geräte sicher um menschliche Teamkollegen herum funktionieren können. In diesem Beitrag zeigen wir Ihnen, wie Sie eine virtuelle Grenze mit Computer Vision und Computer Vision erstellen AWS DeepLens, die AWS Deep Learning-fähige Videokamera, mit der Entwickler maschinelles Lernen (ML) erlernen können. Mithilfe der Techniken für maschinelles Lernen in diesem Beitrag können Sie virtuelle Grenzen für eingeschränkte Bereiche erstellen, die Geräte automatisch herunterfahren oder einen Alarm auslösen, wenn sich Menschen nähern.

Für dieses Projekt trainieren Sie ein benutzerdefiniertes Objekterkennungsmodell mit Amazon Sage Maker und stellen Sie das Modell auf einem AWS DeepLens-Gerät bereit. Die Objekterkennung ist ein ML-Algorithmus, der ein Bild als Eingabe verwendet und Objekte und ihre Position innerhalb des Bildes identifiziert. Zusätzlich zu virtuellen Grenzlösungen können Sie die in diesem Beitrag erlernten Techniken anwenden, wenn Sie erkennen müssen, wo sich bestimmte Objekte in einem Bild befinden, oder die Anzahl der Instanzen eines gewünschten Objekts in einem Bild zählen müssen, z. B. das Zählen von Elementen in einem Lagerplatz oder in einem Verkaufsregal.

Lösungsüberblick

Die exemplarische Vorgehensweise umfasst die folgenden Schritte:

1. Bereiten Sie Ihren Datensatz für die Einspeisung in einen ML-Algorithmus vor.
2. Trainiere ein Modell mit Amazon SageMaker.
3. Testmodell mit benutzerdefinierten Beschränkungszonen.
4. Stellen Sie die Lösung für AWS DeepLens bereit.

Wir diskutieren auch andere reale Anwendungsfälle, in denen Sie diese Lösung anwenden können.

Das folgende Diagramm zeigt die Lösungsarchitektur.

Voraussetzungen:

Um diese exemplarische Vorgehensweise abzuschließen, müssen Sie über die folgenden Voraussetzungen verfügen:

Bereiten Sie Ihren Datensatz für die Einspeisung in einen ML-Algorithmus vor

In diesem Beitrag wird ein ML-Algorithmus verwendet, der als Objekterkennungsmodell bezeichnet wird, um eine Lösung zu erstellen, die erkennt, ob sich eine Person in einer benutzerdefinierten Sperrzone befindet. Sie nutzen die öffentlich zugängliche Datensatz zur Fußgängererkennung verfügbar auf Kaggle, das über 2,000 Bilder hat. Dieser Datensatz enthält Beschriftungen für menschliche und menschenähnliche Objekte (wie Schaufensterpuppen), damit das trainierte Modell genauer zwischen echten Menschen und Requisiten oder Statuen aus Pappe unterscheiden kann.

Die folgenden Bilder zeigen beispielsweise, wie ein Bauarbeiter erkannt wird und ob er sich in der benutzerdefinierten Sperrzone befindet (roter Umriss).

Um mit dem Training Ihres Modells zu beginnen, Erstellen Sie zunächst einen S3-Bucket um Ihre Trainingsdaten und Modellausgaben zu speichern. Bei AWS DeepLens-Projekten müssen die S3-Bucket-Namen mit dem Präfix beginnen deeplens-. Sie verwenden diese Daten, um ein Modell mit SageMaker zu trainieren, einem vollständig verwalteten Dienst, der die Möglichkeit bietet, ML-Modelle schnell zu erstellen, zu trainieren und bereitzustellen.

Trainiere ein Modell mit Amazon SageMaker

Sie verwenden SageMaker Jupyter-Notebooks als Entwicklungsumgebung, um das Modell zu trainieren. Jupyter Notebook ist eine Open-Source-Webanwendung, mit der Sie Dokumente erstellen und freigeben können, die Live-Code, Gleichungen, Visualisierungen und narrativen Text enthalten. Für diesen Beitrag stellen wir zur Verfügung Train_Object_Detection_People_DeepLens.ipynb, ein vollständiges Notizbuch, dem Sie folgen können.

Um ein benutzerdefiniertes Objekterkennungsmodell zu erstellen, müssen Sie eine GPU-fähige Schulungsjobinstanz (Graphic Processing Unit) verwenden. GPUs eignen sich hervorragend zum Parallelisieren von Berechnungen, die zum Trainieren eines neuronalen Netzwerks erforderlich sind. Obwohl das Notizbuch selbst eine einzelne ml.t2.medium-Instanz ist, verwendet der Schulungsjob speziell eine ml.p2.xlarge-Instanz. Um auf eine GPU-fähige Instanz für Schulungsjobs zuzugreifen, müssen Sie einen Antrag auf Erhöhung des Servicelimits stellen an das AWS Support Center.

Führen Sie die folgenden Schritte aus, um eine SageMaker-Notebook-Instanz zu erstellen, nachdem Sie Ihre Limiterhöhung erhalten haben:

1. Wählen Sie in der SageMaker-Konsole Notebook-Instanzen.
2. Auswählen Erstellen Sie eine Notebook-Instanz.
3. Aussichten für Name der Notebook-InstanzGeben Sie einen Namen für Ihre Notebook-Instanz ein.
4. Aussichten für Instanztyp, wählen t2.mittel.

Dies ist der kostengünstigste Instanztyp, den Notebook-Instanzen unterstützen, und er reicht für dieses Lernprogramm aus.

5. Aussichten für IAM-Rolle, wählen Erstellen Sie eine neue Rolle.

Stellen Sie dies sicher AWS Identity and Access Management and Die Rolle (IAM) hat Zugriff auf den zuvor erstellten S3-Bucket (Präfix) deeplens-).

6. Auswählen Erstellen Sie eine Notebook-Instanz. Der Start Ihrer Notebook-Instanz kann einige Minuten dauern.

7. Wenn sich der Status auf der Seite mit den Notebook-Instanzen in InService ändert, wählen Sie Öffne Jupyter um Ihre neu erstellte Jupyter-Notebook-Instanz zu starten.
8. Auswählen Hochladen um das hochzuladen Train_Object_Detection_people_DeepLens.ipynb Datei, die Sie zuvor heruntergeladen haben.

9. Öffnen Sie das Notizbuch und folgen Sie ihm bis zum Ende.
10. Wenn Sie nach dem Einstellen des Kernels gefragt werden, wählen Sie conda_mxnet_p36.

Das Jupyter-Notizbuch enthält eine Mischung aus Text- und Codezellen. Um einen Code auszuführen, wählen Sie die Zelle aus und drücken Sie Shift + Enter. Während die Zelle ausgeführt wird, wird neben der Zelle ein Sternchen angezeigt. Wenn die Zelle fertig ist, werden eine Ausgabenummer und eine neue Ausgabezelle unter der ursprünglichen Zelle angezeigt.

11. Laden Sie das Dataset aus dem öffentlichen S3-Bucket in die lokale SageMaker-Instanz herunter und entpacken Sie die Daten. Dies kann durch Befolgen des Codes im Notizbuch erfolgen:

     !aws s3 cp s3://deeplens-public/samples/pedestriansafety/humandetection_data.zip . !rm -rf humandetection/ !unzip humandetection_data.zip -d humandetection 

12. Konvertieren Sie den Datensatz in ein Format (RecordIO), die in den SageMaker-Algorithmus eingespeist werden können:

     !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/train_mask.lst $DATA_PATH/ !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/val_mask.lst $DATA_PATH/ 

13. Übertragen Sie die RecordIO-Dateien zurück zu Amazon S3.

Nachdem Sie mit der gesamten Datenvorbereitung fertig sind, können Sie den Objektdetektor trainieren.

Es gibt viele verschiedene Arten von Objekterkennungsalgorithmen. Für diesen Beitrag verwenden Sie die Single-Shot-MultiBox-Erkennungsalgorithmus (SSD). Der SSD-Algorithmus bietet ein ausgewogenes Verhältnis zwischen Geschwindigkeit und Genauigkeit und ist daher ideal für die Ausführung auf Edge-Geräten wie AWS DeepLens geeignet.

Im Rahmen des Trainingsjobs stehen Ihnen zahlreiche Optionen für Hyperparameter zur Verfügung, mit denen Sie das Trainingsverhalten konfigurieren können (z. B. Anzahl der Epochen, Lernrate, Optimierungstyp und Mini-Batch-Größe). Mit Hyperparametern können Sie die Trainingsgeschwindigkeit und -genauigkeit Ihres Modells einstellen. Weitere Informationen zu Hyperparametern finden Sie unter Objekterkennungsalgorithmus.

15. Richten Sie Ihre Hyperparameter und Datenkanäle ein. Verwenden Sie die folgende Beispieldefinition für Hyperparameter:

     od_model = sagemaker.estimator.Estimator(training_image, role, train_instance_count=1, train_instance_type='ml.p2.xlarge', train_volume_size = 50, train_max_run = 360000, input_mode= 'File', output_path=s3_output_location, sagemaker_session=sess) od_model.set_hyperparameters(base_network='resnet-50', use_pretrained_model=1, num_classes=2, mini_batch_size=32, epochs=100, learning_rate=0.003, lr_scheduler_step='3,6', lr_scheduler_factor=0.1, optimizer='sgd', momentum=0.9, weight_decay=0.0005, overlap_threshold=0.5, nms_threshold=0.45, image_shape=300, num_training_samples=n_train_samples) 

Das Notebook verfügt über einige vorgewählte Standard-Hyperparameter. Für die Fußgängererkennung trainieren Sie das Modell für 100 Epochen. Dieser Trainingsschritt sollte mit einer ml.p2.xlarge-Instanz ungefähr 2 Stunden dauern. Sie können mit verschiedenen Kombinationen der Hyperparameter experimentieren oder weitere Epochen trainieren, um die Leistung zu verbessern. Informationen zu den neuesten Preisen finden Sie unter Amazon SageMaker Preise.

16. Sie können einen Schulungsjob mit einer einzigen Codezeile starten und die Genauigkeit über die Zeit auf der SageMaker-Konsole überwachen:

    od_model.fit(inputs=data_channels, logs=True) 

Weitere Informationen zur Funktionsweise von Schulungen finden Sie unter ErstellenTrainingJob. Die Bereitstellung und das Herunterladen von Daten nehmen je nach Größe der Daten Zeit in Anspruch. Daher kann es einige Minuten dauern, bis Sie Datenprotokolle für Ihre Schulungsjobs abrufen.

Sie können den Fortschritt Ihres Trainingsjobs anhand der metrischen mittleren Durchschnittsgenauigkeit (mAP) überwachen, mit der Sie die Qualität der Fähigkeit des Modells überwachen können, Objekte zu klassifizieren und die richtigen Begrenzungsrahmen zu erkennen. In den Datenprotokollen wird unter anderem der mAP für die Validierungsdaten für jeden Lauf des Datensatzes einmal für eine Epoche ausgedruckt. Diese Metrik ist ein Proxy für die Qualität der Leistung des Algorithmus bei der genauen Erkennung der Klasse und des genauen Begrenzungsrahmens um sie herum.

Wenn der Auftrag abgeschlossen ist, finden Sie die trainierten Modelldateien im S3-Bucket und im Ordner, die zuvor unter angegeben wurden s3_output_location:

s3_output_location = 's3://{}/{}/output'.format(BUCKET, PREFIX)

Für diesen Beitrag zeigen wir Ergebnisse zum Validierungssatz nach Abschluss der 10. und 100. Epoche. Am Ende der 10. Epoche sehen wir einen Validierungs-mAP von ungefähr 0.027, während die 100. Epoche ungefähr 0.42 betrug.

Um bessere Erkennungsergebnisse zu erzielen, können Sie versuchen, die Hyperparameter mithilfe der in SageMaker integrierten Funktion zu optimieren automatische Modellabstimmung und trainiere das Modell für weitere Epochen. Normalerweise hören Sie mit dem Training auf, wenn Sie einen abnehmenden Genauigkeitsgewinn feststellen.

Testmodell mit benutzerdefinierten Beschränkungszonen

Bevor Sie das trainierte Modell für AWS DeepLens bereitstellen, können Sie es in der Cloud mithilfe eines von SageMaker gehosteten Endpunkts testen. Ein SageMaker-Endpunkt ist ein vollständig verwalteter Dienst, mit dem Sie über eine REST-API in Echtzeit Rückschlüsse ziehen können. Mit SageMaker können Sie schnell neue Endpunkte bereitstellen, um Ihre Modelle zu testen, sodass Sie das Modell nicht auf der lokalen Instanz hosten müssen, die zum Trainieren des Modells verwendet wurde. Auf diese Weise können Sie aus dem Modell Vorhersagen (oder Schlussfolgerungen) für Bilder treffen, die der Algorithmus während des Trainings nicht gesehen hat.

Sie müssen nicht auf demselben Instanztyp hosten, den Sie zum Trainieren verwendet haben. Das Training ist ein langwieriger und rechenintensiver Job, der andere Rechen- und Speicheranforderungen erfordert als das Hosting normalerweise nicht. Sie können einen beliebigen Instanztyp auswählen, der das Modell hosten soll. In diesem Fall haben wir die Instanz ml.p3.2xlarge zum Trainieren ausgewählt, aber wir haben uns dafür entschieden, das Modell auf der kostengünstigeren CPU-Instanz ml.m4.xlarge zu hosten. Das folgende Codefragment zeigt unsere Endpunktbereitstellung.

object_detector = od_model.deploy(initial_instance_count = 1, instance_type = 'ml.m4.xlarge') 

Erkennung in einer benutzerdefinierten Restriktionszone (Region von Interesse)

Das Format der Ausgabe kann als [Klassenindex, Vertrauenspunktzahl, xmin, ymin, xmax, ymax] dargestellt werden. Vorhersagen mit geringem Vertrauen weisen häufig eine höhere Wahrscheinlichkeit für falsch positive oder falsch negative Ergebnisse auf. Daher sollten Sie Vorhersagen mit niedrigem Vertrauen wahrscheinlich verwerfen. Mit dem folgenden Code können Sie feststellen, ob sich der Begrenzungsrahmen der Person mit der eingeschränkten Zone überschneidet.

def inRestrictedSection(ImShape = None, R1 = None, restricted_region = None, kclass = None, score = None, threshold = None): statement = 'Person Not Detected in Restricted Zone' if (kclass == 1) and (score > threshold): Im1 = np.zeros((ImShape[0],ImShape[1],3), np.int32) cv2.fillPoly(Im1, [R1], 255) Im2 = np.zeros((ImShape[0],ImShape[1],3), np.int32) if restricted_region is None: restricted_region = np.array([[0,ImShape[0]],[ImShape[1],ImShape[0]],[ImShape[1],0], [0,0]], np.int32) cv2.fillPoly(Im2, [restricted_region], 255) Im = Im1 * Im2 if np.sum(np.greater(Im, 0))>0: statement = 'Person Detected in Restricted Zone' else: statement = statement return statement 

Standardmäßig wird der gesamte Frame auf menschliche Anwesenheit ausgewertet. Sie können jedoch leicht die Region von Interesse angeben, in der die Anwesenheit einer Person als hohes Risiko eingestuft wird. Wenn Sie eine benutzerdefinierte Einschränkungszone hinzufügen möchten, fügen Sie Koordinaten der Scheitelpunkte des durch [X-Achse, Y-Achse] dargestellten Bereichs hinzu und erstellen Sie das Polygon. Die Koordinaten müssen entweder im oder gegen den Uhrzeigersinn eingegeben werden. Siehe folgenden Code:

restricted_region = None #restricted_region = np.array([[0,200],[100,200],[100,0], [10,10]], np.int32) 

Der folgende Beispielcode zeigt Fußgänger, die innerhalb einer Sperrzone identifiziert wurden:

file_name = 'humandetection/test_images/t1_image.jpg' img = cv2.imread(file_name) img =cv2.cvtColor(img,cv2.COLOR_BGR2RGB) thresh = 0.2 height = img.shape[0] width = img.shape[1] colors = dict() with open(file_name, 'rb') as image: f = image.read() b = bytearray(f) ne = open('n.txt','wb') ne.write(b) results = object_detector.predict(b, initial_args={'ContentType': 'image/jpeg'}) detections = json.loads(results) object_categories = ['no-person', 'person'] for det in detections['prediction']: (klass, score, x0, y0, x1, y1) = det if score < thresh: continue cls_id = int(klass) prob = score if cls_id not in colors: colors[cls_id] = (random.random(), random.random(), random.random()) xmin = int(x0 * width) ymin = int(y0 * height) xmax = int(x1 * width) ymax = int(y1 * height) R1 = np.array([[xmin,ymin],[xmax,ymin],[xmax,ymax], [xmin,ymax]], np.int32) cv2.polylines(img,[R1],True, (255,255,0), thickness = 5) cv2.polylines(img,[restricted_region],True, (255,0,0), thickness = 5) plt.imshow(img) print(inRestrictedSection(img.shape,R1 = R1, restricted_region= restricted_region, kclass = cls_id, score = prob, threshold=0.2)) 

Die folgenden Bilder zeigen unsere Ergebnisse.

Stellen Sie die Lösung für AWS DeepLens bereit

Konvertieren Sie das Modell für die Bereitstellung in AWS DeepLens

Wenn Sie ein von SageMaker geschultes SSD-Modell für AWS DeepLens bereitstellen, müssen Sie es zuerst ausführen Deploy.py So konvertieren Sie das Modellartefakt in ein bereitstellbares Modell:

!rm -rf incubator-mxnet !git clone -b v1.7.x https://github.com/apache/incubator-mxnet MODEL_PATH = od_model.model_data TARGET_PATH ='s3://'+BUCKET+'/'+PREFIX+'/patched/' !rm -rf tmp && mkdir tmp rm -rf tmp && mkdir tmp !aws s3 cp $MODEL_PATH tmp !tar -xzvf tmp/model.tar.gz -C tmp !mv tmp/model_algo_1-0000.params tmp/ssd_resnet50_300-0000.params !mv tmp/model_algo_1-symbol.json tmp/ssd_resnet50_300-symbol.json !python incubator-mxnet/example/ssd/deploy.py --network resnet50 --data-shape 300 --num-class 2 --prefix tmp/ssd_ !tar -cvzf ./patched_model.tar.gz -C tmp ./deploy_ssd_resnet50_300-0000.params ./deploy_ssd_resnet50_300-symbol.json ./hyperparams.json !aws s3 cp patched_model.tar.gz $TARGET_PATH

Importieren Sie Ihr Modell in AWS DeepLens

Um das Modell auf einem AWS DeepLens-Gerät auszuführen, müssen Sie ein AWS DeepLens-Projekt erstellen. Importieren Sie zunächst Ihr Modell in AWS DeepLens.

1. Auf der AWS DeepLens-Konsole unter Downloads, wählen Modelle.
2. Auswählen Modell importieren.

3. Aussichten für Quelle importierenWählen Extern geschultes Modell.
4. Geben Sie den Amazon S3-Speicherort des ein gepatchtes Modell dass Sie im obigen Schritt vom Ausführen von deploy.py gespeichert haben.
5. Aussichten für Modellrahmen, wählen MXNet.
6. Auswählen Modell importieren.

Erstellen Sie die Inferenzfunktion

Die Inferenzfunktion speist jeden Kamerarahmen in das Modell ein, um Vorhersagen zu erhalten, und führt eine benutzerdefinierte Geschäftslogik aus, wenn die Inferenzergebnisse verwendet werden. Sie verwenden AWS Lambda um eine Funktion zu erstellen, die Sie in AWS DeepLens bereitstellen. Die Funktion führt Inferenz lokal auf dem AWS DeepLens-Gerät aus.

Zunächst müssen wir eine Lambda-Funktion erstellen, um sie in AWS DeepLens bereitzustellen.

1. Laden Sie die Inferenz Lambda-Funktion.
2. Wählen Sie auf der Lambda-Konsole Funktionen.
3. Auswählen Funktion erstellen.
4. Auswählen Autor von Grund auf neu.
5. Aussichten für Funktionsname, Geben Sie einen Namen ein.
6. Aussichten für Laufzeit, wählen Python 3.7.
7. Aussichten für Wählen Sie eine Ausführungsrolle aus oder erstellen Sie sie, wählen Verwenden Sie eine vorhandene Rolle.
8. Auswählen Servicerolle / AWSDeepLensLambdaRole.
9. Auswählen Funktion erstellen.

10. Auf der Detailseite der Funktion auf der Aktionen Menü, wählen Sie Laden Sie eine ZIP-Datei hoch.

11. Laden Sie die Folgerung Lambda Datei, die Sie zuvor heruntergeladen haben.
12. Auswählen Speichern um den eingegebenen Code zu speichern.
13. Auf dem Aktionen Menü, wählen Sie Neue Version veröffentlichen.

Durch das Veröffentlichen der Funktion wird sie auf der AWS DeepLens-Konsole verfügbar, sodass Sie sie Ihrem benutzerdefinierten Projekt hinzufügen können.

14. Geben Sie eine Versionsnummer ein und wählen Sie Veröffentlichen.

Die Inferenzfunktion verstehen

Dieser Abschnitt führt Sie durch einige wichtige Teile der Inferenzfunktion. Zunächst sollten Sie zwei bestimmte Dateien beachten:

• label.txt - Enthält eine Zuordnung der Ausgabe vom neuronalen Netzwerk (Ganzzahlen) zu von Menschen lesbaren Bezeichnungen (Zeichenfolge).
• lambda_function.py - Enthält Code für die aufgerufene Funktion, um Vorhersagen für jeden Kamerarahmen zu generieren und Ergebnisse zurückzusenden

In lambda_function.py laden und optimieren Sie zunächst das Modell. Im Vergleich zu virtuellen Cloud-Maschinen mit einer GPU verfügt AWS DeepLens über weniger Rechenleistung. AWS DeepLens verwendet den Intel OpenVino-Modelloptimierer, um das in SageMaker trainierte Modell für die Ausführung auf seiner Hardware zu optimieren. Der folgende Code optimiert Ihr Modell für die lokale Ausführung:

client.publish(topic=iot_topic, payload='Optimizing model...') ret, model_path = mo.optimize('deploy_ssd_resnet50_300', INPUT_W, INPUT_H) # Load the model onto the GPU. client.publish(topic=iot_topic, payload='Loading model...') model = awscam.Model(model_path, {'GPU': 1}) 

Anschließend führen Sie das Modell Bild für Bild über die Bilder der Kamera aus. Siehe folgenden Code:

while True: # Get a frame from the video stream ret, frame = awscam.getLastFrame() if not ret: raise Exception('Failed to get frame from the stream') # Resize frame to the same size as the training set. frame_resize = cv2.resize(frame, (INPUT_H, INPUT_W)) # Run the images through the inference engine and parse the results using # the parser API, note it is possible to get the output of doInference # and do the parsing manually, but since it is a ssd model, # a simple API is provided. parsed_inference_results = model.parseResult(model_type, model.doInference(frame_resize)) 

Schließlich senden Sie die Ergebnisse der Textvorhersage zurück in die Cloud. Das Anzeigen der Textergebnisse in der Cloud ist eine bequeme Methode, um sicherzustellen, dass das Modell ordnungsgemäß funktioniert. Jedes AWS DeepLens-Gerät verfügt über ein dediziertes iot_topic, das automatisch erstellt wird, um die Inferenzergebnisse zu erhalten. Siehe folgenden Code:

# Send results to the cloud client.publish(topic=iot_topic, payload=json.dumps(cloud_output)) 

Erstellen Sie ein benutzerdefiniertes AWS DeepLens-Projekt

Führen Sie die folgenden Schritte aus, um ein neues AWS DeepLens-Projekt zu erstellen:

1. Auf der AWS DeepLens-Konsole auf der Projekte Seite wählen Projekt anlegen.
2. Aussichten für ProjekttypWählen Erstellen Sie ein neues leeres Projekt.
3. Auswählen Weiter.

4. Benennen Sie Ihr Projekt yourname-pedestrian-detector-.
5. Auswählen Modell hinzufügen.
6. Wählen Sie das Modell aus, das Sie gerade erstellt haben.
7. Auswählen Funktion hinzufügen.
8. Suchen Sie nach der Lambda-Funktion, die Sie zuvor mit Namen erstellt haben.
9. Auswählen Projekt anlegen.
10. Auf dem Projekte Wählen Sie auf dieser Seite das Projekt aus, das Sie bereitstellen möchten.
11. Wählen Auf Gerät bereitstellen.
12. Aussichten für Zielgerät, wählen Sie Ihr Gerät.
13. Auswählen Bewertung.
14. Überprüfen Sie Ihre Einstellungen und wählen Sie Deploy.

Die Bereitstellung kann bis zu 10 Minuten dauern, abhängig von der Geschwindigkeit des Netzwerks, mit dem Ihre AWS DeepLens verbunden ist. Nach Abschluss der Bereitstellung sollte auf der Seite ein grünes Banner mit der Meldung "Herzlichen Glückwunsch, Ihr Modell wird jetzt lokal auf AWS DeepLens ausgeführt!" Angezeigt.

Scrollen Sie auf der Seite mit den Gerätedetails nach unten, um die Textausgabe anzuzeigen Projektausgabe Sektion. Befolgen Sie die Anweisungen im Abschnitt, um das Thema zu kopieren, und gehen Sie zu AWS IoT-Kern Konsole, um das Thema zu abonnieren. Sie sollten die Ergebnisse wie im folgenden Screenshot sehen.

Eine schrittweise Anleitung zum Anzeigen des Videostreams oder der Textausgabe finden Sie unter Anzeigen der Ergebnisse von AWS DeepLens.

Reale Anwendungsfälle

Nachdem Sie Vorhersagen von Ihrem Modell haben, das auf AWS DeepLens ausgeführt wird, konvertieren wir diese Vorhersagen in Warnungen und Erkenntnisse. Einige der häufigsten Verwendungszwecke für ein Projekt wie dieses sind:

• Verstehen, wie viele Personen an einem bestimmten Tag eine Sperrzone betreten haben, damit Baustellen Stellen identifizieren können, die mehr Sicherheitszeichen erfordern. Dies kann erreicht werden, indem die Ergebnisse gesammelt und verwendet werden, um mithilfe von ein Dashboard zu erstellen Amazon QuickSight. Weitere Informationen zum Erstellen eines Dashboards mit QuickSight finden Sie unter Erstellen Sie mit AWS DeepLens und GluonCV einen Workure-from-Home-Haltungs-Tracker.
• Sammeln der Ausgabe von AWS DeepLens und Konfigurieren eines Raspberry Pi, um einen Alarm auszulösen, wenn jemand eine eingeschränkte Zone betritt. Weitere Informationen zum Anschließen eines AWS DeepLens-Geräts an ein Raspberry Pi-Gerät finden Sie unter Erstellen eines Müllsortierers mit AWS DeepLens.

Zusammenfassung

In diesem Beitrag haben Sie gelernt, wie Sie ein Objekterkennungsmodell trainieren und in AWS DeepLens bereitstellen, um Personen zu erkennen, die eingeschränkte Zonen betreten. Sie können dieses Lernprogramm als Referenz verwenden, um Ihre eigenen benutzerdefinierten Objekterkennungsprojekte in AWS DeepLens zu trainieren und bereitzustellen.

Eine ausführlichere Anleitung zu diesem Lernprogramm und anderen Lernprogrammen, Beispielen und Projektideen mit AWS DeepLens finden Sie unter AWS DeepLens-Rezepte.

Über die Autoren

Jasch Schah ist Datenwissenschaftler im Amazon ML Solutions Lab, wo er an einer Reihe von Anwendungsfällen für maschinelles Lernen arbeitet, vom Gesundheitswesen über die Fertigung bis hin zum Einzelhandel. Er hat einen formalen Hintergrund in Human Factors and Statistics und war zuvor Teil des Amazon SCOT-Teams, das Produkte entwarf, um 3P-Verkäufern eine effiziente Bestandsverwaltung zu ermöglichen.

Phu Nguyen ist Produktmanager für AWS Panorama. Er entwickelt Produkte, die Entwicklern aller Könnensstufen eine einfache und praktische Einführung in das maschinelle Lernen ermöglichen.

Quelle: https://aws.amazon.com/blogs/machine-learning/protecting-people-through-virtual-boundaries-computer-vision/