Protezione delle persone dalle aree pericolose attraverso i confini virtuali con Computer Vision

Timestamp: 13 aprile 2021 2:49
Nodo di origine: 807925

Poiché le aziende accolgono sempre più robot autonomi e altre apparecchiature pesanti sul posto di lavoro, dobbiamo garantire che le apparecchiature possano funzionare in sicurezza attorno ai compagni di squadra umani. In questo post, ti mostreremo come costruire un confine virtuale con la visione artificiale e Obiettivo AWS Deep, la videocamera AWS abilitata per il deep learning progettata per consentire agli sviluppatori di apprendere il machine learning (ML). Utilizzando le tecniche di apprendimento automatico in questo post, puoi creare confini virtuali per aree riservate che spengono automaticamente le apparecchiature o emettono un avviso quando gli umani si avvicinano.

Per questo progetto, addestrerai un modello di rilevamento di oggetti personalizzato con Amazon Sage Maker e distribuisci il modello su un dispositivo AWS DeepLens. Il rilevamento degli oggetti è un algoritmo ML che prende un'immagine come input e identifica gli oggetti e la loro posizione all'interno dell'immagine. Oltre alle soluzioni di confine virtuale, puoi applicare le tecniche apprese in questo post quando devi rilevare dove si trovano determinati oggetti all'interno di un'immagine o contare il numero di istanze di un oggetto desiderato in un'immagine, come contare gli elementi in un contenitore di archiviazione o su uno scaffale di vendita al dettaglio.

Panoramica della soluzione

La procedura dettagliata include i seguenti passaggi:

  1. Prepara il tuo set di dati da inserire in un algoritmo ML.
  2. Addestra un modello con Amazon SageMaker.
  3. Modello di prova con zone di restrizione personalizzate.
  4. Distribuisci la soluzione in AWS DeepLens.

Discutiamo anche di altri casi d'uso del mondo reale in cui è possibile applicare questa soluzione.

Il diagramma seguente illustra l'architettura della soluzione.

Prerequisiti

Per completare questa procedura dettagliata, è necessario disporre dei seguenti prerequisiti:

Prepara il tuo set di dati da inserire in un algoritmo ML

Questo post utilizza un algoritmo ML chiamato modello di rilevamento degli oggetti per creare una soluzione che rilevi se una persona si trova in una zona riservata personalizzata. Si utilizza il pubblicamente disponibile Set di dati sul rilevamento dei pedoni disponibile su Kaggle, che ha oltre 2,000 immagini. Questo set di dati ha etichette per oggetti umani e simili (come manichini) in modo che il modello addestrato possa distinguere più accuratamente tra umani reali e oggetti di scena o statue di cartone.

Ad esempio, le seguenti immagini sono esempi di rilevamento di un operaio edile e se si trova nella zona di restrizione personalizzata (contorno rosso).

Per iniziare ad addestrare il tuo modello, creare prima un bucket S3 per archiviare i dati di addestramento e l'output del modello. Per i progetti AWS DeepLens, i nomi dei bucket S3 devono iniziare con il prefisso deeplens-. Puoi utilizzare questi dati per addestrare un modello con SageMaker, un servizio completamente gestito che offre la possibilità di creare, addestrare e distribuire rapidamente modelli ML.

Addestra un modello con Amazon SageMaker

Utilizza i notebook SageMaker Jupyter come ambiente di sviluppo per addestrare il modello. Jupyter Notebook è un'applicazione Web open source che consente di creare e condividere documenti che contengono codice live, equazioni, visualizzazioni e testo narrativo. Per questo post, forniamo Train_Object_Detection_People_DeepLens.ipynb, un taccuino completo da seguire.

Per creare un modello di rilevamento oggetti personalizzato, è necessario utilizzare un'istanza lavoro di addestramento abilitata per GPU (Graphic Processing Unit). Le GPU sono eccellenti nel parallelizzare i calcoli necessari per addestrare una rete neurale. Sebbene il notebook stesso sia una singola istanza ml.t2.medium, il processo di addestramento utilizza specificamente un'istanza ml.p2.xlarge. Per accedere a un'istanza lavoro di addestramento abilitata per GPU, è necessario inviare una richiesta di aumento del limite del servizio all'AWS Support Center.

