Creați un clasificator de gunoi Pi cu ML !: 8 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Proiectul Trash Classifier, cunoscut cu afecțiune ca „Unde merge ?!”, este conceput pentru a arunca lucrurile mai repede și mai fiabil.

Acest proiect folosește un model de învățare automată (ML) instruit în Lobe, un constructor de modele ML pentru începători (fără cod!), Pentru a identifica dacă un obiect merge în gunoi, în reciclare, în compost sau în deșeuri periculoase. Modelul este apoi încărcat pe un computer Raspberry Pi 4 pentru al face utilizabil oriunde ați putea găsi coșuri de gunoi!

Acest tutorial vă arată cum să creați propriul proiect de clasificare a coșului de gunoi pe un Raspberry Pi dintr-un model Lobe TensorFlow în Python3.

Dificultate: Începător ++ (unele cunoștințe cu circuitele și codarea sunt utile)

Timp de citire: 5 min

Timp de construcție: 60 - 90 min

Cost: ~ 70 USD (inclusiv Pi 4)

Provizii:

Software (partea PC)

• Lob
• WinSCP (sau altă metodă de transfer de fișiere SSH, poate folosi CyberDuck pentru Mac)
• Terminal
• Conexiune desktop la distanță sau RealVNC

Hardware

• Raspberry Pi, card SD și sursă de alimentare USB-C (5V, 2.5A)
• Camera Pi
• Apasa butonul

• 5 LED-uri (4 LED-uri indicatoare și 1 LED de stare)

  • LED galben: gunoi
  • LED albastru: reciclați
  • LED verde: compost
  • LED roșu: deșeuri periculoase
  • LED alb: stare
• 6 rezistoare de 220 Ohm
• 10 fire jumper de la M la M
• Placă de pâine, de jumătate

Dacă alegeți să lipiți:

• 1 conector JST, numai capăt femelă
• 2 fire jumper de la M la F
• 10 fire jumper F-to-F
• PCB

Incintă

• Carcasa proiectului (de ex. Cutie de carton, lemn sau plastic, aprox. 6 "x 5" x 4 ")

• 0,5 "x 0,5" (2cm x 2cm) pătrat din plastic transparent

  De exemplu. dintr-un capac din plastic pentru recipient pentru alimente

• Velcro

Instrumente

• Freze de sârmă
• Cuțit de precizie (de ex. Cuțit exacto) și covor de tăiere
• Fier de lipit (opțional)
• Instrument de topire la cald (sau alt lipici neconductiv - epoxidicul funcționează excelent, dar este permanent)

Pasul 1: Înainte de a începe

Acest proiect presupune că începeți cu un Raspberry Pi complet configurat într-o configurație fără cap. Iată un ghid pentru începători despre cum să faceți acest lucru.

De asemenea, vă ajută să cunoașteți următoarele:

1. Familiarizarea cu Raspberry Pi

   • Iată un ghid de pornire la îndemână!
   • De asemenea, util: Noțiuni introductive despre camera Pi

2. Citirea și editarea codului Python (nu va trebui să scrieți un program, doar să editați)

   Introducere în Python cu Raspberry Pi

3. Citirea diagramelor de cablare Fritzing

4. Folosind o placă de calcul

   Cum se folosește un tutorial pentru breadboard

Aflați unde merge gunoiul dvs

Fiecare oraș din SUA (și aș presupune că globul) are propriul său gunoi / reciclare / compost / etc. sistem de colectare. Aceasta înseamnă că, pentru a crea un clasificator de gunoi precis, va trebui să 1) să construim un model ML personalizat (vom acoperi acest lucru în pasul următor - fără cod!) Și 2) să știm unde merge fiecare bucată de gunoi.

Deoarece nu știam întotdeauna coșul adecvat pentru fiecare articol pe care l-am folosit pentru a-mi antrena modelul, am folosit volantul Seattle Utilities (Foto 1) și, de asemenea, acest lucru la îndemână "Unde merge?" instrument de căutare pentru orașul Seattle! Verificați ce resurse sunt disponibile în orașul dvs., căutând utilitarul de colectare a gunoiului din orașul dvs. și consultând site-ul său web.

Pasul 2: Creați un model ML personalizat în Lobe

Lobe este un instrument ușor de utilizat, care are tot ce aveți nevoie pentru a aduce la viață ideile dvs. de învățare automată. Arătați-i exemple de ceea ce doriți să facă și antrenează automat un model personalizat de învățare automată care poate fi exportat pentru dispozitive și aplicații edge. Pentru a începe, nu necesită nicio experiență. Vă puteți antrena gratuit pe propriul computer!

