Protegendo pessoas de áreas perigosas através de fronteiras virtuais com visão computacional

Como as empresas aceitam robôs mais autônomos e outros equipamentos pesados ​​no local de trabalho, precisamos garantir que os equipamentos possam operar com segurança ao redor de colegas humanos. Neste post, mostraremos como construir uma fronteira virtual com visão computacional e AWS DeepLens, a câmera de vídeo habilitada para aprendizado profundo da AWS projetada para que os desenvolvedores aprendam o aprendizado de máquina (ML). Usando as técnicas de aprendizado de máquina neste post, você pode construir limites virtuais para áreas restritas que desligam equipamentos automaticamente ou soam um alerta quando humanos se aproximam.

Para este projeto, você treinará um modelo de detecção de objeto personalizado com Amazon Sage Maker e implantar o modelo em um dispositivo AWS DeepLens. A detecção de objetos é um algoritmo de ML que pega uma imagem como entrada e identifica os objetos e sua localização na imagem. Além das soluções de limites virtuais, você pode aplicar técnicas aprendidas nesta postagem quando precisar detectar onde certos objetos estão dentro de uma imagem ou contar o número de instâncias de um objeto desejado em uma imagem, como contar itens em um compartimento de armazenamento em uma prateleira de varejo.

Visão geral da solução

A explicação passo a passo inclui as seguintes etapas:

1. Prepare seu conjunto de dados para alimentar um algoritmo de ML.
2. Treine um modelo com o Amazon SageMaker.
3. Modelo de teste com zonas de restrição personalizadas.
4. Implante a solução para AWS DeepLens.

Também discutimos outros casos de uso do mundo real onde você pode aplicar esta solução.

O diagrama a seguir ilustra a arquitetura da solução.

Pré-requisitos

Para concluir esta explicação passo a passo, você deve ter os seguintes pré-requisitos:

Prepare seu conjunto de dados para alimentar um algoritmo de ML

Esta postagem usa um algoritmo de ML chamado modelo de detecção de objetos para construir uma solução que detecta se uma pessoa está em uma zona restrita personalizada. Você usa o disponível publicamente Conjunto de dados de detecção de pedestres disponível no Kaggle, que possui mais de 2,000 imagens. Este conjunto de dados tem rótulos para objetos humanos e semelhantes a humanos (como manequins) para que o modelo treinado possa distinguir com mais precisão entre humanos reais e adereços de papelão ou estátuas.

Por exemplo, as imagens a seguir são exemplos de um trabalhador da construção civil sendo detectado e se ele está na zona de restrição personalizada (contorno vermelho).

Para começar a treinar seu modelo, primeiro crie um balde S3 para armazenar seus dados de treinamento e saída do modelo. Para projetos AWS DeepLens, os nomes dos intervalos S3 devem começar com o prefixo deeplens-. Você usa esses dados para treinar um modelo com o SageMaker, um serviço totalmente gerenciado que oferece a capacidade de criar, treinar e implantar modelos de ML rapidamente.

Treine um modelo com Amazon SageMaker

Você usa blocos de notas SageMaker Jupyter como o ambiente de desenvolvimento para treinar o modelo. O Jupyter Notebook é um aplicativo da web de código aberto que permite criar e compartilhar documentos que contêm código ativo, equações, visualizações e texto narrativo. Para esta postagem, fornecemos Train_Object_Detection_People_DeepLens.ipynb, um caderno completo para você acompanhar.

Para criar um modelo de detecção de objeto personalizado, você precisa usar uma instância de trabalho de treinamento habilitada para unidade de processamento gráfico (GPU). As GPUs são excelentes para paralelizar cálculos necessários para treinar uma rede neural. Embora o bloco de notas em si seja uma única instância ml.t2.medium, o job de treinamento usa especificamente uma instância ml.p2.xlarge. Para acessar uma instância de trabalho de treinamento habilitado para GPU, você deve enviar uma solicitação de aumento de limite de serviço para o AWS Support Center.

Depois de receber o aumento do limite, conclua as seguintes etapas para criar uma instância de notebook SageMaker:

1. No console SageMaker, escolha Instâncias de notebook.
2. Escolha Criar instância de notebook.
3. Escolha Nome da instância do notebook, insira um nome para sua instância de notebook.
4. Escolha Tipo de instância, escolha t2.médio.

Este é o tipo de instância menos caro que as instâncias de notebook suportam e é suficiente para este tutorial.

5. Escolha Papel do IAM, escolha Crie uma nova função.

