Faça um classificador de lixo de Pi com ML !: 8 etapas (com imagens)

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

O projeto Trash Classifier, carinhosamente conhecido como "Para onde vai ?!", foi desenvolvido para tornar o descarte de coisas mais rápido e confiável.

Este projeto usa um modelo de aprendizado de máquina (ML) treinado em Lobe, um construtor de modelos de ML amigável para iniciantes (sem código!), Para identificar se um objeto vai para o lixo, reciclagem, compostagem ou resíduos perigosos. O modelo é então carregado em um computador Raspberry Pi 4 para torná-lo utilizável em qualquer lugar onde você possa encontrar latas de lixo!

Este tutorial mostra como criar seu próprio projeto de classificador de lixo em um Raspberry Pi a partir de um modelo Lobe TensorFlow em Python3.

Dificuldade: iniciante ++ (algum conhecimento com circuitos e codificação é útil)

Tempo de leitura: 5 min

Tempo de construção: 60 - 90 min

Custo: ~ $ 70 (incluindo Pi 4)

Suprimentos:

Software (lado do PC)

• Lobo
• WinSCP (ou outro método de transferência de arquivo SSH, pode usar CyberDuck para Mac)
• terminal
• Conexão de área de trabalho remota ou RealVNC

Hardware

• Raspberry Pi, cartão SD e fonte de alimentação USB-C (5 V, 2,5 A)
• Pi Camera
• Botão de apertar

• 5 LEDs (4 LEDs indicadores e 1 LED de status)

  • LED amarelo: lixo
  • LED azul: reciclar
  • LED verde: composto
  • LED vermelho: resíduos perigosos
  • LED branco: status
• 6 resistores de 220 Ohm
• Fios de jumper 10 M para M
• Placa de ensaio, metade do tamanho

Se você escolher soldar:

• 1 conector JST, apenas extremidade fêmea
• 2 fios de ligação M para F
• 10 fios de jumper F para F
• PCB

Gabinete

• Caixa do projeto (por exemplo, papelão, madeira ou caixa de plástico, aproximadamente 6 "x 5" x 4 ")

• Quadrado de plástico transparente de 0,5 "x 0,5" (2cm x 2cm)

  Por exemplo. de uma tampa de recipiente de plástico para alimentos

• Velcro

Ferramentas

• Cortadores de arame
• Faca de precisão (por exemplo, faca exacto) e tapete de corte
• Ferro de soldar (opcional)
• Ferramenta de hot melt (ou outra cola não condutiva - epóxi funciona muito bem, mas é permanente)

Etapa 1: antes de começar

Este projeto pressupõe que você está começando com um Raspberry Pi totalmente configurado em uma configuração sem cabeça. Aqui está um guia para iniciantes sobre como fazer isso.

Também ajuda ter algum conhecimento do seguinte:

1. Familiaridade com o Raspberry Pi

   • Aqui está um prático guia de primeiros passos!
   • Também útil: Primeiros passos com a câmera Pi

2. Ler e editar o código Python (você não precisa escrever um programa, apenas edite)

   Introdução ao Python com o Raspberry Pi

3. Lendo diagramas de fiação de Fritzing

4. Usando um breadboard

   Como usar um tutorial de breadboard

Descubra para onde seu lixo vai

Cada cidade nos Estados Unidos (e eu presumo que no globo) tem seu próprio lixo / reciclagem / compostagem / etc. sistema de coleta. Isso significa que, para fazer um classificador de lixo preciso, precisaremos 1) construir um modelo de ML personalizado (abordaremos isso na próxima etapa - sem código!) E 2) saber para onde vai cada pedaço de lixo.

Como eu nem sempre sabia o compartimento adequado para cada item que usei para treinar meu modelo, usei o folheto Seattle Utilities (Foto 1) e também este prático "Para onde ele vai?" ferramenta de pesquisa para a cidade de Seattle! Verifique quais recursos estão disponíveis em sua cidade, consultando o utilitário de coleta de lixo de sua cidade e folheando seu site.

Etapa 2: criar um modelo de ML personalizado no Lobe