Iată o prezentare generală rapidă despre cum să utilizați Lobe:

1. Deschideți programul Lobe și creați un proiect nou.

2. Faceți sau importați fotografii și etichetați-le în categorii adecvate. (Foto 1) Vom avea nevoie de aceste etichete mai târziu în partea software a proiectului.

Există două moduri de a importa fotografii:

1. Faceți fotografii de articole direct de pe camera web a computerului sau

2. Importați fotografii din folderele existente pe computer.

   Rețineți că numele folderului foto va fi folosit ca nume de etichetă de categorie, deci asigurați-vă că se potrivește cu etichetele existente

În afară de asta: am ajuns să folosesc ambele metode, deoarece cu cât aveți mai multe fotografii, cu atât este mai precis modelul dvs.

3. Utilizați funcția „Redare” pentru a testa precizia modelului. Schimbați distanțele, iluminarea, pozițiile mâinilor etc. pentru a identifica unde este și nu modelul exact. Adăugați mai multe fotografii după cum este necesar. (Fotografii 3-4)

4. Când sunteți gata, exportați modelul Lobe ML într-un format TensorFlow (TF) Lite.

Sfaturi:

• Înainte de a importa fotografii, faceți o listă cu toate categoriile de care aveți nevoie și cum doriți să le etichetați (de ex. „Gunoi”, „reciclare”, „compost” etc.)

  Notă: Utilizați aceleași etichete ca în imaginea de mai sus „Etichete model lob” pentru a reduce cantitatea de cod pe care trebuie să o modificați

• Includeți o categorie pentru „nu coșul de gunoi” care conține fotografii cu orice altceva ar putea fi în fotografie (de exemplu, mâinile și brațele dvs., fundalul etc.)
• Dacă este posibil, faceți fotografii de pe camera Pi și importați în Lobe. Acest lucru va îmbunătăți foarte mult acuratețea modelului dvs.!
• Aveți nevoie de mai multe fotografii? Verificați seturile de date open-source pe Kaggle, inclusiv acest set de imagini de clasificare a gunoiului!
• Ai nevoie de mai mult ajutor? Conectați-vă cu comunitatea Lobe de pe Reddit!

Pasul 3: Construiți-l: Hardware

1. Conectați cu atenție camera Pi la Pi (accesați ghidul introductiv Pi Foundation pentru mai multe informații). (Foto 1)

2. Urmați schema de cablare pentru a conecta butonul și LED-urile la pinii GPIO Pi.

• Buton: Conectați un picior al butonului la pinul GPIO 2. Conectați celălalt, printr-un rezistor, la un pin GPIO GND.
• LED galben: Conectați piciorul pozitiv (mai lung) la pinul GPIO 17. Conectați celălalt picior, printr-un rezistor, la un pin GPIO GND.
• LED albastru: Conectați piciorul pozitiv la pinul GPIO 27. Conectați celălalt picior, printr-un rezistor, la un pin GPIO GND.
• LED verde: Conectați piciorul pozitiv la pinul GPIO 22. Conectați celălalt picior, printr-un rezistor, la un pin GPIO GND.
• LED roșu: Conectați piciorul pozitiv la pinul GPIO 23. Conectați celălalt picior, printr-un rezistor, la un pin GPIO GND.
• LED alb: Conectați piciorul pozitiv la pinul GPIO 24. Conectați celălalt picior, printr-un rezistor, la un pin GPIO GND.

3. Este recomandat să vă testați circuitul pe o placă de rulare și să rulați programul înainte de a lipi sau a face oricare dintre conexiuni permanente. Pentru a face acest lucru, va trebui să scriem și să încărcăm programul nostru software, așa că să trecem la pasul următor!

Pasul 4: Codificați-l: Software

1. Pe computer, deschideți WinSCP și conectați-vă la Pi. Creați un folder Lobe în directorul principal al Pi și creați un folder model în acel director.

2. Trageți conținutul folderului Lobe TF rezultat pe Pi. Notați calea fișierului: / home / pi / Lobe / model

3. Pe Pi, deschideți un terminal și descărcați biblioteca lobe-python pentru Python3 executând următoarele comenzi bash:

instalați pip3

pip3 instalează lobul

4. Descărcați codul de clasificare a coșului de gunoi (rpi_trash_classifier.py) din această repo pe Pi (faceți clic pe butonul „Cod” așa cum se arată în fotografia 1).