Dopo aver ricevuto l'aumento del limite, completa i seguenti passaggi per creare un'istanza notebook SageMaker:

  1. Sulla console di SageMaker, scegli Istanze di notebook.
  2. Scegli Crea istanza del blocco note.
  3. Nel Nome dell'istanza del notebook, inserisci un nome per la tua istanza notebook.
  4. Nel Tipo di istanzascegli t2.medio.

Questo è il tipo di istanza meno costoso supportato dalle istanze notebook ed è sufficiente per questo tutorial.

  1. Nel Ruolo IAMscegli Crea un nuovo ruolo.

Assicurati questo Gestione dell'identità e dell'accesso di AWS (IAM) ha accesso al bucket S3 creato in precedenza (prefisso deeplens-).

  1. Scegli Crea istanza del blocco note. L'avvio dell'istanza notebook può richiedere un paio di minuti.
  1. Quando lo stato nella pagina delle istanze del blocco appunti cambia in InService, scegliere Apri Jupyter per avviare l'istanza del notebook Jupyter appena creata.
  2. Scegli Caricare per caricare il file Train_Object_Detection_people_DeepLens.ipynb file scaricato in precedenza.

  1. Apri il taccuino e seguilo fino alla fine.
  2. Se ti viene chiesto di impostare il kernel, seleziona conda_mxnet_p36.

Il notebook Jupyter contiene una combinazione di testo e celle di codice. Per eseguire un pezzo di codice, scegli la cella e premi Maiusc + Invio. Mentre la cella è in esecuzione, accanto alla cella viene visualizzato un asterisco. Quando la cella è completa, sotto la cella originale vengono visualizzati un numero di output e una nuova cella di output.

  1. Scarica il set di dati dal bucket S3 pubblico nell'istanza SageMaker locale e decomprimi i dati. Questo può essere fatto seguendo il codice nel notebook: 
     !aws s3 cp s3://deeplens-public/samples/pedestriansafety/humandetection_data.zip . !rm -rf humandetection/ !unzip humandetection_data.zip -d humandetection

  2. Converti il ​​set di dati in un formato (Registra IO) che può essere inserito nell'algoritmo SageMaker: 
     !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/

  3. Ritrasferisci i file RecordIO su Amazon S3.

Ora che hai finito con tutta la preparazione dei dati, sei pronto per addestrare il rilevatore di oggetti.

Esistono molti tipi diversi di algoritmi di rilevamento degli oggetti. Per questo post, usi il file Algoritmo Single-Shot MultiBox Detection (SSD). L'algoritmo SSD ha un buon equilibrio tra velocità e precisione, rendendolo ideale per l'esecuzione su dispositivi edge come AWS DeepLens.

Come parte del lavoro di addestramento, hai molte opzioni per gli iperparametri che aiutano a configurare il comportamento di addestramento (come il numero di epoche, la velocità di apprendimento, il tipo di ottimizzatore e le dimensioni del mini-batch). Gli iperparametri ti consentono di regolare la velocità di addestramento e la precisione del tuo modello. Per ulteriori informazioni sugli iperparametri, vedere Algoritmo di rilevamento degli oggetti.

  1. Configura gli iperparametri e i canali dati. Prendi in considerazione l'utilizzo della seguente definizione di esempio di iperparametri: 
     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)

Il notebook ha alcuni iperparametri predefiniti che sono stati preselezionati. Per il rilevamento dei pedoni, addestrare il modello per 100 epoche. Questa fase di addestramento dovrebbe richiedere circa 2 ore utilizzando un'istanza ml.p2.xlarge. Puoi sperimentare diverse combinazioni di iperparametri o allenarti per più epoche per migliorare le prestazioni. Per informazioni sui prezzi più recenti, vedere Prezzi di Amazon SageMaker.

  1. Puoi iniziare un lavoro di addestramento con una singola riga di codice e monitorare l'accuratezza nel tempo sulla console SageMaker: 
    od_model.fit(inputs=data_channels, logs=True)