Certifique-se de Gerenciamento de acesso e identidade da AWS (IAM) função tem acesso ao intervalo S3 que você criou anteriormente (prefixo deeplens-).

6. Escolha Criar instância de notebook. Sua instância de notebook pode levar alguns minutos para inicializar.

7. Quando o status na página de instâncias do notebook mudar para InService, escolha Abra o Jupyter para iniciar sua instância de notebook Jupyter recém-criada.
8. Escolha Escolher arquivo para fazer o upload do Train_Object_Detection_people_DeepLens.ipynb arquivo que você baixou anteriormente.

9. Abra o caderno e siga até o fim.
10. Se você for questionado sobre a configuração do kernel, selecione conda_mxnet_p36.

O bloco de notas Jupyter contém uma mistura de texto e células de código. Para executar um trecho de código, escolha a célula e pressione Shift + Enter. Enquanto a célula está em execução, um asterisco aparece ao lado da célula. Quando a célula estiver completa, um número de output e uma nova célula de output aparecem abaixo da célula original.

11. Baixe o conjunto de dados do depósito S3 público na instância local do SageMaker e descompacte os dados. Isso pode ser feito seguindo o código no notebook:

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

12. Converta o conjunto de dados em um formato (Gravar IO) que pode ser alimentado no 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/ 

13. Transfira os arquivos RecordIO de volta para o Amazon S3.

Agora que você concluiu toda a preparação de dados, está pronto para treinar o detector de objetos.

Existem muitos tipos diferentes de algoritmos de detecção de objetos. Para esta postagem, você usa o Algoritmo de detecção de caixa múltipla de disparo único (SSD). O algoritmo SSD tem um bom equilíbrio entre velocidade e precisão, tornando-o ideal para execução em dispositivos de ponta, como AWS DeepLens.

Como parte do trabalho de treinamento, você tem várias opções para hiperparâmetros que ajudam a configurar o comportamento do treinamento (como número de épocas, taxa de aprendizado, tipo de otimizador e tamanho do minilote). Os hiperparâmetros permitem ajustar a velocidade de treinamento e a precisão do seu modelo. Para obter mais informações sobre hiperparâmetros, consulte Algoritmo de detecção de objetos.

15. Configure seus hiperparâmetros e canais de dados. Considere usar a seguinte definição de exemplo de hiperparâmetros:

     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) 

O notebook possui alguns hiperparâmetros padrão que foram pré-selecionados. Para detecção de pedestres, você treina o modelo por 100 épocas. Esta etapa de treinamento deve levar aproximadamente 2 horas usando uma instância ml.p2.xlarge. Você pode experimentar diferentes combinações de hiperparâmetros ou treinar por mais períodos para melhorias de desempenho. Para obter informações sobre os preços mais recentes, consulte Preços do Amazon SageMaker.

16. Você pode iniciar um job de treinamento com uma única linha de código e monitorar a precisão ao longo do tempo no console do SageMaker:

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

Para obter mais informações sobre como funciona o treinamento, consulte Criar trabalho de treinamento. O provisionamento e o download de dados demoram, dependendo do tamanho dos dados. Portanto, pode demorar alguns minutos antes de você começar a obter registros de dados para seus jobs de treinamento.

Você pode monitorar o andamento do seu trabalho de treinamento por meio da precisão média métrica (mAP), que permite monitorar a qualidade da capacidade do modelo de classificar objetos e detectar as caixas delimitadoras corretas. Os registros de dados também imprimem o mAP nos dados de validação, entre outras perdas, para cada execução do conjunto de dados, uma vez para uma época. Essa métrica é um proxy para a qualidade do desempenho do algoritmo na detecção precisa da classe e da caixa delimitadora precisa ao redor dela.

Quando o trabalho for concluído, você pode encontrar os arquivos do modelo treinado no intervalo S3 e na pasta especificada anteriormente em s3_output_location:

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

Para esta postagem, mostramos os resultados da validação definida na conclusão da 10ª época e da 100ª época. No final da 10ª época, vemos um mAP de validação de aproximadamente 0.027, enquanto a 100ª época foi de aproximadamente 0.42.

Para obter melhores resultados de detecção, você pode tentar ajustar os hiperparâmetros usando o recurso integrado ao SageMaker para ajuste automático do modelo e treinar o modelo por mais épocas. Você geralmente para de treinar quando vê um ganho decrescente na precisão.

Modelo de teste com zonas de restrição personalizadas

