Skydda människor från farliga områden genom virtuella gränser med Computer Vision

Eftersom företag välkomnar mer autonoma robotar och annan tung utrustning till arbetsplatsen måste vi se till att utrustningen kan fungera säkert runt mänskliga lagkamrater. I det här inlägget visar vi dig hur du bygger en virtuell gräns med datorvision och AWS DeepLens, den AWS djupinlärningsaktiverade videokameran designad för utvecklare att lära sig maskininlärning (ML). Med hjälp av maskininlärningsteknikerna i det här inlägget kan du bygga virtuella gränser för begränsade områden som automatiskt stänger av utrustning eller låter en varning när människor kommer nära.

För detta projekt kommer du att träna en anpassad objektdetekteringsmodell med Amazon SageMaker och distribuera modellen till en AWS DeepLens-enhet. Objektdetektering är en ML-algoritm som tar en bild som inmatning och identifierar objekt och deras placering i bilden. Förutom virtuella gränslösningar kan du tillämpa tekniker som lärt sig i det här inlägget när du behöver upptäcka var vissa objekt finns i en bild eller räkna antalet instanser av ett önskat objekt i en bild, till exempel att räkna objekt i ett förvaringsfack på en detaljhandelshylla.

Lösningsöversikt

Genomgång innehåller följande steg:

1. Förbered din dataset för att matas in i en ML-algoritm.
2. Träna en modell med Amazon SageMaker.
3. Testmodell med anpassade begränsningszoner.
4. Distribuera lösningen till AWS DeepLens.

Vi diskuterar också andra praktiska användningsfall där du kan använda denna lösning.

Följande diagram illustrerar lösningsarkitekturen.

Förutsättningar

För att genomföra detta genomgång måste du ha följande förutsättningar:

Förbered din dataset att mata in i en ML-algoritm

Det här inlägget använder en ML-algoritm som kallas en objektdetekteringsmodell för att bygga en lösning som upptäcker om en person befinner sig i en anpassad begränsad zon. Du använder det allmänt tillgängliga Gånguppsättning för fotgängare tillgänglig på Kaggle, som har över 2,000 bilder. Denna dataset har etiketter för mänskliga och mänskliga objekt (som skyltdockor) så att den utbildade modellen mer exakt kan skilja mellan riktiga människor och kartongrekvisita eller statyer.

Följande bilder är till exempel exempel på att en byggnadsarbetare upptäcks och om de befinner sig i den anpassade begränsningszonen (röd kontur).

För att börja träna din modell, skapa först en S3-hink för att lagra dina träningsdata och modellutdata. För AWS DeepLens-projekt måste S3-skopnamnen börja med prefixet deeplens-. Du använder dessa data för att träna en modell med SageMaker, en helt hanterad tjänst som ger möjlighet att snabbt bygga, träna och distribuera ML-modeller.

Träna en modell med Amazon SageMaker

Du använder SageMaker Jupyter-bärbara datorer som utvecklingsmiljö för att träna modellen. Jupyter Notebook är en öppen källkodsapplikation som låter dig skapa och dela dokument som innehåller live-kod, ekvationer, visualiseringar och berättande text. För det här inlägget tillhandahåller vi Train_Object_Detection_People_DeepLens.ipynb, en fullständig anteckningsbok som du kan följa med.

För att skapa en anpassad objektdetekteringsmodell måste du använda en träningsjobbinstans som är grafisk bearbetad (GPU). GPU: er är utmärkta för att parallellisera beräkningar som krävs för att träna ett neuralt nätverk. Även om den bärbara datorn i sig är en enda ml.t2.mediuminstans, använder träningsjobbet specifikt en ml.p2.xlarge instans. För att komma åt en GPU-aktiverad träningsjobbinstans måste du skicka en begäran om höjning av servicegränser till AWS supportcenter.

När du har fått din maximihöjning, gör följande steg för att skapa en SageMaker-anteckningsbokinstans:

1. Välj på SageMaker-konsolen Notebook-instanser.
2. Välja Skapa anteckningsbokinstans.
3. För Anteckningsbokens förekomstnamn, ange ett namn för din anteckningsbokinstans.
4. För Instans typväljer t2.medium.

Det här är den billigaste instansstypen som bärbara instanser stödjer, och det räcker för den här självstudien.

5. För IAM-rollväljer Skapa en ny roll.

