Beskytte mennesker fra farlige områder gjennom virtuelle grenser med Computer Vision

Ettersom selskaper ønsker mer autonome roboter og annet tungt utstyr velkommen på arbeidsplassen, må vi sikre at utstyr kan operere trygt rundt menneskelige lagkamerater. I dette innlegget vil vi vise deg hvordan du bygger en virtuell grense med datasyn og AWS DeepLens, AWS dyplæringsaktivert videokamera designet for utviklere å lære maskinlæring (ML). Ved å bruke maskinlæringsteknikkene i dette innlegget kan du bygge virtuelle grenser for begrensede områder som automatisk slår av utstyr eller varsler når mennesker kommer i nærheten.

For dette prosjektet vil du trene en tilpasset objektdeteksjonsmodell med Amazon SageMaker og distribuer modellen til en AWS DeepLens-enhet. Objektdeteksjon er en ML-algoritme som tar et bilde som input og identifiserer objekter og deres plassering i bildet. I tillegg til virtuelle grenseløsninger kan du bruke teknikker du har lært i dette innlegget når du trenger å oppdage hvor visse objekter er inne i et bilde eller telle antall forekomster av et ønsket objekt i et bilde, for eksempel å telle gjenstander i en lagringskasse eller på en butikkhylle.

Løsningsoversikt

Gjennomgangen inkluderer følgende trinn:

1. Forbered datasettet ditt til å mate inn i en ML-algoritme.
2. Tren en modell med Amazon SageMaker.
3. Testmodell med tilpassede restriksjonssoner.
4. Distribuer løsningen til AWS DeepLens.

Vi diskuterer også andre virkelige brukstilfeller der du kan bruke denne løsningen.

Følgende diagram illustrerer løsningsarkitekturen.

Forutsetninger

For å fullføre dette gjennomgangen må du ha følgende forutsetninger:

Forbered datasettet ditt til å mate inn i en ML-algoritme

Dette innlegget bruker en ML-algoritme kalt en objektdeteksjonsmodell for å bygge en løsning som oppdager om en person er i en tilpasset begrenset sone. Du bruker det offentlig tilgjengelige Fotgjengerdeteksjon datasett tilgjengelig på Kaggle, som har over 2,000 bilder. Dette datasettet har etiketter for menneskelignende og menneskelignende objekter (som mannekenger) slik at den trente modellen kan skille mer nøyaktig mellom ekte mennesker og papprekvisitter eller statuer.

Følgende bilder er for eksempel eksempler på at en bygningsarbeider blir oppdaget og om de befinner seg i den tilpassede restriksjonssonen (rød kontur).

For å begynne å trene modellen din, lag først en S3-bøtte for å lagre treningsdata og modellutdata. For AWS DeepLens-prosjekter må S3-bøttenavnene starte med prefikset deeplens-. Du bruker disse dataene til å trene en modell med SageMaker, en fullstendig administrert tjeneste som gir muligheten til å bygge, trene og distribuere ML-modeller raskt.

Tren en modell med Amazon SageMaker

Du bruker SageMaker Jupyter notatbøker som utviklingsmiljø for å trene modellen. Jupyter Notebook er en åpen kildekode-nettapplikasjon som lar deg lage og dele dokumenter som inneholder levende kode, ligninger, visualiseringer og fortellende tekst. For dette innlegget gir vi Train_Object_Detection_People_DeepLens.ipynb, en fullstendig notatbok du kan følge med på.

For å lage en egendefinert objektdeteksjonsmodell må du bruke en grafisk prosesseringsenhet (GPU)-aktivert treningsjobbforekomst. GPUer er utmerket til å parallellisere beregninger som kreves for å trene et nevralt nettverk. Selv om selve bærbare PC-en er en enkelt ml.t2.medium-forekomst, bruker treningsjobben spesifikt en ml.p2.xlarge-forekomst. For å få tilgang til en GPU-aktivert treningsjobbforekomst må du sende inn en forespørsel om økning i tjenestegrensen til AWS Support Center.

Etter at du har mottatt grenseøkningen, fullfører du følgende trinn for å opprette en SageMaker-notebook-forekomst:

1. Velg på SageMaker-konsollen Notatboksforekomster.
2. Velg Opprett notatbokforekomst.
3. Til Navn på notatbokforekomst, skriv inn et navn for notatbokforekomsten.
4. Til Forekomsttype, velg t2.middels.

Dette er den billigste forekomsttypen som bærbare forekomster støtter, og det er nok for denne opplæringen.

5. Til IAM-rolle, velg Lag en ny rolle.