Per ulteriori informazioni su come funziona la formazione, vedere Crea lavoro di formazione. Il provisioning e il download dei dati richiedono tempo, a seconda della dimensione dei dati. Pertanto, potrebbero essere necessari alcuni minuti prima che inizi a ricevere i registri dei dati per i tuoi lavori di formazione.

Puoi monitorare l'avanzamento del tuo lavoro di addestramento attraverso la precisione media media metrica (mAP), che ti consente di monitorare la qualità della capacità del modello di classificare gli oggetti e rilevare i riquadri di delimitazione corretti. I registri dei dati stampano anche il mAP sui dati di convalida, tra le altre perdite, per ogni esecuzione del set di dati, una volta per un'epoca. Questa metrica è un proxy per la qualità delle prestazioni dell'algoritmo nel rilevare con precisione la classe e il riquadro di delimitazione accurato attorno ad essa.

Al termine del lavoro, puoi trovare i file del modello addestrato nel bucket S3 e nella cartella specificati in precedenza s3_output_location:

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

Per questo post, mostriamo i risultati sulla convalida impostata al completamento della 10a epoca e della 100a epoca. Alla fine della decima epoca, vediamo un mAP di convalida di circa 10, mentre la centesima epoca era di circa 0.027.

Per ottenere risultati di rilevamento migliori, puoi provare a ottimizzare gli iperparametri utilizzando la funzionalità integrata in SageMaker for messa a punto automatica del modello e addestrare il modello per più epoche. Di solito interrompi l'allenamento quando vedi un aumento della precisione in diminuzione.

Modello di prova con zone di restrizione personalizzate

Prima di distribuire il modello addestrato in AWS DeepLens, puoi testarlo nel cloud utilizzando un endpoint ospitato da SageMaker. Un endpoint SageMaker è un servizio completamente gestito che ti consente di effettuare inferenze in tempo reale tramite un'API REST. SageMaker ti consente di distribuire rapidamente nuovi endpoint per testare i tuoi modelli in modo da non dover ospitare il modello sull'istanza locale utilizzata per addestrare il modello. Ciò consente di effettuare previsioni (o inferenze) dal modello su immagini che l'algoritmo non ha visto durante l'addestramento.

Non è necessario ospitare sullo stesso tipo di istanza utilizzato per l'addestramento. L'addestramento è un lavoro prolungato e pesante per il calcolo che richiede un set diverso di requisiti di calcolo e memoria che l'hosting in genere non richiede. Puoi scegliere qualsiasi tipo di istanza in cui desideri ospitare il modello. In questo caso, abbiamo scelto l'istanza ml.p3.2xlarge da addestrare, ma abbiamo scelto di ospitare il modello sull'istanza CPU meno costosa, ml.m4.xlarge. Il seguente frammento di codice mostra la nostra distribuzione dell'endpoint.

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

Rilevamento in una zona di restrizione personalizzata (regione di interesse)

Il formato dell'output può essere rappresentato come [indice_classe, punteggio_confidenza, xmin, ymin, xmax, ymax]. Le previsioni a bassa confidenza hanno spesso maggiori probabilità di un falso positivo o falso negativo, quindi dovresti probabilmente scartare le previsioni a bassa confidenza. È possibile utilizzare il codice seguente per rilevare se il riquadro di delimitazione della persona si sovrappone alla zona riservata.

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

Per impostazione predefinita, l'inquadratura completa viene valutata per la presenza umana. Tuttavia, puoi facilmente specificare la regione di interesse all'interno della quale la presenza di una persona è ritenuta ad alto rischio. Se desideri aggiungere una zona di restrizione personalizzata, aggiungi le coordinate dei vertici della regione rappresentata da [asse X, asse Y] e crea il poligono. Le coordinate devono essere inserite in senso orario o antiorario. Vedere il seguente codice:

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