Antes de implantar o modelo treinado para AWS DeepLens, você pode testá-lo na nuvem usando um endpoint hospedado SageMaker. Um ponto de extremidade SageMaker é um serviço totalmente gerenciado que permite fazer inferências em tempo real por meio de uma API REST. O SageMaker permite que você implante rapidamente novos endpoints para testar seus modelos, para que você não precise hospedar o modelo na instância local que foi usada para treinar o modelo. Isso permite que você faça previsões (ou inferências) a partir do modelo em imagens que o algoritmo não viu durante o treinamento.

Você não precisa hospedar no mesmo tipo de instância que costumava treinar. O treinamento é um trabalho prolongado e de computação pesada que requer um conjunto diferente de requisitos de computação e memória que a hospedagem normalmente não requer. Você pode escolher qualquer tipo de instância que deseja hospedar o modelo. Nesse caso, escolhemos a instância ml.p3.2xlarge para treinar, mas optamos por hospedar o modelo na instância de CPU menos cara, ml.m4.xlarge. O fragmento de código a seguir mostra nossa implantação de endpoint.

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

Detecção em uma zona de restrição personalizada (região de interesse)

O formato da saída pode ser representado como [índice_classe, pontuação_confiança, xmin, ymin, xmax, ymax]. As previsões de baixa confiança geralmente têm maiores chances de um falso positivo ou falso negativo, portanto, você provavelmente deve descartar as previsões de baixa confiança. Você pode usar o código a seguir para detectar se a caixa delimitadora da pessoa se sobrepõe à zona restrita.

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 

Por padrão, o quadro completo é avaliado quanto à presença humana. No entanto, você pode especificar facilmente a região de interesse na qual a presença de uma pessoa é considerada de alto risco. Se você quiser adicionar uma zona de restrição personalizada, adicione as coordenadas dos vértices da região representada por [eixo X, eixo Y] e crie o polígono. As coordenadas devem ser inseridas no sentido horário ou anti-horário. Veja o seguinte código:

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

O código de exemplo a seguir mostra os pedestres identificados em uma zona restrita:

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

As imagens a seguir mostram nossos resultados.

Implante a solução para AWS DeepLens

Converta o modelo de implantação para AWS DeepLens

Ao implantar um modelo SSD treinado por SageMaker para AWS DeepLens, você deve primeiro executar implantar.py para converter o artefato do modelo em um modelo implantável:

!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

Importe seu modelo para AWS DeepLens

Para executar o modelo em um dispositivo AWS DeepLens, você precisa criar um projeto AWS DeepLens. Comece importando seu modelo para o AWS DeepLens.

1. No console do AWS DeepLens, em Recursos, escolha Modelos.
2. Escolha Modelo de importação.

3. Escolha Fonte de importação, selecione Modelo treinado externamente.
4. Insira a localização do Amazon S3 do modelo remendado que você salvou da execução de deploy.py na etapa acima.
5. Escolha Estrutura do modelo, escolha MXNet.
6. Escolha Modelo de importação.

Crie a função de inferência

A função de inferência alimenta cada quadro de câmera no modelo para obter previsões e executa qualquer lógica de negócios personalizada usando os resultados da inferência. Você usa AWS Lambda para criar uma função que você implanta no AWS DeepLens. A função executa inferência localmente no dispositivo AWS DeepLens.

Primeiro, precisamos criar uma função Lambda para implantar no AWS DeepLens.

1. Faça o download do função lambda de inferência.
2. No console do Lambda, escolha Funções.
3. Escolha Criar função.
4. Selecionar Autor do zero.
5. Escolha Nome da função, Insira o nome.
6. Escolha Runtime, escolha Python 3.7.
7. Escolha Escolha ou crie uma função de execução, escolha Use uma função existente.
8. Escolha service-role / AWSDeepLensLambdaRole.
9. Escolha Criar função.

10. Na página de detalhes da função, no Opções menu, escolha Faça upload de um arquivo .zip.

11. Nos envie os inferência lambda arquivo que você baixou anteriormente.
12. Escolha Salvar para salvar o código inserido.
13. No Opções menu, escolha Publicar nova versão.

Publicar a função a torna disponível no console AWS DeepLens para que você possa adicioná-la ao seu projeto personalizado.

14. Digite um número de versão e escolha Publique.

Compreendendo a função de inferência

Esta seção o conduz por algumas partes importantes da função de inferência. Primeiro, você deve prestar atenção a dois arquivos específicos:

• etiquetas.txt - Contém um mapeamento da saída da rede neural (inteiros) para rótulos legíveis por humanos (string)
• lambda_function.py - Contém código para a função que está sendo chamada para gerar previsões em cada quadro de câmera e enviar os resultados de volta