Forsikre deg om at dette AWS identitets- og tilgangsadministrasjon (IAM)-rollen har tilgang til S3-bøtten du opprettet tidligere (prefiks deeplens-).

6. Velg Opprett notatbokforekomst. Forekomsten av den bærbare datamaskinen kan ta et par minutter å starte opp.

7. Når statusen på siden for notatblokkforekomster endres til InService, velger du Åpne Jupyter for å starte den nyopprettede Jupyter-notatbokforekomsten.
8. Velg Last opp å laste opp Train_Object_Detection_people_DeepLens.ipynb fil du lastet ned tidligere.

9. Åpne notatboken og følg den til slutten.
10. Hvis du blir spurt om innstilling av kjernen, velg conda_mxnet_p36.

Jupyter-notisboken inneholder en blanding av tekst- og kodeceller. For å kjøre et kodestykke, velg cellen og trykk Shift + Enter. Mens cellen kjører, vises en stjerne ved siden av cellen. Når cellen er fullført, vises et utgangsnummer og en ny utdatacelle under den opprinnelige cellen.

11. Last ned datasettet fra den offentlige S3-bøtten til den lokale SageMaker-forekomsten og pakk ut dataene. Dette kan gjøres ved å følge koden i notatboken:

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

12. Konverter datasettet til et format (RecordIO) som kan mates inn 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-filene tilbake til Amazon S3.

Nå som du er ferdig med alle dataforberedelsene, er du klar til å trene objektdetektoren.

Det finnes mange forskjellige typer objektdeteksjonsalgoritmer. For dette innlegget bruker du Single-Shot MultiBox Detection Algoritme (SSD). SSD-algoritmen har en god balanse mellom hastighet og nøyaktighet, noe som gjør den ideell for å kjøre på avanserte enheter som AWS DeepLens.

Som en del av treningsjobben har du mange alternativer for hyperparametere som hjelper deg med å konfigurere treningsatferden (som antall epoker, læringshastighet, optimeringstype og minibatchstørrelse). Hyperparametere lar deg justere treningshastigheten og nøyaktigheten til modellen din. For mer informasjon om hyperparametre, se Objektdeteksjonsalgoritme.

15. Sett opp hyperparametre og datakanaler. Vurder å bruke følgende eksempeldefinisjon av 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) 

Notatboken har noen standard hyperparametere som er forhåndsvalgt. For fotgjengerdeteksjon trener du modellen i 100 epoker. Dette treningstrinnet bør ta ca. 2 timer ved å bruke en ml.p2.xlarge forekomst. Du kan eksperimentere med forskjellige kombinasjoner av hyperparametrene, eller trene for flere epoker for ytelsesforbedringer. For informasjon om de nyeste prisene, se Amazon SageMaker-priser.

16. Du kan starte en treningsjobb med én enkelt kodelinje og overvåke nøyaktigheten over tid på SageMaker-konsollen:

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

For mer informasjon om hvordan trening fungerer, se Opprett treningsjobb. Klargjøringen og datanedlastingen tar tid, avhengig av størrelsen på dataene. Derfor kan det ta noen minutter før du begynner å få datalogger for treningsjobbene dine.

Du kan overvåke fremdriften til treningsjobben din gjennom den metriske gjennomsnittlige presisjonen (mAP), som lar deg overvåke kvaliteten på modellens evne til å klassifisere objekter og oppdage de riktige avgrensningsboksene. Dataloggene skriver også ut mAP på valideringsdataene, blant annet tap, for hver kjøring av datasettet, én gang for én epoke. Denne beregningen er en proxy for kvaliteten på algoritmens ytelse ved nøyaktig å detektere klassen og den nøyaktige avgrensningsrammen rundt den.

Når jobben er ferdig, kan du finne de trente modellfilene i S3-bøtten og mappen som er spesifisert tidligere s3_output_location:

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

For dette innlegget viser vi resultater på valideringssettet ved fullføringen av den 10. epoken og den 100. epoken. På slutten av den 10. epoken ser vi en valideringsmAP på ca. 0.027, mens den 100. epoken var ca. 0.42.

For å oppnå bedre deteksjonsresultater kan du prøve å justere hyperparametrene ved å bruke funksjonen innebygd i SageMaker for automatisk modellinnstilling og trene modellen for flere epoker. Du slutter vanligvis å trene når du ser en avtagende økning i nøyaktigheten.

Testmodell med tilpassede restriksjonssoner

