Transfira o aprendizado com NVIDIA JetBot - Diversão com cones de trânsito: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Por dvillevaldMy GithubFollow Sobre: Eu gosto de aplicativos de IA e aprendizado de máquina, especialmente em robótica. Mais sobre dvillevald »

Ensine seu robô a encontrar um caminho em um labirinto de cones de trânsito usando a câmera e o modelo de aprendizado profundo de última geração.

Suprimentos

• NVIDIA JetBot

  A página de lista de materiais da NVIDIA JetBot Wiki lista tudo o que você precisa para construir o JetBot, junto com links de compra de fornecedores populares

• Computador com GPU NVIDIA

  Necessário para treinar o modelo

• BlueDot Trading 4 "RC Racing Agility Cones, laranja - conjunto de 20

Etapa 1: Motivação

Cada vez que dirijo na área de contração, fico pensando em como seria desafiador para um carro que dirige sozinho passar pelos cones de trânsito. Acontece que não é tão difícil com o novo JetBot da NVIDIA - com apenas algumas centenas de imagens, você pode treinar um modelo de aprendizado profundo de última geração para ensinar seu robô a encontrar um caminho em um labirinto de cones de trânsito de brinquedo usando apenas a câmera integrada e nenhum outro sensor.

Etapa 2: NVIDIA JetBot e visão geral do projeto

JetBot é um robô de código aberto baseado no kit NVIDIA Jetson Nano. Você pode encontrar instruções detalhadas sobre como construir e configurá-lo aqui.

Este projeto é um exemplo modificado de prevenção de colisão do NVIDIA JetBot Wiki. Consiste em três etapas principais, cada uma descrita em um bloco de notas Jupyter separado:

• Colete dados no JetBot - notebook data_collection_cones.ipynb
• Modelo de trem em outra máquina GPU - notebook train_model_cones.ipynb
• Execute uma demonstração ao vivo no JetBot - notebook live_demo_cones.ipynb

Você pode encontrar esses três cadernos Jupyter aqui

Etapa 3: Construir JetBot e Carregar Notebooks Jupyter

1. Crie e configure o JetBot conforme explicado aqui
2. Conecte-se ao seu robô navegando para https://: 8888Faça login com a senha padrão jetbot
3. Desligue todos os outros notebooks em execução selecionando Kernel -> Desligar Todos os Kernels …
4. Navegue até ~ / Notebooks /
5. Crie uma nova subpasta ~ / Notebooks / traffic_cones_driving /
6. Faça upload de data_collection_cones.ipynb e live_demo_cones.ipynb para ~ / Notebooks / traffic_cones_driving /

IMPORTANTE: Os notebooks Jupyter data_collection_cones.ipynb e live_demo_cones.ipynb referenciados nestas instruções devem ser executados no JetBot enquanto train_model_cones.ipynb - em um computador com GPU.

Portanto, temos que fazer upload de data_collection_cones.ipynb e live_demo_cones.ipynb para o JetBot e colocá-los em ~ / Notebooks / traffic_cones_driving /

Etapa 4: coleta de dados de treinamento no JetBot

Coletaremos um conjunto de dados de classificação de imagens que será usado para ajudar a JetBot a operar em um labirinto de cones de tráfego. JetBot aprenderá como estimar probabilidades de quatro cenários (classes):

• Grátis - quando é seguro seguir em frente
• Bloqueado - quando há um obstáculo na frente do robô
• Esquerda - quando o robô deve girar para a esquerda
• Certo - quando o robô deve girar para a direita

Para coletar os dados de treinamento no JetBot, usaremos o notebook Jupyter data_collection_cones.ipynb que contém instruções detalhadas sobre como fazê-lo. Para executar este notebook no JetBot, siga as próximas etapas:

1. Conecte-se ao seu robô navegando para https://: jetbot-ip-address:: 8888
2. Faça login com a senha padrão jetbot
3. Desligue todos os outros notebooks em execução selecionando Kernel -> Desligar Todos os Kernels …
4. Navegue para ~ / Notebooks / traffic_cones_driving /
5. Abra e siga o bloco de notas data_collection_cones.ipynb

Etapa 5: treinar a rede neural na máquina GPU

A seguir, usaremos os dados coletados para treinar novamente o modelo de aprendizado profundo AlexNet na máquina GPU (host) executando train_model_cones.ipynb.

Observe que train_model_cones.ipynb é o único notebook Jupyter neste tutorial que NÃO é executado no JetBot

1. Conecte-se a uma máquina GPU com PyTorch instalado e um servidor Jupyter Lab em execução
2. Carregue train_model_cones.ipynb notebook e para esta máquina
3. Faça upload do arquivo dataset_cones.zip que você criou no bloco de notas data_collection_cones.ipynb e extraia este conjunto de dados. (Após esta etapa, você deve ver uma pasta chamada dataset_cones aparecer no navegador de arquivos.)
4. Abra e siga o bloco de notas train_model_cones.ipynb. No final desta etapa, você criará um modelo - o arquivo best_model_cones.pth que deve ser carregado no JetBot para executar a demonstração ao vivo.

Etapa 6: execute a demonstração ao vivo no JetBot

Esta etapa final é fazer o upload do modelo best_model_cones.pth para o JetBot e executá-lo.

1. Alimente seu robô com a bateria USB
2. Conecte-se novamente ao seu robô navegando para https://: jetbot-ip-address:: 8888
3. Faça login com a senha padrão jetbot
4. Desligue todos os outros notebooks em execução selecionando Kernel -> Desligar Todos os Kernels …
5. Navegue até ~ / Notebooks / traffic_cones_driving
6. Abra e siga o bloco de notas live_demo_cones.ipynb

Comece com cautela e dê ao JetBot espaço suficiente para se mover. Experimente diferentes configurações de cone e veja o desempenho do robô em diferentes ambientes, iluminação, etc. Enquanto o notebook live_demo_cones.ipynb explica todas as etapas em detalhes, o gráfico a seguir mostra a lógica dos movimentos do robô dadas as probabilidades previstas pelos modelos.

O caderno também explica como armazenar o histórico de movimentos do robô com probabilidades livre / esquerda / direita / bloqueado previstas pelo modelo e como fazer dois vídeos FPV (visualização em primeira pessoa) (a taxas de 1 fps e 15 fps) com telemetria sobreposta e Dados de ações do JetBot. Eles são úteis para depuração, ajuste do controlador PID e melhoria do modelo.

Divirta-se e diga-me se tiver dúvidas!:-)

O código está disponível no Github