Em lambda_function.py, você primeiro carrega e otimiza o modelo. Em comparação com as máquinas virtuais em nuvem com uma GPU, o AWS DeepLens tem menos poder de computação. O AWS DeepLens usa o otimizador de modelo Intel OpenVino para otimizar o modelo treinado no SageMaker para ser executado em seu hardware. O código a seguir otimiza seu modelo para execução local:

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

Em seguida, você executa o modelo quadro a quadro sobre as imagens da câmera. Veja o seguinte código:

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

Finalmente, você envia os resultados da previsão de texto de volta para a nuvem. Visualizar os resultados do texto na nuvem é uma maneira conveniente de verificar se o modelo está funcionando corretamente. Cada dispositivo AWS DeepLens tem um iot_topic dedicado criado automaticamente para receber os resultados da inferência. Veja o seguinte código:

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

Crie um projeto personalizado do AWS DeepLens

Para criar um novo projeto AWS DeepLens, conclua as seguintes etapas:

1. No console AWS DeepLens, no Projectos página, escolha Criar projeto.
2. Escolha Tipo de projeto, selecione Crie um novo projeto em branco.
3. Escolha Próximo.

4. Nomeie seu projeto yourname-pedestrian-detector-.
5. Escolha Adicionar modelo.
6. Selecione o modelo que você acabou de criar.
7. Escolha Adicionar função.
8. Procure a função Lambda que você criou anteriormente pelo nome.
9. Escolha Criar projeto.
10. No Projectos página, selecione o projeto que deseja implantar.
11. Escolheu Implantar no dispositivo.
12. Escolha Dispositivo alvo, escolha o seu dispositivo.
13. Escolha Avaliações.
14. Revise suas configurações e escolha Implantação.

A implantação pode levar até 10 minutos para ser concluída, dependendo da velocidade da rede à qual seu AWS DeepLens está conectado. Quando a implantação for concluída, você deverá ver um banner verde na página com a mensagem, “Parabéns, seu modelo agora está sendo executado localmente no AWS DeepLens!”

Para ver a saída de texto, role para baixo na página de detalhes do dispositivo até o Resultado do projeto seção. Siga as instruções na seção para copiar o tópico e vá para o Núcleo da AWS IoT console para se inscrever no tópico. Você deve ver os resultados como na imagem a seguir.

Para obter instruções passo a passo sobre como visualizar o fluxo de vídeo ou saída de texto, consulte Visualizando os resultados do AWS DeepLens.

Casos de uso do mundo real

Agora que você tem previsões de seu modelo em execução no AWS DeepLens, vamos converter essas previsões em alertas e insights. Alguns usos mais comuns para um projeto como este incluem:

• Entender quantas pessoas em um determinado dia entraram em uma zona restrita para que os canteiros de obras possam identificar pontos que exigem mais sinalização de segurança. Isso pode ser feito coletando os resultados e usando-os para criar um painel usando AmazonQuickSight. Para obter mais detalhes sobre como criar um painel usando QuickSight, consulte Crie um rastreador de postura do trabalho em casa com o AWS DeepLens e o GluonCV.
• Coletar a saída do AWS DeepLens e configurar um Raspberry Pi para soar um alerta quando alguém estiver entrando em uma zona restrita. Para obter mais detalhes sobre como conectar um dispositivo AWS DeepLens a um dispositivo Raspberry Pi, consulte Construindo um classificador de lixo com AWS DeepLens.

Conclusão

Nesta postagem, você aprendeu como treinar um modelo de detecção de objeto e implantá-lo no AWS DeepLens para detectar pessoas entrando em zonas restritas. Você pode usar este tutorial como uma referência para treinar e implantar seus próprios projetos de detecção de objetos personalizados no AWS DeepLens.

Para obter instruções mais detalhadas sobre este tutorial e outros tutoriais, exemplos e ideias de projeto com AWS DeepLens, consulte Receitas do AWS DeepLens.

Sobre os autores

Yash Shah é um cientista de dados no Amazon ML Solutions Lab, onde trabalha em uma variedade de casos de uso de aprendizado de máquina, de assistência médica a manufatura e varejo. Ele tem experiência formal em Fatores Humanos e Estatística e anteriormente fez parte da equipe Amazon SCOT que projeta produtos para orientar os vendedores 3P com gerenciamento de estoque eficiente.

Phu Nguyen é gerente de produto do AWS Panorama. Ele cria produtos que oferecem aos desenvolvedores de qualquer nível de habilidade uma introdução fácil e prática ao aprendizado de máquina.

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