• Preferați să copiați / lipiți? Obțineți codul brut aici.
• Preferați să descărcați pe computer? Descărcați repo / codul pe computer, apoi transferați codul Python în Pi prin WinSCP (sau programul dvs. preferat de transfer de fișiere la distanță).

5. După ce ați conectat hardware-ul la pinii GPIO ai Pi, citiți exemplul de cod și actualizați orice cale de fișier după cum este necesar:

• Linia 29: cale de fișiere către modelul Lobe TF
• Liniile 47 și 83: calea fișierelor către imaginile capturate prin intermediul camerei Pi

6. Dacă este necesar, actualizați etichetele modelului din cod pentru a se potrivi exact cu etichetele din modelul Lobe (inclusiv majuscule, punctuație etc.):

• Linia 57: „gunoi”
• Linia 60: „reciclează”
• Linia 63: „compost”
• Linia 66: „instalația pentru deșeuri periculoase”
• Linia 69: "nu gunoi!"

7. Rulați programul folosind Python3 în fereastra terminalului:

python3 rpi_trash_classifier.py

Pasul 5: Testați-l: Rulați programul

Prezentare generală a programului

Când rulați programul pentru prima dată, va dura ceva timp pentru a încărca biblioteca TensorFlow și modelul Lobe ML. Când programul este gata să capteze o imagine, lumina de stare (LED alb) va pulsa.

Odată ce ați făcut o imagine, programul va compara imaginea cu modelul Lobe ML și va afișa predicția rezultată (linia 83). Ieșirea determină ce lumină este aprinsă: galben (gunoi), albastru (reciclare), verde (compost) sau roșu (deșeuri periculoase).

Dacă niciunul dintre LED-urile indicator nu se aprinde și LED-ul de stare revine în modul impuls, înseamnă că imaginea capturată nu a fost „gunoi”, cu alte cuvinte, refaceți fotografia!

Captarea unei imagini

Apăsați butonul pentru a captura o imagine. Rețineți că poate fi necesar să țineți apăsat butonul timp de cel puțin 1 s pentru ca programul să înregistreze presa. Este recomandat să faceți câteva imagini de testare, apoi să le deschideți pe desktop pentru a înțelege mai bine vizualizarea camerei și cadrul.

Pentru a permite utilizatorului timp pentru a poziționa obiectul și pentru ajustarea nivelurilor de lumină ale camerei, este nevoie de aproximativ 5 secunde pentru a capta complet o imagine. Puteți modifica aceste setări în cod (liniile 35 și 41), dar rețineți că Fundația Pi recomandă minimum 2 secunde pentru ajustarea nivelului de lumină.

Depanare

Cea mai mare provocare este să ne asigurăm că imaginea capturată este ceea ce ne așteptăm, așa că luați ceva timp pentru a revizui imaginile și a compara rezultatele așteptate cu ieșirea LED indicatoare. Dacă este necesar, puteți trece imagini la modelul Lobe ML pentru inferență directă și comparație mai rapidă.

Câteva lucruri de reținut:

• Biblioteca TensorFlow va lansa probabil câteva mesaje de avertizare - acest lucru este tipic pentru versiunea utilizată în acest exemplu de cod.
• Etichetele de predicție trebuie să fie exact așa cum sunt scrise în funcția led_select (), inclusiv scrierea cu majuscule, punctuația și spațiul. Asigurați-vă că le schimbați dacă aveți un model de lob diferit.
• Pi necesită o sursă de alimentare constantă. Lumina de alimentare a lui Pi trebuie să fie strălucitoare, roșie continuă.
• Dacă unul sau mai multe LED-uri nu se aprind când vă așteptați, verificați forțându-le cu comanda:

red_led.on ()

Pasul 6: (Opțional) Construiți-l: finalizați-vă circuitul

Acum, că am testat și, dacă este necesar, am depanat proiectul nostru, astfel încât acesta să funcționeze conform așteptărilor, suntem gata să lipim circuitul nostru!

Notă: Dacă nu aveți un fier de lipit, puteți sări peste acest pas. O alternativă este acoperirea conexiunilor de sârmă cu adeziv fierbinte (această opțiune vă va permite să reparați / adăugați / utilizați lucrurile mai târziu, dar este mai probabil să se rupă), sau să utilizați epoxidic sau un adeziv permanent similar (această opțiune va fi mult mai durabilă dar nu veți putea folosi circuitul sau potențialul Pi după ce faceți acest lucru)

