Mensen beschermen tegen gevaarlijke gebieden via virtuele grenzen met Computer Vision

Nu bedrijven meer autonome robots en ander zwaar materieel op de werkvloer verwelkomen, moeten we ervoor zorgen dat apparatuur veilig kan functioneren rond menselijke teamgenoten. In dit bericht laten we u zien hoe u een virtuele grens kunt bouwen met computervisie en AWS DeepLens, de AWS-videocamera met deep learning-functionaliteit, ontworpen voor ontwikkelaars om machine learning (ML) te leren. Met behulp van de machine learning-technieken in dit bericht kun je virtuele grenzen stellen voor beperkte gebieden, waardoor apparatuur automatisch wordt uitgeschakeld of een waarschuwingssignaal klinkt wanneer mensen in de buurt komen.

Voor dit project train je een aangepast objectdetectiemodel Amazon Sage Maker en implementeer het model op een AWS DeepLens-apparaat. Objectdetectie is een ML-algoritme dat een afbeelding als invoer neemt en objecten en hun locatie binnen de afbeelding identificeert. Naast virtuele grensoplossingen kunt u de in dit bericht geleerde technieken toepassen wanneer u wilt detecteren waar bepaalde objecten zich in een afbeelding bevinden of het aantal exemplaren van een gewenst object in een afbeelding wilt tellen, zoals het tellen van items in een opslagbak of op een winkelplank.

Overzicht oplossingen

De walkthrough omvat de volgende stappen:

1. Bereid uw dataset voor om in een ML-algoritme te worden ingevoerd.
2. Train een model met Amazon SageMaker.
3. Testmodel met aangepaste beperkingszones.
4. Implementeer de oplossing voor AWS DeepLens.

We bespreken ook andere praktijkvoorbeelden waarin u deze oplossing kunt toepassen.

Het volgende diagram illustreert de oplossingsarchitectuur.

Voorwaarden

Om deze walkthrough te voltooien, moet u aan de volgende voorwaarden voldoen:

Bereid uw dataset voor om in een ML-algoritme te worden ingevoerd

Dit bericht maakt gebruik van een ML-algoritme, een objectdetectiemodel genaamd, om een ​​oplossing te bouwen die detecteert of een persoon zich in een aangepaste beperkte zone bevindt. U gebruikt het openbaar beschikbare Gegevensset voor voetgangersdetectie beschikbaar op Kaggle, dat meer dan 2,000 afbeeldingen heeft. Deze dataset bevat labels voor menselijke en mensachtige objecten (zoals mannequins), zodat het getrainde model nauwkeuriger onderscheid kan maken tussen echte mensen en kartonnen rekwisieten of standbeelden.

De volgende afbeeldingen zijn bijvoorbeeld voorbeelden van een bouwvakker die wordt gedetecteerd en of deze zich in de aangepaste beperkingszone bevindt (rode omtrek).

Om te beginnen met het trainen van uw model, Maak eerst een S3-bucket om uw trainingsgegevens en modeluitvoer op te slaan. Voor AWS DeepLens-projecten moeten de S3-bucketnamen beginnen met het voorvoegsel deeplens-. U gebruikt deze gegevens om een ​​model te trainen met SageMaker, een volledig beheerde service die de mogelijkheid biedt om snel ML-modellen te bouwen, trainen en implementeren.

Train een model met Amazon SageMaker

U gebruikt SageMaker Jupyter-notebooks als ontwikkelomgeving om het model te trainen. Jupyter Notebook is een open-source webapplicatie waarmee u documenten kunt maken en delen die live code, vergelijkingen, visualisaties en verhalende tekst bevatten. Voor dit bericht bieden wij Train_Object_Detection_People_DeepLens.ipynb, een volledig notitieboekje dat u kunt volgen.

