Beskyttelse af mennesker mod farlige områder gennem virtuelle grænser med Computer Vision

Da virksomheder byder mere autonome robotter og andet tungt udstyr velkommen på arbejdspladsen, er vi nødt til at sikre, at udstyr kan fungere sikkert omkring menneskelige holdkammerater. I dette indlæg vil vi vise dig, hvordan du bygger en virtuel grænse med computersyn og AWS DeepLens, det AWS deep learning-aktiverede videokamera designet til udviklere at lære maskinlæring (ML). Ved at bruge maskinlæringsteknikkerne i dette indlæg kan du bygge virtuelle grænser for begrænsede områder, der automatisk lukker udstyr ned eller afgiver en alarm, når mennesker kommer tæt på.

Til dette projekt vil du træne en brugerdefineret objektdetekteringsmodel med Amazon SageMaker og implementer modellen til en AWS DeepLens-enhed. Objektdetektion er en ML-algoritme, der tager et billede som input og identificerer objekter og deres placering i billedet. Ud over virtuelle grænseløsninger kan du anvende teknikker lært i dette indlæg, når du skal opdage, hvor bestemte objekter er inde i et billede eller tælle antallet af forekomster af et ønsket objekt i et billede, såsom at tælle genstande i en lagerbeholder eller på en detailhylde.

Løsningsoversigt

Gennemgangen omfatter følgende trin:

1. Forbered dit datasæt til at feed ind i en ML-algoritme.
2. Træn en model med Amazon SageMaker.
3. Testmodel med tilpassede begrænsningszoner.
4. Implementer løsningen til AWS DeepLens.

Vi diskuterer også andre brugssager i den virkelige verden, hvor du kan anvende denne løsning.

Følgende diagram illustrerer løsningsarkitekturen.

Forudsætninger

For at gennemføre denne gennemgang skal du have følgende forudsætninger:

Forbered dit datasæt til at feed ind i en ML-algoritme

Dette indlæg bruger en ML-algoritme kaldet en objektdetektionsmodel til at bygge en løsning, der registrerer, om en person er i en tilpasset begrænset zone. Du bruger det offentligt tilgængelige Fodgængerdetekteringsdatasæt tilgængelig på Kaggle, som har over 2,000 billeder. Dette datasæt har etiketter til menneskelige og menneskelignende objekter (som mannequiner), så den trænede model kan mere præcist skelne mellem rigtige mennesker og paprekvisitter eller statuer.

For eksempel er følgende billeder eksempler på en bygningsarbejder, der bliver opdaget, og hvis de er i den tilpassede begrænsningszone (rød kontur).

For at begynde at træne din model, først oprette en S3-spand til at gemme dine træningsdata og modeloutput. For AWS DeepLens-projekter skal S3-bøttenavnene starte med præfikset deeplens-. Du bruger disse data til at træne en model med SageMaker, en fuldt administreret tjeneste, der giver mulighed for hurtigt at bygge, træne og implementere ML-modeller.

Træn en model med Amazon SageMaker

Du bruger SageMaker Jupyter-notebooks som udviklingsmiljø til at træne modellen. Jupyter Notebook er en open source-webapplikation, der giver dig mulighed for at oprette og dele dokumenter, der indeholder live-kode, ligninger, visualiseringer og fortællende tekst. Til dette indlæg leverer vi Train_Object_Detection_People_DeepLens.ipynb, en komplet notesbog, som du kan følge med i.

For at oprette en brugerdefineret objektdetekteringsmodel skal du bruge en grafisk behandlingsenhed (GPU)-aktiveret træningsjobinstans. GPU'er er fremragende til at parallelisere beregninger, der kræves for at træne et neuralt netværk. Selvom selve notebooken er en enkelt ml.t2.medium-instans, bruger træningsjobbet specifikt en ml.p2.xlarge-instans. For at få adgang til en GPU-aktiveret træningsjobinstans skal du indsende en anmodning om forhøjelse af servicegrænsen til AWS Support Center.

Når du har modtaget din grænseforøgelse, skal du udføre følgende trin for at oprette en SageMaker notebook-instans:

1. Vælg på SageMaker-konsollen Notebook-forekomster.
2. Vælg Opret notesbogsforekomst.
3. Til Notebook-forekomstnavn, indtast et navn til din notesbogsforekomst.
4. Til Forekomsttype, vælg t2.medium.

Dette er den billigste instanstype, som notebook-instanser understøtter, og den er tilstrækkelig til denne øvelse.

5. Til IAM rolle, vælg Lav en ny rolle.