Il seguente codice di esempio mostra i pedoni identificati all'interno di una zona a traffico limitato:

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

Le seguenti immagini mostrano i nostri risultati.

Distribuisci la soluzione in AWS DeepLens

Converti il ​​modello per la distribuzione in AWS DeepLens

Quando distribuisci un modello SSD addestrato da SageMaker in AWS DeepLens, devi prima eseguire deploy.py per convertire l'artefatto del modello in un modello distribuibile:

!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

Importa il tuo modello in AWS DeepLens

Per eseguire il modello su un dispositivo AWS DeepLens, devi creare un progetto AWS DeepLens. Inizia importando il tuo modello in AWS DeepLens.

  1. Sulla console AWS DeepLens, sotto Risorsescegli Modelli.
  2. Scegli Importa modello.

  1. Nel Fonte di importazione, selezionare Modello addestrato esternamente.
  2. Inserisci la posizione Amazon S3 del file modello rattoppato che hai salvato dall'esecuzione di deploy.py nel passaggio precedente.
  3. Nel Quadro modelloscegli MXNet.
  4. Scegli Importa modello.

Crea la funzione di inferenza

La funzione di inferenza inserisce ogni fotogramma della telecamera nel modello per ottenere previsioni ed esegue qualsiasi logica aziendale personalizzata utilizzando i risultati dell'inferenza. Usate AWS Lambda per creare una funzione da distribuire in AWS DeepLens. La funzione esegue l'inferenza in locale sul dispositivo AWS DeepLens.

Innanzitutto, dobbiamo creare una funzione Lambda da distribuire in AWS DeepLens.

  1. Scarica la Funzione Lambda di inferenza.
  2. Sulla console Lambda, selezionare funzioni.
  3. Scegli Crea funzione.
  4. Seleziona Autore da zero.
  5. Nel Nome della funzione, inserisci un nome.
  6. Nel Runtimescegli Python 3.7.
  7. Nel Scegli o crea un ruolo di esecuzionescegli Usa un ruolo esistente.
  8. Scegli ruolo-servizio / AWSDeepLensLambdaRole.
  9. Scegli Crea funzione.

  1. Nella pagina dei dettagli della funzione, nel file Azioni menù, scegliere Carica un file .zip.

  1. Carica il inferenza Lambda file scaricato in precedenza.
  2. Scegli Risparmi per salvare il codice inserito.
  3. Sulla Azioni menù, scegliere Pubblica nuova versione.

La pubblicazione della funzione la rende disponibile nella console AWS DeepLens in modo che tu possa aggiungerla al tuo progetto personalizzato.

  1. Inserisci un numero di versione e scegli Pubblica.

Comprensione della funzione di inferenza

Questa sezione ti guida attraverso alcune parti importanti della funzione di inferenza. Innanzitutto, dovresti prestare attenzione a due file specifici:

  • etichette.txt – Contiene una mappatura dell'output dalla rete neurale (numeri interi) alle etichette leggibili dall'uomo (stringa)
  • funzione_lambda.py – Contiene il codice per la funzione chiamata per generare previsioni su ogni fotogramma della telecamera e restituire i risultati

In lambda_function.py, per prima cosa carichi e ottimizzi il modello. Rispetto alle macchine virtuali cloud con una GPU, AWS DeepLens ha una potenza di calcolo inferiore. AWS DeepLens utilizza l'ottimizzatore del modello Intel OpenVino per ottimizzare il modello addestrato in SageMaker per l'esecuzione sul proprio hardware. Il codice seguente ottimizza il modello per l'esecuzione in locale:

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

Quindi si esegue il modello fotogramma per fotogramma sulle immagini dalla fotocamera. Vedere il codice seguente:

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

Infine, invii i risultati della previsione del testo al cloud. Visualizzare i risultati del testo nel cloud è un modo conveniente per assicurarsi che il modello funzioni correttamente. Ogni dispositivo AWS DeepLens ha un iot_topic dedicato creato automaticamente per ricevere i risultati dell'inferenza. Vedere il seguente codice:

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

Crea un progetto AWS DeepLens personalizzato