Als u een aangepast objectdetectiemodel wilt maken, moet u een trainingstaakinstantie met grafische verwerkingseenheid (GPU) gebruiken. GPU's zijn uitstekend in het parallelliseren van berekeningen die nodig zijn om een ​​neuraal netwerk te trainen. Hoewel de notebook zelf een enkele ml.t2.medium-instantie is, maakt de trainingstaak specifiek gebruik van een ml.p2.xlarge-instantie. Om toegang te krijgen tot een trainingstaak met GPU-ondersteuning, moet u: een verzoek indienen voor een verhoging van de servicelimiet naar het AWS-ondersteuningscentrum.

Nadat u uw limietverhoging heeft ontvangen, voert u de volgende stappen uit om een ​​SageMaker-notebookinstantie te maken:

1. Kies op de SageMaker-console Notebook-exemplaren.
2. Kies Maak een notitieboekexemplaar.
3. Voor Naam van exemplaar van notebookVoer een naam in voor uw notebookinstantie.
4. Voor Instantietype, kiezen t2.middel.

Dit is het minst dure exemplaartype dat door notebookinstanties wordt ondersteund, en het is voldoende voor deze zelfstudie.

5. Voor IAM-rol, kiezen Maak een nieuwe rol.

Zorg ervoor dat dit AWS Identiteits- en toegangsbeheer (IAM)-rol heeft toegang tot de S3-bucket die u eerder hebt gemaakt (prefix deeplens-).

6. Kies Maak een notitieboekexemplaar. Het opstarten van uw notebookinstantie kan enkele minuten duren.

7. Kies wanneer de status op de pagina met notebookinstanties verandert in InService Jupyter openen om uw zojuist gemaakte Jupyter-notebookinstantie te starten.
8. Kies Uploaden om de te uploaden Train_Object_Detection_people_DeepLens.ipynb bestand dat u eerder hebt gedownload.

9. Open het notitieboekje en volg het tot het einde.
10. Als u wordt gevraagd over het instellen van de kernel, selecteert u conda_mxnet_p36.

Het Jupyter-notebook bevat een combinatie van tekst- en codecellen. Om een ​​stukje code uit te voeren, kiest u de cel en drukt u op Shift + Enter. Terwijl de cel actief is, verschijnt er een sterretje naast de cel. Wanneer de cel compleet is, verschijnen een uitvoernummer en een nieuwe uitvoercel onder de oorspronkelijke cel.

11. Download de dataset van de openbare S3-bucket naar de lokale SageMaker-instantie en pak de gegevens uit. Dit kunt u doen door de code in het notitieblok te volgen:

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

12. Converteer de gegevensset naar een formaat (RecordIO) die in het SageMaker-algoritme kunnen worden ingevoerd:

     !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. Breng de RecordIO-bestanden terug naar Amazon S3.

Nu u klaar bent met alle gegevensvoorbereiding, bent u klaar om de objectdetector te trainen.

Er zijn veel verschillende soorten algoritmen voor objectdetectie. Voor dit bericht gebruik je de Single-Shot MultiBox-detectiealgoritme (SSD). Het SSD-algoritme heeft een goede balans tussen snelheid en nauwkeurigheid, waardoor het ideaal is voor gebruik op edge-apparaten zoals AWS DeepLens.

Als onderdeel van de trainingstaak hebt u veel opties voor hyperparameters die helpen bij het configureren van het trainingsgedrag (zoals het aantal tijdperken, de leersnelheid, het type optimalisatie en de minibatchgrootte). Met hyperparameters kunt u de trainingssnelheid en nauwkeurigheid van uw model afstemmen. Zie voor meer informatie over hyperparameters Algoritme voor objectdetectie.

15. Stel uw hyperparameters en datakanalen in. Overweeg het gebruik van de volgende voorbeelddefinitie van hyperparameters:

     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) 

Het notebook heeft een aantal standaard hyperparameters die vooraf zijn geselecteerd. Voor voetgangersdetectie traint u het model voor 100 tijdvakken. Deze trainingsstap duurt ongeveer 2 uur met één ml.p2.xlarge-instantie. U kunt experimenteren met verschillende combinaties van de hyperparameters, of trainen voor meer tijdperken voor prestatieverbeteringen. Voor informatie over de meest recente prijzen, zie Amazon SageMaker-prijzen.