Sørg for dette AWS identitets- og adgangsstyring (IAM)-rollen har adgang til den S3-indsamling, du oprettede tidligere (præfiks deeplens-).

6. Vælg Opret notesbogsforekomst. Din notebook-forekomst kan tage et par minutter at starte op.

7. Når status på notebook-forekomstsiden ændres til InService, skal du vælge Åbn Jupyter for at starte din nyoprettede Jupyter notebook-instans.
8. Vælg Upload at uploade Train_Object_Detection_people_DeepLens.ipynb fil, du downloadede tidligere.

9. Åbn notesbogen og følg den til ende.
10. Hvis du bliver spurgt om indstilling af kernen, skal du vælge conda_mxnet_p36.

Jupyter-notesbogen indeholder en blanding af tekst- og kodeceller. For at køre et stykke kode skal du vælge cellen og trykke på Skift + Enter. Mens cellen kører, vises en stjerne ved siden af ​​cellen. Når cellen er færdig, vises et outputnummer og en ny outputcelle under den originale celle.

11. Download datasættet fra den offentlige S3-bøtte til den lokale SageMaker-instans, og pak dataene ud. Dette kan gøres ved at følge koden i notesbogen:

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

12. Konverter datasættet til et format (RecordIO), der kan indlæses i SageMaker-algoritmen:

     !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. Overfør RecordIO-filerne tilbage til Amazon S3.

Nu hvor du er færdig med al dataforberedelsen, er du klar til at træne objektdetektoren.

Der er mange forskellige typer objektdetekteringsalgoritmer. Til dette indlæg bruger du Single-Shot MultiBox Detection Algoritme (SSD). SSD-algoritmen har en god balance mellem hastighed og nøjagtighed, hvilket gør den ideel til at køre på edge-enheder såsom AWS DeepLens.

Som en del af træningsjobbet har du en masse muligheder for hyperparametre, der hjælper med at konfigurere træningsadfærden (såsom antal epoker, indlæringshastighed, optimeringstype og mini-batchstørrelse). Hyperparametre giver dig mulighed for at justere træningshastigheden og nøjagtigheden af ​​din model. For mere information om hyperparametre, se Objektdetektionsalgoritme.

15. Opsæt dine hyperparametre og datakanaler. Overvej at bruge følgende eksempeldefinition af hyperparametre:

     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) 

Notesbogen har nogle standard hyperparametre, der er forudvalgt. Til fodgængerdetektion træner du modellen i 100 epoker. Dette træningstrin bør tage cirka 2 timer ved at bruge en ml.p2.xlarge instans. Du kan eksperimentere med forskellige kombinationer af hyperparametrene eller træne til flere epoker for forbedringer af ydeevnen. For information om de seneste priser, se Amazon SageMaker-priser.

16. Du kan starte et træningsjob med en enkelt kodelinje og overvåge nøjagtigheden over tid på SageMaker-konsollen:

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

For mere information om, hvordan træning fungerer, se Skab Træningsjob. Klargøringen og dataoverførslen tager tid, afhængigt af størrelsen af ​​dataene. Derfor kan der gå et par minutter, før du begynder at få datalogfiler til dine træningsjobs.

Du kan overvåge fremskridtene af dit træningsjob gennem den metriske middelgennemsnitspræcision (mAP), som giver dig mulighed for at overvåge kvaliteten af ​​modellens evne til at klassificere objekter og detektere de korrekte afgrænsningskasser. Dataloggene udskriver også mAP på valideringsdataene, blandt andre tab, for hver kørsel af datasættet, én gang for en epoke. Denne metrik er en proxy for kvaliteten af ​​algoritmens ydeevne ved nøjagtig detektering af klassen og den nøjagtige afgrænsningsramme omkring den.

Når jobbet er færdigt, kan du finde de trænede modelfiler i S3-spanden og -mappen specificeret tidligere s3_output_location:

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

Til dette indlæg viser vi resultater på valideringssættet ved afslutningen af ​​den 10. epoke og den 100. epoke. I slutningen af ​​den 10. epoke ser vi et valideringsmAP på cirka 0.027, hvorimod den 100. epoke var cirka 0.42.

For at opnå bedre detektionsresultater kan du prøve at justere hyperparametrene ved at bruge den indbyggede kapacitet i SageMaker til automatisk model tuning og træne modellen til flere epoker. Du stopper normalt med at træne, når du ser en aftagende stigning i nøjagtigheden.

Testmodel med tilpassede begrænsningszoner