Lobe é uma ferramenta fácil de usar que tem tudo de que você precisa para dar vida às suas ideias de aprendizado de máquina. Mostre exemplos do que você deseja fazer e treine automaticamente um modelo de aprendizado de máquina personalizado que pode ser exportado para dispositivos e aplicativos de ponta. Não requer nenhuma experiência para começar. Você pode treinar em seu próprio computador gratuitamente!

Esta é uma visão geral rápida sobre como usar o Lobe:

1. Abra o programa Lobe e crie um novo projeto.

2. Tire ou importe fotos e classifique-as nas categorias apropriadas. (Foto 1) Vamos precisar dessas etiquetas mais tarde na parte de software do projeto.

Existem duas maneiras de importar fotos:

1. Tire fotos de itens diretamente da webcam do computador ou

2. Importe fotos de pastas existentes em seu computador.

   Lembre-se de que o nome da pasta de fotos será usado como o nome do rótulo da categoria, portanto, certifique-se de que ele corresponda aos rótulos existentes

À parte: acabei usando os dois métodos, pois quanto mais fotos você tiver, mais preciso será o seu modelo.

3. Use o recurso "Play" para testar a precisão do modelo. Altere distâncias, iluminação, posições das mãos, etc. para identificar onde o modelo está e onde não é preciso. Adicione mais fotos conforme necessário. (Fotos 3 - 4)

4. Quando estiver pronto, exporte seu modelo Lobe ML em um formato TensorFlow (TF) Lite.

Pontas:

• Antes de importar fotos, faça uma lista de todas as categorias de que você precisa e como deseja classificá-las (por exemplo, "lixo", "reciclar", "compostagem" etc.)

  Nota: Use os mesmos rótulos mostrados na foto "Lobe Model Labels" acima para reduzir a quantidade de código que você precisa alterar

• Incluir uma categoria para "não é lixo" que contém fotos de tudo o que pode estar na foto (por exemplo, suas mãos e braços, o plano de fundo, etc.)
• Se possível, tire fotos da câmera Pi e importe para o Lobe. Isso melhorará muito a precisão do seu modelo!
• Precisa de mais fotos? Confira os conjuntos de dados de código aberto no Kaggle, incluindo este conjunto de imagens de classificação de lixo!
• Precisa de mais ajuda? Conecte-se com a Comunidade Lobe no Reddit!

Etapa 3: Construa: Hardware

1. Conecte cuidadosamente a câmera Pi ao Pi (visite o guia de primeiros passos da Fundação Pi para obter mais informações). (Foto 1)

2. Siga o diagrama de fiação para conectar o botão e LEDs aos pinos Pi GPIO.

• Botão de pressão: Conecte uma perna do botão de pressão ao pino 2 GPIO. Conecte a outra, por meio de um resistor, a um pino GND GPIO.
• LED amarelo: Conecte a perna positiva (mais longa) ao pino GPIO 17. Conecte a outra perna, por meio de um resistor, a um pino GPIO GND.
• LED azul: conecte a perna positiva ao pino 27 GPIO. Conecte a outra perna, por meio de um resistor, a um pino GND GPIO.
• LED verde: conecte a perna positiva ao pino 22 GPIO. Conecte a outra perna, por meio de um resistor, a um pino GND GPIO.
• LED vermelho: conecte a perna positiva ao pino 23 GPIO. Conecte a outra perna, por meio de um resistor, a um pino GND GPIO.
• LED branco: Conecte a perna positiva ao pino GPIO 24. Conecte a outra perna, por meio de um resistor, a um pino GPIO GND.

3. Recomenda-se testar seu circuito em uma placa de ensaio e executar o programa antes de soldar ou tornar qualquer uma das conexões permanentes. Para fazer isso, precisaremos escrever e fazer upload de nosso programa de software, então vamos para a próxima etapa!

Etapa 4: Codifique: Software

1. No seu PC, abra o WinSCP e conecte-se ao seu Pi. Crie uma pasta Lobe no diretório inicial do seu Pi e crie uma pasta de modelo nesse diretório.

2. Arraste o conteúdo da pasta Lobe TF resultante para o Pi. Anote o caminho do arquivo: / home / pi / Lobe / model