Comentariu rapid despre alegerile mele de proiectare (Foto 1):

• Am optat pentru fire jumper de sex feminin pentru LED-uri și Pi GPIO, deoarece îmi permit să îndepărtez LED-urile și să schimb culorile sau să le mișc, dacă este necesar. Puteți sări peste acestea dacă doriți să faceți conexiunile permanente.
• În mod similar, am ales un conector JST pentru buton.

Înainte de a construi

1. Tăiați fiecare jumătate a firelor jumperului (da, toate!). Folosind decapanti de sârmă, îndepărtați aproximativ 1/4 (1/2 cm) din izolația firului.

2. Pentru fiecare dintre LED-uri, lipiți un rezistor de 220Ω la piciorul negativ (mai scurt). (Foto 2)

3. Tăiați o bucată mică, aproximativ 1 (2cm) de tub termocontractabil și împingeți joncțiunea LED și rezistență. Asigurați-vă că celălalt picior al rezistorului este accesibil, apoi încălziți tubul termocontractabil până când fixează articulația. (Foto 3)

4. Introduceți fiecare LED într-o pereche de fire jumper. (Foto 4)

5. Etichetați firele jumperului (de exemplu, cu bandă), apoi lipiți firele jumperului pe placa dvs. de circuit imprimat (PCB). (Foto 5)

6. Apoi, utilizați un fir jumper (tăiat) de sex feminin pentru a conecta fiecare LED la pinul GPIO respectiv. Lipiți și etichetați un fir jumper astfel încât metalul gol să se conecteze la piciorul LED pozitiv prin PCB. (Foto 5)

Notă: Unde ați lipit acest fir va depinde de aspectul PCB-ului dvs. De asemenea, puteți lipi acest fir direct pe firul jumper cu LED pozitiv.

7. Lipiți un rezistor de 220Ω la capătul negativ (negru) al conectorului JST. (Foto 6)

8. Lipiți conectorul și rezistența JST la buton. (Foto 6)

9. Conectați firele jumperului M-la-F între conectorul butonului și pinii GPIO (memento: negru este GND).

10. Îmbrăcați conexiunile PCB în clei fierbinte sau epoxidic pentru o conexiune mai sigură.

Notă: dacă alegeți să utilizați epoxidici, este posibil să nu puteți utiliza pinii GPIO ai lui Pi pentru alte proiecte în viitor. Dacă sunteți îngrijorat de acest lucru, adăugați un cablu panglică GPIO și conectați firele jumperului la acesta.

Pasul 7: (Opțional) Construiește-l: Carcasă

Creați o carcasă pentru Pi, care va ține camera, butonul și LED-urile în poziție, protejând totodată Pi. Proiectați-vă propria carcasă sau urmați instrucțiunile noastre de construcție de mai jos pentru a prototipa rapid o carcasă din carton!

1. În partea de sus a micii cutii de carton, urmăriți locațiile pentru buton, indicatorul de stare, luminile de identificare și fereastra camerei pi (Foto 1).

   Notă: Fereastra camerei Pi trebuie să aibă aproximativ 3/4 "x 1/2"

2. Folosind cuțitul de precizie, tăiați urmele.

   Notă: poate doriți să testați dimensiunile pe măsură ce mergeți (Foto 1)

3. Opțional: vopsiți carcasa! Am optat pentru vopsea spray:)
4. Tăiați un capac dreptunghiular de „fereastră” pentru Camera Pi (Foto 4) și lipiți pe interiorul cutiei

5. În cele din urmă, decupați slotul pentru cablul de alimentare Pi.

   Recomandat să instalați mai întâi toate componentele electronice pentru a găsi cel mai bun loc pentru slotul cablului de alimentare pi

Pasul 8: Instalați și implementați

Asta e! Sunteți gata să instalați și să vă implementați proiectul! Așezați carcasa deasupra coșurilor de gunoi, conectați Pi și rulați programul pentru a obține un mod mai rapid și mai fiabil de reducere a deșeurilor noastre. Yay!

Mergand inainte

• Împărtășiți proiectele și ideile dvs. cu alte persoane prin intermediul comunității Lobe Reddit!
• Consultați repoziția Lobe Python GitHub pentru o prezentare generală despre modul de utilizare a Python pentru a implementa o varietate mai largă de proiecte Lobe
• Întrebări sau cereri de proiect? Lasă un comentariu la acest proiect sau contactează-ne direct: [email protected]