16. U kunt een trainingstaak starten met een enkele regel code en de nauwkeurigheid in de loop van de tijd controleren op de SageMaker-console:

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

Voor meer informatie over hoe training werkt, zie CreërenTrainingJob. Het inrichten en downloaden van gegevens kost tijd, afhankelijk van de omvang van de gegevens. Daarom kan het een paar minuten duren voordat u datalogboeken voor uw trainingstaken ontvangt.

U kunt de voortgang van uw trainingstaak volgen via de metrische gemiddelde gemiddelde precisie (mAP), waarmee u de kwaliteit kunt controleren van het vermogen van het model om objecten te classificeren en de juiste selectiekaders te detecteren. De datalogboeken drukken ook de mAP af van de validatiegegevens, naast andere verliezen, voor elke run van de dataset, één keer voor één tijdperk. Deze metriek is een indicatie voor de kwaliteit van de prestaties van het algoritme bij het nauwkeurig detecteren van de klasse en het nauwkeurige selectiekader eromheen.

Wanneer de taak is voltooid, kunt u de getrainde modelbestanden vinden in de S3-bucket en map die eerder zijn opgegeven in s3_output_location:

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

Voor dit bericht laten we resultaten zien van de validatieset aan het einde van het 10e tijdperk en het 100e tijdperk. Aan het einde van het 10e tijdperk zien we een validatie-mAP van ongeveer 0.027, terwijl het 100e tijdperk ongeveer 0.42 was.

Om betere detectieresultaten te bereiken, kunt u proberen de hyperparameters af te stemmen met behulp van de mogelijkheid die in SageMaker is ingebouwd automatische modelafstemming en train het model voor meer tijdperken. Meestal stopt u met trainen als u merkt dat de nauwkeurigheid afneemt.

Testmodel met aangepaste beperkingszones

Voordat u het getrainde model implementeert in AWS DeepLens, kunt u het in de cloud testen met behulp van een door SageMaker gehost eindpunt. Een SageMaker-eindpunt is een volledig beheerde service waarmee u realtime gevolgtrekkingen kunt maken via een REST API. Met SageMaker kunt u snel nieuwe eindpunten implementeren om uw modellen te testen, zodat u het model niet hoeft te hosten op de lokale instantie die is gebruikt om het model te trainen. Hierdoor kunt u op basis van het model voorspellingen doen (of gevolgtrekkingen maken) op basis van afbeeldingen die het algoritme tijdens de training niet heeft gezien.

U hoeft niet te hosten op hetzelfde exemplaartype dat u hebt getraind. Training is een langdurige en rekenintensieve taak waarvoor andere reken- en geheugenvereisten nodig zijn dan bij hosting doorgaans niet het geval is. U kunt elk type exemplaar kiezen waarop u het model wilt hosten. In dit geval kozen we ervoor om de ml.p3.2xlarge-instantie te trainen, maar we kozen ervoor om het model te hosten op de goedkopere CPU-instantie, ml.m4.xlarge. Het volgende codefragment toont onze eindpuntimplementatie.

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

Detectie in een aangepaste beperkingszone (interessegebied)

Het formaat van de uitvoer kan worden weergegeven als [class_index, confidentie_score, xmin, ymin, xmax, ymax]. Voorspellingen met een laag vertrouwen hebben vaak een grotere kans op een vals-positief of vals-negatief, dus voorspellingen met een laag vertrouwen moet u waarschijnlijk terzijde schuiven. U kunt de volgende code gebruiken om te detecteren of het selectiekader van de persoon overlapt met de beperkte zone.

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 

Standaard wordt het volledige frame geëvalueerd op menselijke aanwezigheid. U kunt echter eenvoudig het interessegebied opgeven waarbinnen de aanwezigheid van een persoon als hoog risico wordt beschouwd. Als u een aangepaste beperkingszone wilt toevoegen, voegt u de coördinaten toe van de hoekpunten van het gebied dat wordt weergegeven door [X-as,Y-as] en maakt u de polygoon. De coördinaten moeten met de klok mee of tegen de klok in worden ingevoerd. Zie de volgende code:

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