3. No Pi, abra um terminal e baixe a biblioteca lobe-python para Python3 executando os seguintes comandos bash:

pip3 install

pip3 instalar lóbulo

4. Baixe o código do classificador de lixo (rpi_trash_classifier.py) deste repositório para o Pi (clique no botão "Código" conforme mostrado na Foto 1).

• Prefere copiar / colar? Obtenha o código bruto aqui.
• Prefere fazer o download para o seu computador? Baixe o repo / código em seu computador e depois transfira o código Python para o Pi via WinSCP (ou seu programa de transferência de arquivo remoto preferido).

5. Depois de conectar o hardware aos pinos GPIO do Pi, leia o código de exemplo e atualize todos os caminhos de arquivo conforme necessário:

• Linha 29: caminho de arquivo para o modelo Lobe TF
• Linhas 47 e 83: caminho de arquivo para imagens capturadas por meio da câmera Pi

6. Se necessário, atualize os rótulos do modelo no código para corresponder exatamente aos rótulos em seu modelo Lobe (incluindo letras maiúsculas, pontuação, etc.):

• Linha 57: "lixo"
• Linha 60: "reciclar"
• Linha 63: "composto"
• Linha 66: "instalação de resíduos perigosos"
• Linha 69: "não é lixo!"

7. Execute o programa usando Python3 na janela do terminal:

python3 rpi_trash_classifier.py

Etapa 5: Teste: execute o programa

visão geral do programa

Ao executar o programa pela primeira vez, levará algum tempo para carregar a biblioteca TensorFlow e o modelo Lobe ML. Quando o programa está pronto para capturar uma imagem, a luz de status (LED branco) piscará.

Depois de obter uma imagem, o programa irá comparar a imagem com o modelo Lobe ML e produzir a previsão resultante (linha 83). A saída determina qual luz está acesa: amarelo (lixo), azul (reciclar), verde (composto) ou vermelho (lixo perigoso).

Se nenhum dos LEDs indicadores acender e o LED de status voltar ao modo pulsante, significa que a imagem capturada "não era lixo", ou seja, tire a foto novamente!

Capturando uma imagem

Pressione o botão para capturar uma imagem. Observe que pode ser necessário segurar o botão por pelo menos 1s para que o programa registre a impressora. Recomenda-se tirar algumas imagens de teste e, em seguida, abri-las na área de trabalho para entender melhor a visão e o quadro da câmera.

Para permitir que o usuário posicione o objeto e os níveis de luz da câmera se ajustem, leva cerca de 5s para capturar totalmente uma imagem. Você pode alterar essas configurações no código (linhas 35 e 41), mas tenha em mente que a Pi Foundation recomenda um mínimo de 2s para o ajuste do nível de luz.

Solução de problemas

O maior desafio é garantir que a imagem capturada seja a que esperamos, portanto, reserve um tempo para revisar as imagens e comparar os resultados esperados com a saída do LED do indicador. Se necessário, você pode passar imagens para o modelo Lobe ML para inferência direta e comparação mais rápida.

Algumas coisas a serem observadas:

• A biblioteca TensorFlow provavelmente emitirá algumas mensagens de aviso - isso é típico para a versão usada neste código de amostra.
• Os rótulos de previsão devem ser exatamente como escritos na função led_select (), incluindo letras maiúsculas, pontuação e espaçamento. Certifique-se de alterá-los se tiver um modelo de Lóbulo diferente.
• O Pi requer uma fonte de alimentação estável. A luz de energia do Pi deve ser vermelha sólida e brilhante.
• Se um ou mais LEDs não ligam quando esperado, verifique forçando-os a acender com o comando:

red_led.on ()

Etapa 6: (Opcional) Construa: Finalize Seu Circuito

Agora que testamos e, se necessário, depuramos nosso projeto para que funcione como esperado, estamos prontos para soldar nosso circuito!

Nota: Se você não tiver um ferro de solda, pode pular esta etapa. Uma alternativa é revestir as conexões dos fios com cola quente (esta opção permitirá que você conserte / adicione / use coisas mais tarde, mas é mais provável que quebre), ou use epóxi ou uma cola permanente semelhante (esta opção será muito mais durável mas você não será capaz de usar o circuito ou potencialmente o Pi depois de fazer isso)