Før du distribuerer den trente modellen til AWS DeepLens, kan du teste den i skyen ved å bruke et SageMaker-vertsbasert endepunkt. Et SageMaker-endepunkt er en fullstendig administrert tjeneste som lar deg gjøre sanntidsslutninger via en REST API. SageMaker lar deg raskt distribuere nye endepunkter for å teste modellene dine, slik at du ikke trenger å være vert for modellen på den lokale forekomsten som ble brukt til å trene modellen. Dette lar deg lage spådommer (eller slutninger) fra modellen på bilder som algoritmen ikke så under trening.

Du trenger ikke være vert for samme instanstype som du pleide å trene. Trening er en langvarig og datatung jobb som krever et annet sett med data- og minnekrav som hosting vanligvis ikke gjør. Du kan velge hvilken som helst type forekomst du vil være vert for modellen. I dette tilfellet valgte vi ml.p3.2xlarge-forekomsten å trene, men vi velger å hoste modellen på den rimeligere CPU-forekomsten, ml.m4.xlarge. Følgende kodebit viser endepunktsimplementeringen vår.

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

Deteksjon i en egendefinert restriksjonssone (interesseområde)

Formatet til utdataene kan representeres som [klasse_indeks, konfidens_score, xmin, ymin, xmax, ymax]. Spådommer med lav selvtillit har ofte høyere sjanser for en falsk positiv eller falsk negativ, så du bør sannsynligvis forkaste spådommer med lav konfidens. Du kan bruke følgende kode for å oppdage om avgrensningsboksen til personen overlapper den begrensede sonen.

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 blir hele rammen evaluert for menneskelig tilstedeværelse. Du kan imidlertid enkelt spesifisere interesseområdet der tilstedeværelsen av en person anses som høyrisiko. Hvis du vil legge til en egendefinert restriksjonssone, legger du til koordinatene til toppunktene i området representert av [X-akse,Y-akse] og lag polygonet. Koordinatene må legges inn enten med eller mot klokken. 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 fotgjengere som er identifisert innenfor en restriksjonssone:

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

Følgende bilder viser resultatene våre.

Distribuer løsningen til AWS DeepLens

Konverter modellen for distribusjon til AWS DeepLens

Når du distribuerer en SageMaker-trent SSD-modell til AWS DeepLens, må du først løpe deploy.py for å konvertere modellartefakten til en distribuerbar 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

Importer modellen din til AWS DeepLens

For å kjøre modellen på en AWS DeepLens-enhet, må du opprette et AWS DeepLens-prosjekt. Start med å importere modellen din til AWS DeepLens.

1. På AWS DeepLens-konsollen, under Ressurser, velg Modeller.
2. Velg Importer modell.

3. Til Importer kilde, plukke ut Eksternt trent modell.
4. Skriv inn Amazon S3-plasseringen til lappet modell som du lagret fra å kjøre deploy.py i trinnet ovenfor.
5. Til Modellramme, velg MX Nett.
6. Velg Importer modell.

Lag inferensfunksjonen

Inferensfunksjonen mater hver kameraramme inn i modellen for å få spådommer og kjører enhver tilpasset forretningslogikk på bruk av slutningsresultatene. Du bruker AWS Lambda for å lage en funksjon som du distribuerer til AWS DeepLens. Funksjonen kjører inferens lokalt på AWS DeepLens-enheten.

Først må vi lage en Lambda-funksjon for å distribuere til AWS DeepLens.

1. Last ned inferens Lambda-funksjon.
2. Velg Lambda-konsollen Funksjoner.
3. Velg Opprett funksjon.
4. Plukke ut Forfatter fra bunnen av.
5. Til Funksjonsnavn, skriv inn et navn.
6. Til Runtime, velg Python 3.7.
7. Til Velg eller opprett en utførelsesrolle, velg Bruk en eksisterende rolle.
8. Velg tjeneste-rolle / AWSDeepLensLambdaRole.
9. Velg Opprett funksjon.

10. På funksjonens detaljside, på handlinger meny, velg Last opp en .zip-fil.

11. Last opp slutning Lambda fil du lastet ned tidligere.
12. Velg Spar for å lagre koden du skrev inn.
13. På handlinger meny, velg Publiser ny versjon.

Å publisere funksjonen gjør den tilgjengelig på AWS DeepLens-konsollen slik at du kan legge den til i ditt tilpassede prosjekt.

14. Skriv inn et versjonsnummer og velg Publiser.

Forstå inferensfunksjonen

Denne delen leder deg gjennom noen viktige deler av slutningsfunksjonen. Først bør du ta hensyn til to spesifikke filer:

• labels.txt – Inneholder en kartlegging av utdata fra det nevrale nettverket (heltall) til lesbare etiketter (streng)
• lambda_function.py – Inneholder kode for funksjonen som kalles for å generere spådommer på hver kameraramme og sende tilbake resultater