Se till att detta AWS identitets- och åtkomsthantering (IAM) -roll har åtkomst till S3-skopan du skapade tidigare (prefix deeplens-).

6. Välja Skapa anteckningsbokinstans. Det kan ta några minuter innan din notebook-dator startas.

7. När statusen på sidan för notebook-instanser ändras till InService väljer du Öppna Jupyter för att starta din nyskapade Jupyter-anteckningsbokinstans.
8. Välja Ladda att ladda upp Train_Object_Detection_people_DeepLens.ipynb fil du laddat ner tidigare.

9. Öppna anteckningsboken och följ den till slutet.
10. Om du blir ombedd att ställa in kärnan väljer du conda_mxnet_p36.

Jupyter-anteckningsboken innehåller en blandning av text- och kodceller. För att köra en kod, välj cellen och tryck Skift + Enter. Medan cellen körs visas en asterisk bredvid cellen. När cellen är klar visas ett utdatanummer och en ny utdatacell under den ursprungliga cellen.

11. Ladda ner datamängden från den offentliga S3-skopan till den lokala SageMaker-instansen och packa upp data. Detta kan göras genom att följa koden i anteckningsboken:

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

12. Konvertera dataset till ett format (RecordIO) som kan matas in 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. Överför RecordIO-filerna tillbaka till Amazon S3.

Nu när du är klar med all dataförberedelse är du redo att träna objektdetektorn.

Det finns många olika typer av objektdetekteringsalgoritmer. För det här inlägget använder du Single-Shot MultiBox Detection algoritm (SSD). SSD-algoritmen har en bra balans mellan hastighet och noggrannhet, vilket gör den idealisk för körning på edge-enheter som AWS DeepLens.

Som en del av träningsjobbet har du många alternativ för hyperparametrar som hjälper till att konfigurera träningsbeteendet (till exempel antal epoker, inlärningshastighet, optimeringstyp och minibatchstorlek). Hyperparametrar låter dig ställa in träningshastighet och noggrannhet för din modell. För mer information om hyperparametrar, se Objektdetekteringsalgoritm.

15. Ställ in dina hyperparametrar och datakanaler. Överväg att använda följande exempeldefinition av hyperparametrar:

     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) 

Anteckningsboken har några förvalda hyperparametrar som har valts i förväg. För att upptäcka fotgängare tränar du modellen i 100 epoker. Detta utbildningssteg bör ta cirka 2 timmar med en ml.p2.xlarge instans. Du kan experimentera med olika kombinationer av hyperparametrarna eller träna för fler epoker för prestandaförbättringar. För information om den senaste prissättningen, se Amazon SageMaker Prissättning.

16. Du kan starta ett träningsjobb med en enda kodrad och övervaka noggrannheten över tid på SageMaker-konsolen:

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

För mer information om hur träning fungerar, se Skapa utbildningsjobb. Tillhandahållande och nedladdning av data tar tid, beroende på storleken på datan. Det kan därför ta några minuter innan du börjar få dataloggar för dina träningsjobb.

Du kan övervaka utvecklingen av ditt träningsjobb genom den metriska medelprecisionen (mAP), vilket gör att du kan övervaka kvaliteten på modellens förmåga att klassificera objekt och upptäcka rätt avgränsningsrutor. Dataloggarna skriver också ut kartan på valideringsdata, bland andra förluster, för varje körning av datasetet, en gång under en period. Detta mått är en proxy för kvaliteten på algoritmens prestanda för att exakt detektera klassen och den exakta avgränsningsrutan runt den.

När jobbet är klart kan du hitta de utbildade modellfilerna i S3-hinken och mappen som specificerades tidigare i s3_output_location:

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

För det här inlägget visar vi resultat på valideringsuppsättningen vid avslutandet av den 10: e och den 100: e tiden. I slutet av den 10: e epoken ser vi en valideringsmapp på cirka 0.027, medan den 100: e epoken var cirka 0.42.

För att uppnå bättre detekteringsresultat kan du försöka ställa in hyperparametrarna med hjälp av den inbyggda kapaciteten i SageMaker för automatisk modelljustering och träna modellen för fler epoker. Du slutar vanligtvis träna när du ser en minskande vinst i noggrannhet.

Testmodell med anpassade begränsningszoner