Comentário rápido sobre minhas escolhas de design (Foto 1):

• Optei por fios de jumper fêmea para os LEDs e Pi GPIO porque eles me permitem remover LEDs e trocar cores ou movê-los se necessário. Você pode pular estes se quiser tornar as conexões permanentes.
• Da mesma forma, escolhi um conector JST para o botão de pressão.

Avante para a construção

1. Corte cada um dos fios de jumper fêmea ao meio (sim, todos eles!). Usando descascadores de fio, remova cerca de 1/4 (1/2 cm) do isolamento do fio.

2. Para cada um dos LEDs, solde um resistor de 220Ω na perna negativa (mais curta). (Foto 2)

3. Corte um pedaço pequeno, com cerca de 1 (2 cm) de tubo termorretrátil e empurre o LED e a junção do resistor. Certifique-se de que a outra perna do resistor esteja acessível e aqueça o tubo termorretrátil até que prenda a junta. (Foto 3)

4. Insira cada LED em um par de fios de jumper fêmea. (Foto 4)

5. Identifique os fios do jumper (por exemplo, com fita) e solde os fios do jumper na placa de circuito impresso (PCB). (Foto 5)

6. Em seguida, use um fio de jumper fêmea (corte) para conectar cada LED ao seu respectivo pino Pi GPIO. Solde e etiquete um fio de ligação para que o metal desencapado se conecte à perna positiva do LED através do PCB. (Foto 5)

Nota: Onde você solda este fio dependerá do layout de sua placa de circuito impresso. Você também pode soldar este fio diretamente ao fio jumper positivo do LED.

7. Solde um resistor de 220Ω na extremidade negativa (preta) do conector JST. (Foto 6)

8. Solde o conector JST e o resistor ao botão de pressão. (Foto 6)

9. Conecte os fios de jumper M-para-F entre o conector do botão de pressão e os pinos GPIO (lembrete: preto é GND).

10. Cubra as conexões do PCB com cola quente ou epóxi para uma conexão mais segura.

Observação: se você escolher usar epóxi, pode não ser capaz de usar os pinos GPIO do Pi para outros projetos no futuro. Se você estiver preocupado com isso, adicione um cabo de fita GPIO e conecte os fios de jumper a ele.

Etapa 7: (Opcional) Construa: Case

Crie um invólucro para o seu Pi que manterá a câmera, o botão e os LEDs no lugar e, ao mesmo tempo, protegerá o Pi. Projete seu próprio gabinete ou siga nossas instruções de construção abaixo para criar um protótipo rápido de um gabinete de papelão!

1. Na parte superior da pequena caixa de papelão, trace os locais do botão, luz de status, luzes de identificação e a janela da câmera pi (Foto 1).

   Observação: a janela da câmera Pi deve ter cerca de 3/4 "x 1/2"

2. Usando sua faca de precisão, corte os traços.

   Nota: você pode querer testar os tamanhos conforme avança (Foto 1)

3. Opcional: Pinte a caixa! Optei por tinta spray:)
4. Recorte uma capa retangular de "janela" para a câmera Pi (Foto 4) e cole na parte interna da caixa

5. Finalmente, corte a fenda para o cabo de alimentação Pi.

   Recomenda-se instalar primeiro todos os componentes eletrônicos para localizar o melhor lugar para o slot do cabo de alimentação pi

Etapa 8: Instalar e implantar

É isso! Você está pronto para instalar e implantar seu projeto! Coloque o invólucro acima de suas lixeiras, conecte o Pi e execute o programa para obter uma maneira mais rápida e confiável de reduzir nosso desperdício. Yay!

Daqui para frente

• Compartilhe seus projetos e ideias com outras pessoas por meio da comunidade Lobe Reddit!
• Confira o repositório Lobe Python GitHub para uma visão geral sobre como usar Python para implantar uma variedade maior de projetos Lobe
• Dúvidas ou solicitações de projetos? Deixe um comentário sobre este projeto ou entre em contato conosco diretamente: [email protected]