I lambda_function.py laster og optimaliserer du først modellen. Sammenlignet med virtuelle skymaskiner med en GPU, har AWS DeepLens mindre datakraft. AWS DeepLens bruker Intel OpenVino-modelloptimereren for å optimalisere modellen som er trent i SageMaker til å kjøre på maskinvaren. Følgende kode optimaliserer modellen din for å kjø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}) 

Deretter kjører du modellen frame-per-frame over bildene 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 slutt sender du tekstprediksjonsresultatene tilbake til skyen. Å se tekstresultatene i skyen er en praktisk måte å sikre at modellen fungerer som den skal. Hver AWS DeepLens-enhet har et dedikert iot_topic opprettet automatisk for å motta slutningsresultatene. Se følgende kode:

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

Lag et tilpasset AWS DeepLens-prosjekt

For å opprette et nytt AWS DeepLens-prosjekt, fullfør følgende trinn:

1. På AWS DeepLens-konsollen, på Prosjekter side, velg Opprett prosjekt.
2. Til Prosjekt type, plukke ut Opprett et nytt tomt prosjekt.
3. Velg neste.

4. Gi navn på prosjektet ditt yourname-pedestrian-detector-.
5. Velg Legg til modell.
6. Velg modellen du nettopp har laget.
7. Velg Legg til funksjon.
8. Søk etter Lambda-funksjonen du opprettet tidligere ved navn.
9. Velg Opprett prosjekt.
10. På Prosjekter siden, velg prosjektet du vil distribuere.
11. Velg Distribuer til enheten.
12. Til Målenhet, velg enheten din.
13. Velg Anmeldelse.
14. Gå gjennom innstillingene og velg Distribuer.

Implementeringen kan ta opptil 10 minutter å fullføre, avhengig av hastigheten på nettverket AWS DeepLens er koblet til. Når distribusjonen er fullført, skal du se et grønt banner på siden med meldingen "Gratulerer, modellen din kjører nå lokalt på AWS DeepLens!"

For å se tekstutdata, bla nedover på enhetsdetaljer-siden til Prosjektutgang seksjon. Følg instruksjonene i delen for å kopiere emnet og gå til AWS IoT-kjerne konsoll for å abonnere på emnet. Du bør se resultater som i følgende skjermbilde.

For trinnvise instruksjoner om visning av videostrømmen eller tekstutdata, se Viser resultater fra AWS DeepLens.

Virkelige brukssaker

Nå som du har spådommer fra modellen din som kjører på AWS DeepLens, la oss konvertere disse spådommene til varsler og innsikt. Noen vanligste bruksområder for et prosjekt som dette inkluderer:

• Forstå hvor mange mennesker på en gitt dag som gikk inn i en restriksjonssone, slik at byggeplasser kan identifisere steder som krever flere sikkerhetsskilt. Dette kan gjøres ved å samle resultatene og bruke dem til å lage et dashbord ved hjelp av Amazon QuickSight. For mer informasjon om hvordan du oppretter et dashbord med QuickSight, se Bygg en jobb-hjemmefra posture tracker med AWS DeepLens og GluonCV.
• Samler inn utdata fra AWS DeepLens og konfigurerer en Raspberry Pi for å gi et varsel når noen går inn i en begrenset sone. For mer informasjon om å koble en AWS DeepLens-enhet til en Raspberry Pi-enhet, se Bygge en søppel sorter med AWS DeepLens.

konklusjonen

I dette innlegget lærte du hvordan du trener en objektdeteksjonsmodell og distribuerer den til AWS DeepLens for å oppdage folk som går inn i begrensede soner. Du kan bruke denne opplæringen som en referanse for å trene og distribuere dine egne tilpassede objektdeteksjonsprosjekter på AWS DeepLens.

For en mer detaljert gjennomgang av denne veiledningen og andre opplæringsprogrammer, eksempler og prosjektideer med AWS DeepLens, se AWS DeepLens-oppskrifter.

Om forfatterne

Yash Shah er datavitenskapsmann i Amazon ML Solutions Lab, hvor han arbeider med en rekke brukstilfeller for maskinlæring fra helsetjenester til produksjon og detaljhandel. Han har en formell bakgrunn innen menneskelige faktorer og statistikk, og var tidligere en del av Amazon SCOT-teamet som designet produkter for å veilede 3P-selgere med effektiv lagerstyring.

Phu Nguyen er produktsjef for AWS Panorama. Han bygger produkter som gir utviklere på alle ferdighetsnivåer en enkel, praktisk introduksjon til maskinlæring.

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