De volgende voorbeeldcode toont voetgangers die binnen een beperkingsgebied worden geïdentificeerd:

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)) 

De volgende afbeeldingen tonen onze resultaten.

Implementeer de oplossing voor AWS DeepLens

Converteer het model voor implementatie naar AWS DeepLens

Wanneer u een door SageMaker getraind SSD-model implementeert op AWS DeepLens, moet u eerst uitvoeren implementeren.py om het modelartefact om te zetten in een inzetbaar model:

!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

Importeer uw model in AWS DeepLens

Om het model op een AWS DeepLens-apparaat uit te voeren, moet u een AWS DeepLens-project maken. Begin met het importeren van uw model in AWS DeepLens.

1. Op de AWS DeepLens-console, onder Resources, kiezen Modellen.
2. Kies Model importeren.

3. Voor Bron importerenselecteer Extern opgeleid model.
4. Voer de Amazon S3-locatie van het gepatcht model die u in de bovenstaande stap hebt opgeslagen door het uitvoeren van implement.py.
5. Voor Modelkader, kiezen MXNet.
6. Kies Model importeren.

Maak de gevolgtrekkingsfunctie

De gevolgtrekkingsfunctie voert elk cameraframe in het model in om voorspellingen te verkrijgen en voert aangepaste bedrijfslogica uit op basis van de gevolgtrekkingsresultaten. Je gebruikt AWS Lambda om een ​​functie te maken die u implementeert in AWS DeepLens. De functie voert de gevolgtrekking lokaal uit op het AWS DeepLens-apparaat.

Eerst moeten we een Lambda-functie maken om te implementeren in AWS DeepLens.

1. Download de gevolgtrekking Lambda-functie.
2. Kies op de Lambda-console Functies.
3. Kies Maak functie.
4. kies Auteur vanaf nul.
5. Voor Functienaam, voer een naam in.
6. Voor Runtime, kiezen Python 3.7.
7. Voor Kies of maak een uitvoeringsrol, kiezen Gebruik een bestaande rol.
8. Kies service-rol / AWSDeepLensLambdaRole.
9. Kies Maak functie.

10. Op de detailpagina van de functie, op de Acties menu, kies Upload een .zip-bestand.

11. Upload de gevolgtrekking Lambda bestand dat u eerder hebt gedownload.
12. Kies Bespaar om de ingevoerde code op te slaan.
13. Op de Acties menu, kies Publiceer nieuwe versie.

Door de functie te publiceren, wordt deze beschikbaar op de AWS DeepLens-console, zodat u deze aan uw aangepaste project kunt toevoegen.

14. Voer een versienummer in en kies Publiceer.

De inferentiefunctie begrijpen

In dit gedeelte wordt u door enkele belangrijke onderdelen van de inferentiefunctie geleid. Eerst moet u op twee specifieke bestanden letten:

• labels.txt – Bevat een mapping van de output van het neurale netwerk (gehele getallen) naar voor mensen leesbare labels (string)
• lambda_function.py – Bevat code voor de functie die wordt aangeroepen om voorspellingen te genereren voor elk cameraframe en resultaten terug te sturen

In lambda_function.py laadt en optimaliseert u eerst het model. Vergeleken met virtuele cloudmachines met een GPU heeft AWS DeepLens minder rekenkracht. AWS DeepLens gebruikt de Intel OpenVino-modeloptimalisatie om het model dat in SageMaker is getraind te optimaliseren om op de hardware te draaien. De volgende code optimaliseert uw model zodat het lokaal kan worden uitgevoerd:

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}) 

Vervolgens voer je het model frame-per-frame uit over de beelden van de camera. Zie de volgende 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)) 

Ten slotte stuurt u de tekstvoorspellingsresultaten terug naar de cloud. Het bekijken van de tekstresultaten in de cloud is een handige manier om er zeker van te zijn dat het model correct werkt. Elk AWS DeepLens-apparaat heeft een speciaal iot_topic dat automatisch wordt aangemaakt om de gevolgtrekkingsresultaten te ontvangen. Zie de volgende code:

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