Per creare un nuovo progetto AWS DeepLens, completa i seguenti passaggi:

  1. Nella console AWS DeepLens, in Progetti pagina, scegli Crea progetto.
  2. Nel Tipo di progetto, selezionare Crea un nuovo progetto vuoto.
  3. Scegli Avanti.

  1. Dai un nome al tuo progetto yourname-pedestrian-detector-.
  2. Scegli Aggiungi modello.
  3. Seleziona il modello appena creato.
  4. Scegli Aggiungi funzione.
  5. Cerca la funzione Lambda che hai creato in precedenza per nome.
  6. Scegli Crea progetto.
  7. Sulla Progetti pagina, selezionare il progetto che si desidera distribuire.
  8. Ha scelto Distribuisci sul dispositivo.
  9. Nel Dispositivo di destinazione, scegli il tuo dispositivo.
  10. Scegli Review.
  11. Rivedi le tue impostazioni e scegli Schierare.

Il completamento della distribuzione può richiedere fino a 10 minuti, a seconda della velocità della rete a cui è connesso AWS DeepLens. Al termine della distribuzione, dovresti vedere un banner verde sulla pagina con il messaggio "Congratulazioni, il tuo modello è ora in esecuzione in locale su AWS DeepLens!"

Per visualizzare l'output di testo, scorrere verso il basso nella pagina dei dettagli del dispositivo fino al file Output del progetto sezione. Segui le istruzioni nella sezione per copiare l'argomento e vai al AWS IoT Core console per iscriverti all'argomento. Dovresti vedere i risultati come nello screenshot seguente.

Per istruzioni dettagliate sulla visualizzazione del flusso video o dell'output di testo, vedere Visualizzazione dei risultati da AWS DeepLens.

Casi d'uso del mondo reale

Ora che hai le previsioni del tuo modello in esecuzione su AWS DeepLens, convertiamo tali previsioni in avvisi e approfondimenti. Alcuni usi più comuni per un progetto come questo includono:

  • Capire quante persone in un dato giorno sono entrate in una zona a traffico limitato in modo che i cantieri possano identificare i punti che richiedono più segnaletica di sicurezza. Questo può essere fatto raccogliendo i risultati e utilizzandoli per creare un dashboard utilizzando Amazon QuickSight. Per ulteriori dettagli sulla creazione di un dashboard utilizzando QuickSight, vedere Costruisci un localizzatore di postura da casa con AWS DeepLens e GluonCV.
  • Raccolta dell'output da AWS DeepLens e configurazione di un Raspberry Pi per emettere un avviso quando qualcuno entra in una zona riservata. Per ulteriori dettagli sulla connessione di un dispositivo AWS DeepLens a un dispositivo Raspberry Pi, consulta Creazione di un selezionatore di rifiuti con AWS DeepLens.

Conclusione

In questo post, hai imparato come addestrare un modello di rilevamento degli oggetti e distribuirlo in AWS DeepLens per rilevare le persone che accedono alle zone riservate. Puoi utilizzare questo tutorial come riferimento per addestrare e distribuire i tuoi progetti di rilevamento di oggetti personalizzati su AWS DeepLens.

Per una procedura dettagliata più dettagliata di questo tutorial e altri tutorial, esempi e idee di progetti con AWS DeepLens, consulta Ricette AWS DeepLens.

Informazioni sugli autori

Yash Shah è un data scientist presso l'Amazon ML Solutions Lab, dove lavora su una serie di casi d'uso di machine learning dall'assistenza sanitaria alla produzione e vendita al dettaglio. Ha un background formale in fattori umani e statistiche e in precedenza faceva parte del team di Amazon SCOT che progettava prodotti per guidare i venditori 3P con una gestione efficiente dell'inventario.

Phu Nguyen è un Product Manager per AWS Panorama. Crea prodotti che offrono agli sviluppatori di qualsiasi livello di abilità un'introduzione semplice e pratica all'apprendimento automatico.

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

Timestamp:

Di più da Blog di apprendimento automatico AWS