Innan du distribuerar den utbildade modellen till AWS DeepLens kan du testa den i molnet med hjälp av en SageMaker värd slutpunkt. En SageMaker-slutpunkt är en fullständigt hanterad tjänst som låter dig göra slutsatser i realtid via ett REST API. SageMaker låter dig snabbt distribuera nya slutpunkter för att testa dina modeller så att du inte behöver vara värd för modellen i den lokala instansen som användes för att träna modellen. Detta låter dig göra förutsägelser (eller slutsatser) från modellen på bilder som algoritmen inte såg under träningen.

Du behöver inte vara värd för samma instansstyp som du brukade träna. Träning är ett långvarigt och tungt jobb som kräver en annan uppsättning beräknings- och minneskrav som hosting vanligtvis inte gör. Du kan välja vilken typ av instans du vill vara värd för modellen. I det här fallet valde vi instansen ml.p3.2xlarge för att träna, men vi väljer att vara värd för modellen på den billigare CPU-instansen, ml.m4.xlarge. Följande kodavsnitt visar vår slutpunktsdistribution.

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

Detektering i en anpassad begränsningszon (intressant region)

Utdataformatet kan representeras som [class_index, confidence_score, xmin, ymin, xmax, ymax]. Förutsägelser med lågt förtroende har ofta högre chanser för falskt positivt eller falskt negativt, så du bör förmodligen kasta bort lågförtroende. Du kan använda följande kod för att upptäcka om personens avgränsningsruta överlappar den begränsade zonen.

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 utvärderas hela ramen för mänsklig närvaro. Du kan dock enkelt ange det intresseområde inom vilket en persons närvaro anses vara hög risk. Om du vill lägga till en anpassad begränsningszon lägger du till koordinater för regionens toppar som representeras av [X-axel, Y-axel] och skapar polygonen. Koordinaterna måste anges antingen medurs eller moturs. Se följande kod:

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

Följande exempelkod visar fotgängare som identifieras inom en begränsad zon:

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öljande bilder visar våra resultat.

Distribuera lösningen till AWS DeepLens

Konvertera modellen för distribution till AWS DeepLens

När du distribuerar en SageMaker-utbildad SSD-modell till AWS DeepLens måste du först köra deploy.py för att konvertera modellartefakten till 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

Importera din modell till AWS DeepLens

För att köra modellen på en AWS DeepLens-enhet måste du skapa ett AWS DeepLens-projekt. Börja med att importera din modell till AWS DeepLens.

1. På AWS DeepLens-konsolen, under Resurserväljer Modeller.
2. Välja Importera modell.

3. För Importera källa, Välj Externt tränad modell.
4. Ange Amazon S3-platsen för lappad modell som du sparat från att köra deploy.py i steget ovan.
5. För Modellramväljer MX Net.
6. Välja Importera modell.

Skapa inferensfunktionen

Slutsatsfunktionen matar in varje kameraram i modellen för att få förutsägelser och kör alla anpassade affärslogiker med hjälp av slutsatsresultaten. Du använder AWS Lambda för att skapa en funktion som du distribuerar till AWS DeepLens. Funktionen kör slutledning lokalt på AWS DeepLens-enheten.

Först måste vi skapa en Lambda-funktion att distribuera till AWS DeepLens.

1. ladda ner inferens Lambda-funktion.
2. Välj på Lambda-konsolen Funktioner.
3. Välja Skapa funktion.
4. Välja Författare från början.
5. För Funktionsnamn, ange ett namn.
6. För Runtimeväljer python 3.7.
7. För Välj eller skapa en körningsrollväljer Använd en befintlig roll.
8. Välja service roll / AWSDeepLensLambdaRole.
9. Välja Skapa funktion.

10. På funktionens detaljsida, på Handlingar meny, välj Ladda upp en .zip-fil.

11. Ladda upp inferens Lambda fil du laddat ner tidigare.
12. Välja Save för att spara koden du angav.
13. På Handlingar meny, välj Publicera ny version.

Genom att publicera funktionen blir den tillgänglig på AWS DeepLens-konsolen så att du kan lägga till den i ditt anpassade projekt.

14. Ange ett versionnummer och välj Publicera.

Förstå inferensfunktionen

Detta avsnitt går igenom några viktiga delar av inferensfunktionen. Först bör du vara uppmärksam på två specifika filer:

• labels.txt - Innehåller en kartläggning av utdata från neurala nätverk (heltal) till mänskliga läsbara etiketter (sträng)
• lambda_function.py - Innehåller kod för den funktion som anropas för att generera förutsägelser på varje kameraram och skicka tillbaka resultat