Før du implementerer den trænede model til AWS DeepLens, kan du teste den i skyen ved at bruge et SageMaker-hostet slutpunkt. Et SageMaker-slutpunkt er en fuldt administreret tjeneste, der giver dig mulighed for at foretage realtidsslutninger via en REST API. SageMaker giver dig mulighed for hurtigt at implementere nye endepunkter for at teste dine modeller, så du ikke behøver at hoste modellen på den lokale instans, der blev brugt til at træne modellen. Dette giver dig mulighed for at lave forudsigelser (eller slutninger) fra modellen på billeder, som algoritmen ikke så under træning.

Du behøver ikke være vært på den samme instanstype, som du plejede at træne. Træning er et langvarigt og computertungt job, der kræver et andet sæt computer- og hukommelseskrav, som hosting typisk ikke gør. Du kan vælge en hvilken som helst type forekomst, du vil være vært for modellen. I dette tilfælde valgte vi ml.p3.2xlarge-instansen at træne, men vi vælger at hoste modellen på den billigere CPU-instans, ml.m4.xlarge. Følgende kodestykke viser vores slutpunktsimplementering.

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

Registrering i en tilpasset restriktionszone (interesseområde)

Formatet af output kan repræsenteres som [klasse_indeks, konfidens_score, xmin, ymin, xmax, ymax]. Forudsigelser med lav tillid har ofte større chancer for en falsk positiv eller falsk negativ, så du bør nok kassere forudsigelser med lav tillid. Du kan bruge følgende kode til at registrere, om personens afgrænsningsramme overlapper den begrænsede 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 

Som standard evalueres hele rammen for menneskelig tilstedeværelse. Du kan dog nemt angive det område af interesse, inden for hvilket tilstedeværelsen af ​​en person anses for at være højrisiko. Hvis du vil tilføje en brugerdefineret restriktionszone, skal du tilføje koordinater for hjørnerne af området repræsenteret af [X-akse,Y-akse] og oprette polygonen. Koordinaterne skal indtastes enten med eller mod uret. Se følgende kode:

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

Følgende eksempelkode viser fodgængere, der er identificeret inden for en spærret zone:

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 følgende billeder viser vores resultater.

Implementer løsningen til AWS DeepLens

Konverter modellen til implementering til AWS DeepLens

Når du implementerer en SageMaker-trænet SSD-model til AWS DeepLens, skal du først køre deploy.py for at konvertere modelartefakten til en deployerbar 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

Importer din model til AWS DeepLens

For at køre modellen på en AWS DeepLens-enhed skal du oprette et AWS DeepLens-projekt. Start med at importere din model til AWS DeepLens.

1. På AWS DeepLens-konsollen, under Ressourcer, vælg Modeller.
2. Vælg Import model.

3. Til Importer kilde, Vælg Eksternt trænet model.
4. Indtast Amazon S3-placeringen af lappet model som du gemte fra at køre deploy.py i trin ovenfor.
5. Til Modelramme, vælg MX Net.
6. Vælg Import model.

Opret inferensfunktionen

Inferensfunktionen fører hvert kamerabillede ind i modellen for at få forudsigelser og kører enhver tilpasset forretningslogik på at bruge slutningsresultaterne. Du bruger AWS Lambda for at oprette en funktion, som du implementerer til AWS DeepLens. Funktionen kører inferens lokalt på AWS DeepLens-enheden.

Først skal vi oprette en Lambda-funktion til at implementere til AWS DeepLens.

1. Download inferens Lambda funktion.
2. Vælg på Lambda-konsollen Funktioner.
3. Vælg Opret funktion.
4. Type Forfatter fra bunden.
5. Til Funktionsnavn, indtast et navn.
6. Til Runtime, vælg Python 3.7.
7. Til Vælg eller opret en eksekveringsrolle, vælg Brug en eksisterende rolle.
8. Vælg service-rolle/AWSDeepLensLambdaRole.
9. Vælg Opret funktion.

10. På funktionens detaljeside, på handlinger menu, vælg Upload en .zip-fil.

11. Upload slutning Lambda fil, du downloadede tidligere.
12. Vælg Gem for at gemme den indtastede kode.
13. På handlinger menu, vælg Udgiv ny version.

Udgivelse af funktionen gør den tilgængelig på AWS DeepLens-konsollen, så du kan tilføje den til dit brugerdefinerede projekt.

14. Indtast et versionsnummer og vælg Udgiv.

Forståelse af inferensfunktionen

Dette afsnit leder dig gennem nogle vigtige dele af inferensfunktionen. Først skal du være opmærksom på to specifikke filer:

• labels.txt – Indeholder en kortlægning af outputtet fra det neurale netværk (heltal) til menneskelig læsbare etiketter (streng)
• lambda_function.py – Indeholder kode til den funktion, der kaldes til at generere forudsigelser på hvert kamerabillede og sende resultater tilbage