Maak een aangepast AWS DeepLens-project

Voer de volgende stappen uit om een ​​nieuw AWS DeepLens-project te maken:

1. Op de AWS DeepLens-console, op de Projecten pagina, kies Maak een project aan.
2. Voor Project typeselecteer Maak een nieuw leeg project.
3. Kies Volgende.

4. Geef je project een naam yourname-pedestrian-detector-.
5. Kies Model toevoegen.
6. Selecteer het model dat u zojuist hebt gemaakt.
7. Kies Functie toevoegen.
8. Zoek op naam naar de Lambda-functie die je eerder hebt gemaakt.
9. Kies Maak een project aan.
10. Op de Projecten pagina, selecteer het project dat u wilt implementeren.
11. Chose Implementeer op apparaat.
12. Voor Doelapparaat, kies uw apparaat.
13. Kies Beoordeling.
14. Controleer uw instellingen en kies Implementeren.

Het kan tot 10 minuten duren voordat de implementatie is voltooid, afhankelijk van de snelheid van het netwerk waarmee uw AWS DeepLens is verbonden. Wanneer de implementatie is voltooid, zou u een groene banner op de pagina moeten zien met het bericht: "Gefeliciteerd, uw model draait nu lokaal op AWS DeepLens!"

Als u de tekstuitvoer wilt zien, bladert u omlaag op de pagina met apparaatdetails naar de Projectoutput sectie. Volg de instructies in de sectie om het onderwerp te kopiëren en ga naar de AWS IoT-kern console om u op het onderwerp te abonneren. U zou de resultaten moeten zien zoals in de volgende schermafbeelding.

Voor stapsgewijze instructies voor het bekijken van de videostream of tekstuitvoer, zie Resultaten bekijken van AWS DeepLens.

Praktijkgevallen

Nu u voorspellingen heeft van uw model dat op AWS DeepLens draait, gaan we die voorspellingen omzetten in waarschuwingen en inzichten. Enkele meest voorkomende toepassingen voor een project als dit zijn:

• Begrijpen hoeveel mensen op een bepaalde dag een beperkingsgebied betreden, zodat bouwplaatsen plekken kunnen identificeren waar meer veiligheidsborden nodig zijn. Dit kan door de resultaten te verzamelen en op basis daarvan een dashboard te maken Amazon QuickSight. Voor meer details over het maken van een dashboard met QuickSight, zie Bouw een work-from-home houdingstracker met AWS DeepLens en GluonCV.
• Het verzamelen van de uitvoer van AWS DeepLens en het configureren van een Raspberry Pi om een ​​waarschuwing te geven wanneer iemand een beperkte zone binnenloopt. Voor meer details over het verbinden van een AWS DeepLens-apparaat met een Raspberry Pi-apparaat, zie Een prullenbak sorter bouwen met AWS DeepLens.

Conclusie

In dit bericht heb je geleerd hoe je een objectdetectiemodel traint en implementeert in AWS DeepLens om mensen te detecteren die beperkte zones betreden. U kunt deze zelfstudie gebruiken als referentie voor het trainen en implementeren van uw eigen aangepaste objectdetectieprojecten op AWS DeepLens.

Voor een meer gedetailleerde uitleg van deze tutorial en andere tutorials, voorbeelden en projectideeën met AWS DeepLens, zie AWS DeepLens-recepten.

Over de auteurs

Yash Shah is een datawetenschapper in het Amazon ML Solutions Lab, waar hij werkt aan een reeks gebruiksscenario's voor machine learning, van gezondheidszorg tot productie en detailhandel. Hij heeft een formele achtergrond in Human Factors en Statistieken en maakte eerder deel uit van het Amazon SCOT-team dat producten ontwierp om 3P-verkopers te begeleiden met efficiënt voorraadbeheer.

Phu Nguyen is productmanager voor AWS Panorama. Hij bouwt producten waarmee ontwikkelaars van elk vaardigheidsniveau op een eenvoudige, praktische manier kennis kunnen maken met machine learning.

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