I lambda_function.py laddar du först och optimerar modellen. Jämfört med virtuella molnmaskiner med en GPU har AWS DeepLens mindre datorkraft. AWS DeepLens använder Intel OpenVino-modelloptimeraren för att optimera modellen som är utbildad i SageMaker för att köra på sin hårdvara. Följande kod optimerar din modell för att köras 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}) 

Sedan kör du modellen ram-per-ram över bilderna från kameran. Se följande kod:

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

Slutligen skickar du textförutsägelseresultaten tillbaka till molnet. Att visa textresultaten i molnet är ett bekvämt sätt att se till att modellen fungerar korrekt. Varje AWS DeepLens-enhet har en dedikerad iot_topic som automatiskt skapas för att få slutresultaten. Se följande kod:

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

Skapa ett anpassat AWS DeepLens-projekt

Gör följande för att skapa ett nytt AWS DeepLens-projekt:

1. På AWS DeepLens-konsolen, på Projekt sida, välj Skapa projekt.
2. För Projekttyp, Välj Skapa ett nytt tomt projekt.
3. Välja Nästa.

4. Namn ditt projekt yourname-pedestrian-detector-.
5. Välja Lägg till modell.
6. Välj den modell du just skapat.
7. Välja Lägg till funktion.
8. Sök efter Lambda-funktionen som du skapade tidigare med namn.
9. Välja Skapa projekt.
10. På Projekt välj det projekt du vill distribuera.
11. Välj Distribuera till enheten.
12. För Målenhet, välj din enhet.
13. Välja översyn.
14. Granska dina inställningar och välj Distribuera.

Driftsättningen kan ta upp till tio minuter att slutföra, beroende på hastigheten på nätverket som din AWS DeepLens är ansluten till. När distributionen är klar bör du se en grön banner på sidan med meddelandet "Grattis, din modell körs nu lokalt på AWS DeepLens!"

Om du vill se textutmatningen bläddrar du ned på enhetsinformationssidan till Projektproduktion sektion. Följ instruktionerna i avsnittet för att kopiera ämnet och gå till AWS IoT Core konsol för att prenumerera på ämnet. Du bör se resultat som i följande skärmdump.

För steg-för-steg-instruktioner om hur du visar videoströmmen eller textutmatningen, se Visar resultat från AWS DeepLens.

Verkliga användningsfall

Nu när du har förutsägelser från din modell som körs på AWS DeepLens, låt oss konvertera dessa förutsägelser till varningar och insikter. Några vanligaste användningar för ett projekt som detta inkluderar:

• Att förstå hur många människor på en viss dag kom in i en begränsad zon så att byggarbetsplatser kan identifiera platser som kräver fler säkerhetsskyltar. Detta kan göras genom att samla in resultaten och använda dem för att skapa en instrumentpanel med Amazon QuickSight. Mer information om hur du skapar en instrumentpanel med QuickSight finns i Bygg en work-from-home ställning tracker med AWS DeepLens och GluonCV.
• Samla utdata från AWS DeepLens och konfigurera en Raspberry Pi för att låta en varning när någon går in i en begränsad zon. För mer information om att ansluta en AWS DeepLens-enhet till en Raspberry Pi-enhet, se Bygga en sopssorterare med AWS DeepLens.

Slutsats

I det här inlägget lärde du dig hur du tränar en objektdetekteringsmodell och distribuerar den till AWS DeepLens för att upptäcka personer som kommer in i begränsade zoner. Du kan använda den här självstudien som referens för att träna och distribuera dina egna projekt för objektdetektering på AWS DeepLens.

För en mer detaljerad genomgång av denna handledning och andra självstudier, exempel och projektidéer med AWS DeepLens, se AWS DeepLens-recept.

Om författarna

Yash Shah är datavetare i Amazon ML Solutions Lab, där han arbetar med en rad fall för maskininlärningsanvändning från vård till tillverkning och detaljhandel. Han har en formell bakgrund inom mänskliga faktorer och statistik och var tidigare en del av Amazon SCOT-teamet som designade produkter för att vägleda 3P-säljare med effektiv lagerhantering.

Phu Nguyen är produktchef för AWS Panorama. Han bygger produkter som ger utvecklare på alla nivåer en enkel och praktisk introduktion till maskininlärning.

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