I lambda_function.py indlæser og optimerer du først modellen. Sammenlignet med virtuelle cloud-maskiner med en GPU, har AWS DeepLens mindre computerkraft. AWS DeepLens bruger Intel OpenVino model optimizer til at optimere den model, der er trænet i SageMaker, til at køre på sin hardware. Følgende kode optimerer din model til at køre lokalt:

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

Derefter kører du modellen frame-per-frame over billederne fra kameraet. Se følgende kode:

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

Til sidst sender du tekstforudsigelsesresultaterne tilbage til skyen. At se tekstresultaterne i skyen er en praktisk måde at sikre sig, at modellen fungerer korrekt. Hver AWS DeepLens-enhed har et dedikeret iot_topic, der automatisk oprettes for at modtage slutningsresultaterne. Se følgende kode:

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

Opret et tilpasset AWS DeepLens-projekt

For at oprette et nyt AWS DeepLens-projekt skal du udføre følgende trin:

1. På AWS DeepLens-konsollen, på Projekter side, vælg Opret projekt.
2. Til Projekttype, Vælg Opret et nyt tomt projekt.
3. Vælg Næste.

4. Navngiv dit projekt yourname-pedestrian-detector-.
5. Vælg Tilføj model.
6. Vælg den model, du lige har oprettet.
7. Vælg Tilføj funktion.
8. Søg efter den Lambda-funktion, du oprettede tidligere ved navn.
9. Vælg Opret projekt.
10. På Projekter side, skal du vælge det projekt, du vil implementere.
11. valgte Implementer til enhed.
12. Til Målenhed, vælg din enhed.
13. Vælg anmeldelse.
14. Gennemgå dine indstillinger og vælg Implementer.

Implementeringen kan tage op til 10 minutter at fuldføre, afhængigt af hastigheden på det netværk, din AWS DeepLens er forbundet til. Når implementeringen er færdig, bør du se et grønt banner på siden med beskeden "Tillykke, din model kører nu lokalt på AWS DeepLens!"

For at se tekstoutput skal du rulle ned på siden med enhedsdetaljer til Projekt output afsnit. Følg instruktionerne i afsnittet for at kopiere emnet og gå til AWS IoT Core konsol for at abonnere på emnet. Du bør se resultater som i det følgende skærmbillede.

For trin-for-trin instruktioner om visning af videostream eller tekstoutput, se Se resultater fra AWS DeepLens.

Reelle brugssager

Nu hvor du har forudsigelser fra din model kørende på AWS DeepLens, lad os konvertere disse forudsigelser til advarsler og indsigt. Nogle mest almindelige anvendelser for et projekt som dette inkluderer:

• At forstå, hvor mange mennesker på en given dag, der gik ind i en spærrezone, så byggepladser kan identificere steder, der kræver flere sikkerhedsskilte. Dette kan gøres ved at samle resultaterne og bruge dem til at oprette et dashboard vha Amazon QuickSight. For flere detaljer om oprettelse af et dashboard ved hjælp af QuickSight, se Byg en posture-tracker til at arbejde hjemmefra med AWS DeepLens og GluonCV.
• Indsamler output fra AWS DeepLens og konfigurerer en Raspberry Pi til at afgive en alarm, når nogen går ind i en begrænset zone. For flere detaljer om tilslutning af en AWS DeepLens-enhed til en Raspberry Pi-enhed, se Opbygning af en affaldssortering med AWS DeepLens.

Konklusion

I dette indlæg lærte du, hvordan du træner en objektdetekteringsmodel og implementerer den til AWS DeepLens for at detektere personer, der kommer ind i begrænsede zoner. Du kan bruge dette selvstudie som en reference til at træne og implementere dine egne brugerdefinerede objektdetekteringsprojekter på AWS DeepLens.

For en mere detaljeret gennemgang af dette selvstudie og andre selvstudier, eksempler og projektideer med AWS DeepLens, se AWS DeepLens opskrifter.

Om forfatterne

Yash Shah er dataforsker i Amazon ML Solutions Lab, hvor han arbejder på en række af maskinlæringsbrugssager fra sundhedspleje til fremstilling og detailhandel. Han har en formel baggrund i menneskelige faktorer og statistik og var tidligere en del af Amazon SCOT-teamet, der designer produkter til at guide 3P-sælgere med effektiv lagerstyring.

Phu Nguyen er produktchef for AWS Panorama. Han bygger produkter, der giver udviklere på ethvert færdighedsniveau en nem, praktisk introduktion til maskinlæring.

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