Apprendimento automatico e Reti Neurali - pagina 40

[MetaQuotes]

Demo del tracciamento dei veicoli e della stima della velocità al 2° AI City Challenge Workshop nel CVPR 2018

Demo del tracciamento dei veicoli e della stima della velocità al 2° AI City Challenge Workshop nel CVPR 2018

Il nostro team dell'Università di Washington è il vincitore del Track 1 (Traffic Flow Analysis) al 2nd AI City Challenge Workshop in CVPR 2018.

I set di dati per la seconda AI City Challenge (2018) non sono più disponibili al pubblico. Tuttavia, puoi ancora accedere ai set di dati della 3a AI City Challenge (2019) o partecipare all'ultima 4a AI City Challenge in CVPR 2020.

Hanno fornito un nuovo set di dati su scala urbana per il tracciamento di veicoli con più telecamere e per la reidentificazione basata su immagini. Avevano anche un nuovo set di dati per il rilevamento delle anomalie del traffico. La portata dei set di dati e il numero di veicoli utilizzati per la valutazione sono entrambi senza precedenti. Il sito web di AI City Challenges è https://www.aicitychallenge.org/.

Codice: https://github.com/zhengthomastang/2018AICity_TeamUW

[MetaQuotes]

Roadmap per la visione artificiale | Come diventare un ingegnere di visione artificiale

Roadmap per la visione artificiale | Come diventare un ingegnere di visione artificiale

Questo video fornisce una tabella di marcia per diventare un ingegnere di visione artificiale, suddividendo il processo di apprendimento in quattro moduli: Python e OpenCV, robotica e programmazione di basso livello, intelligenza artificiale e argomenti avanzati. Viene sottolineata l'importanza di progetti pratici che coinvolgono dispositivi fisici come robotica e Arduino, insieme alla necessità di avere una conoscenza di base della matematica. Il relatore discute anche di concorsi e progetti che possono aiutare gli aspiranti ingegneri della visione artificiale ad affinare le proprie capacità. Inoltre, viene evidenziata l'importanza delle competenze trasversali come la documentazione e la conoscenza di strumenti software come Git e Docker. Infine, si consiglia di conseguire lauree in matematica, scienze dei dati, informatica o ingegneria, sebbene sia possibile anche l'apprendimento autonomo attraverso progetti e corsi.

• 00:00:00 In questa sezione del video, il relatore presenta una tabella di marcia per la visione artificiale che copre tutto ciò di cui una persona ha bisogno per imparare a diventare uno sviluppatore di visione artificiale. La tabella di marcia risponde a tre domande principali: quali competenze sono richieste, su quali progetti puoi lavorare per acquisire queste competenze e quali diplomi universitari sono disponibili per l'apprendimento di queste competenze. La roadmap è suddivisa in quattro modelli, con il primo modello che copre Python e OpenCV, essenziali per risolvere il 70% dei problemi di visione artificiale. Il secondo modello riguarda la robotica e la programmazione di basso livello, che include il lavoro con C++ e l'elettronica. Il terzo e il quarto modello riguardano rispettivamente l'intelligenza artificiale e argomenti avanzati. Il relatore suggerisce progetti per principianti per ogni modello, come lavorare su un robot seguace di linea o un lettore di codici QR per sviluppare conoscenze e abilità.
  
  
• 00:05:00 In questa sezione del video, il relatore discute l'importanza di lavorare su progetti che coinvolgono dispositivi fisici come robotica e Arduino. Il relatore spiega che la programmazione per tali dispositivi richiede un approccio diverso perché lo stesso codice può produrre risultati diversi a causa di fattori come il rumore del sensore e le variazioni di illuminazione. Il terzo modulo menzionato dal relatore si concentra sull'intelligenza artificiale e l'apprendimento automatico utilizzando la popolare libreria Python Scikit-learn, che può essere utilizzata per attività come la classificazione delle immagini e il rilevamento di oggetti. Infine, il relatore sottolinea anche l'importanza di avere una conoscenza di base della matematica e di come si collega alla visione artificiale.
  
  
• 00:10:00 In questa sezione, il relatore spiega l'importanza di dividere l'ambiente in diverse regioni e come può essere utilizzato per rilevare situazioni come gli incroci di corsia mentre mostra una semplice immagine con diverse regioni separate dalla geometria di base. Sottolinea la necessità che gli ingegneri della visione artificiale siano fluenti in matematica e raccomanda di apprendere le basi della classificazione delle immagini e del rilevamento degli oggetti, l'apprendimento segreto e la geometria, prima di passare a competenze più avanzate in apprendimento automatico, matematica ed elettronica. Suggerisce progetti come le reti generative avversarie e l'implementazione di documenti all'avanguardia nella visione artificiale per apprendere l'apprendimento automatico avanzato, intraprendendo progetti Arduino avanzati o partecipando a concorsi di robotica per migliorare la conoscenza dell'elettronica.
  
  
• 00:15:00 In questa sezione, il relatore discute vari concorsi e progetti che possono aiutare gli aspiranti ingegneri della visione artificiale ad affinare le proprie capacità. Queste competizioni prevedono la costruzione di robot e agenti in grado di eseguire compiti complessi e competere con altri team. Il relatore sottolinea l'importanza di apprendere i fondamenti della visione artificiale, inclusi Python e OpenCV, che possono aiutare a risolvere il 70% dei problemi disponibili. I quattro moduli menzionati sono: fondamenti, robotica, intenzioni artificiali e moduli avanzati. Sebbene il modulo avanzato sia importante, il relatore suggerisce di concentrarsi prima sugli altri moduli, poiché coprono le competenze essenziali necessarie per diventare un ingegnere di visione artificiale di successo.
  
  
• 00:20:00 In questa sezione, il relatore discute le varie competenze relative al software che uno sviluppatore di visione artificiale dovrebbe avere, oltre a conoscere la visione artificiale, l'apprendimento automatico e Python. Queste competenze includono la conoscenza delle basi di strumenti come Git e Docker, nonché fornitori di servizi cloud come AWS o Google Cloud. Competenze aggiuntive considerate preziose includono lo sviluppo web o mobile, la conoscenza di JavaScript e la capacità di scrivere una documentazione adeguata come un file readme per un repository GitHub o la documentazione di un intero processo. Sebbene non tutte queste abilità siano indispensabili, possono essere utili per mostrare il lavoro di uno sviluppatore e risolvere vari problemi.
  
  
• 00:25:00 In questa sezione, il relatore sottolinea l'importanza della documentazione per gli sviluppatori di visione artificiale in quanto rende le cose più semplici per tutti. Suggeriscono inoltre che ogni sviluppatore, non solo gli sviluppatori di visione artificiale, dovrebbe padroneggiare la documentazione in quanto è un'abilità cruciale. Il relatore sottolinea quindi l'importanza di avere familiarità con vari strumenti software e incoraggia gli aspiranti ingegneri della visione artificiale a imparare il più possibile. Per coloro che sono interessati a conseguire una laurea, il relatore consiglia lauree in matematica, scienze dei dati, informatica, ingegneria elettrica o qualsiasi laurea in ingegneria, in quanto forniscono le basi per affrontare i problemi e trovare soluzioni. Tuttavia, il relatore osserva che è del tutto possibile imparare tutto in modo indipendente seguendo progetti e corsi.

[MetaQuotes]

CLASSIFICAZIONE IMMAGINE con set di dati personalizzato Yolov8 | Esercitazione sulla visione artificiale

Codice: https://github.com/computervisioneng/image-classification-yolov8

CLASSIFICAZIONE IMMAGINE con set di dati personalizzato Yolov8 | Esercitazione sulla visione artificiale

In questa sezione, il presentatore spiega come scegliere il modello migliore per il progetto e fornisce suggerimenti tra la scelta dell'ultimo modello prodotto dal processo di formazione o la selezione del modello con la massima precisione. La decisione dipende da vari fattori, tra cui dati, problema, caso d'uso e processo di formazione. Il relatore spiega anche come fare tutte le inferenze e prevedere nuovi campioni importando YOLO e specificando il percorso assoluto del modello, utilizzando un'immagine dal computer locale e mostrando i risultati. I risultati forniscono molte informazioni, comprese le probabilità e i nomi delle categorie su cui è stato addestrato il classificatore di immagini.

• 00:00:00 In questa sezione, lo YouTuber dimostra come creare un classificatore di immagini utilizzando YOLOv8 su un set di dati personalizzato. Inizia mostrando il set di dati, che include immagini di nuvole, pioggia, sole e albe. Spiega anche la struttura del file che YOLOv8 si aspetta per l'inserimento dei dati. Felipe procede quindi a spiegare tre diversi modi per addestrare un classificatore di immagini utilizzando YOLOv8: il primo utilizza uno script Python, il secondo utilizza un Google Colab Notebook e il terzo utilizza darknet, che è il framework sottostante per YOLOv8.
  
  
• 00:05:00 In questa sezione, il tutorial esamina le dipendenze necessarie per addestrare un modello di classificazione delle immagini utilizzando Yolov8 e come installarle utilizzando l'interprete Python in PyCharm. I due pacchetti principali necessari sono Ultralytics e NumPy, con Ultralytics cruciale nell'importazione dei dati necessari per addestrare il modello. L'esercitazione esamina quindi il codice necessario per addestrare il modello e richiede l'impostazione del percorso assoluto dei dati nel formato corretto. Viene eseguita anche una corsa di prova per una sola epoca per garantire che tutto funzioni correttamente prima di continuare con l'ulteriore formazione.
  
  
• 00:10:00 In questa sezione, il relatore mostra dove si trovano i risultati del processo di formazione e spiega la struttura delle cartelle all'interno della cartella corse. Quindi dimostra come addestrare un classificatore di immagini utilizzando Yolov8 attraverso la riga di comando utilizzando un'utilità specifica e gli argomenti necessari. Procede a mostrare la semplicità di questo approccio addestrando il modello per una sola epoca, quindi mostra dove vengono salvati i risultati in una nuova directory denominata "trained 13". Infine, il relatore discute un altro modo per addestrare il modello utilizzando Google Collab e fornisce una breve spiegazione del processo per configurarlo.
  
  
• 00:15:00 In questa sezione, il presentatore mostra un taccuino che è già stato creato per addestrare i modelli Yolov8 chiamato "train.ipymb". Il caricamento di set di dati su Google Drive è un passaggio essenziale per consentire agli utenti di accedere ai propri dati da Google Collab poiché il processo richiede agli utenti di eseguire una cella che collega Google Collab con Google Drive. Conoscere il percorso del set di dati di un utente in Google Drive è fondamentale poiché gli utenti devono inserire questo percorso nei propri taccuini per utilizzare correttamente i propri set di dati. Infine, il presentatore fornisce semplici comandi che gli utenti possono eseguire per installare le librerie necessarie per addestrare i modelli Yolov8.
  
  
• 00:20:00 In questa sezione del video, l'istruttore mostra come addestrare un classificatore di immagini utilizzando YOLOv8 e un set di dati personalizzato e come copiare i risultati ottenuti in un ambiente Google Colab su Google Drive. Eseguono il processo di addestramento per un'epoca, copiano i risultati su Google Drive e quindi eseguono il processo di addestramento per 20 epoche. Infine, mostrano come analizzare se il processo di formazione ha portato a un buon classificatore di immagini. L'istruttore sottolinea l'importanza di impostare correttamente la variabile della directory dei dati e suggerisce di copiare i risultati in Google Drive per semplificare il download e l'analisi.
  
  
• 00:25:00 In questa sezione vengono analizzati i risultati del processo di addestramento per un set di dati personalizzato utilizzando YOLOv8. Vengono esaminati i file salvati nel computer locale, incluso un file di configurazione che elenca tutti i parametri EPA utilizzati durante il processo di addestramento e un file dei risultati che include la perdita di addestramento e convalida, nonché l'accuratezza. È stato utilizzato un file Python che traccia la perdita e l'accuratezza in epoche diverse per determinare se la perdita sta diminuendo e se l'accuratezza sta aumentando durante il processo di addestramento. Si conclude che un approccio semplice ma potente consiste nel verificare se la perdita di addestramento e la perdita di convalida stanno diminuendo mentre l'accuratezza sta aumentando.
  
  
• 00:30:00 In questa sezione, l'oratore spiega come appare l'accuratezza della valutazione quando aumentiamo il numero di epoche, mostrando che l'accuratezza aumenta e poi si stabilizza. Diversi parametri e una formazione più personalizzata potrebbero essere utilizzati per migliorare il processo per ottenere un modello migliore. Viene anche spiegata la directory "weights", dove sono salvati due diversi file: "last.pt" e "best.pt". Il file "last.pt" è il modello prodotto alla fine dell'ultima epoca del training, mentre il file "best.pt" è il modello prodotto alla fine dell'ultima epoca del training. In pratica, l'ultimo modello verrebbe utilizzato per ottenere i risultati finali.
  
  
• 00:35:00 In questa sezione, il relatore discute su come scegliere il modello migliore per il progetto e fornisce suggerimenti tra la scelta dell'ultimo modello prodotto dal processo di formazione o la selezione del modello con la massima precisione. La decisione dipende da vari fattori, tra cui dati, problema, caso d'uso e processo di formazione. Il relatore spiega anche come fare tutte le inferenze e prevedere nuovi campioni importando YOLO e specificando il percorso assoluto del modello, utilizzando un'immagine dal computer locale e mostrando i risultati. I risultati forniscono molte informazioni, comprese le probabilità e i nomi delle categorie su cui è stato addestrato il classificatore di immagini.
  
  
• 00:40:00 In questa sezione del video, il presentatore spiega come utilizzare un dizionario per identificare le classificazioni di un'immagine utilizzando YOLOv8. I risultati del classificatore di immagini sono numeri interi corrispondenti a diverse categorie e viene utilizzato un dizionario per identificare quale categoria rappresenta ciascun numero intero. Inoltre, si ottiene il vettore di probabilità di tutte le diverse classi per una data immagine e il presentatore dimostra come identificare la probabilità massima e la categoria corrispondente utilizzando numpy. Il presentatore conclude mostrando come classificare un'immagine utilizzando il modello YOLOv8 e suggerisce di iscriversi al loro canale per ulteriori progetti di ingegneria della visione artificiale.
  

[MetaQuotes]

Addestra il rilevamento di oggetti Yolov8 su un set di dati personalizzato | Guida passo passo | Esercitazione sulla visione artificiale

Codice: https://github.com/computervisioneng/train-yolov8-custom-dataset-step-by-step-guide

Addestra il rilevamento di oggetti Yolov8 su un set di dati personalizzato | Guida passo passo | Esercitazione sulla visione artificiale

Questo tutorial video fornisce una guida dettagliata su come addestrare un rilevatore di oggetti utilizzando YOLOv8 su un set di dati personalizzato per applicazioni di visione artificiale. Il tutorial copre aspetti importanti come la raccolta dei dati, l'annotazione, la formattazione e l'addestramento, nonché l'importanza dell'analisi dei grafici delle funzioni di perdita e degli esempi di vita reale per valutare le prestazioni del modello. Il tutorial enfatizza l'uso dello strumento CVAT per l'annotazione, l'adesione al formato dati YOLOv8 richiesto e la creazione di un file YAML di configurazione. Il tutorial dimostra anche l'utilizzo di Google Colab e PyCharm per addestrare e testare il rilevatore di oggetti.

Il video mostra le prestazioni di un modello di rilevamento di oggetti YOLOv8 addestrato su un set di dati di alpaca. L'oratore utilizza uno script Python per caricare video ed eseguire previsioni, mostrando un rilevamento quasi perfetto in alcuni casi e un rilevamento stabile in altri, con alcuni rilevamenti mancati in un video. Il relatore consiglia di analizzare le funzioni di perdita di addestramento e convalida e di decidere se c'è margine di miglioramento prima di addestrare nuovamente il modello per ottenere un modello più potente e con prestazioni migliori.

• 00:00:00 In questa sezione del video, il presentatore spiega l'importanza della raccolta di dati durante l'addestramento di un rilevatore di oggetti utilizzando YOLOv8, nonché i diversi modi in cui è possibile raccogliere dati, ad esempio scattare le proprie fotografie o utilizzare un set di dati disponibile pubblicamente come il set di immagini aperte. Il presentatore utilizza un set di dati di alpaca a scopo dimostrativo e agli spettatori vengono mostrati esempi delle immagini contenute nel set di dati. Inoltre, il presentatore afferma di poter fornire agli spettatori script per scaricare e formattare i dati dal set di immagini aperte esattamente nel modo necessario per il tutorial.
  
  
• 00:05:00 In questa sezione del video, il narratore discute il processo di annotazione dei dati utilizzando lo strumento CVAT, che è uno strumento di etichettatura che può essere utilizzato per il rilevamento di oggetti e le attività di annotazione relative alla visione artificiale. Il narratore dimostra come utilizzare lo strumento CVAT per annotare un set di immagini per un set di dati personalizzato, spiegando come creare un nuovo progetto e attività, caricare immagini e aggiungere etichette per gli oggetti da rilevare. Sebbene il narratore disponga già delle annotazioni per le immagini utilizzate, fornisce una guida passo passo per coloro che devono annotare i propri dati. Il video evidenzia anche i vantaggi e gli svantaggi dei diversi strumenti di annotazione sottolineando i vantaggi dell'utilizzo di CVAT.
  
  
• 00:10:00 In questa sezione, il creatore di video mostra come etichettare gli oggetti su un set di dati immagine per il rilevamento degli oggetti utilizzando l'algoritmo YOLOv8. Il creatore utilizza immagini di alpaca e dimostra come racchiudere l'oggetto in una scatola di legame, consentendo all'algoritmo di rilevare e identificare gli oggetti. Spiegano inoltre l'importanza di annotare i propri dati per avere maggiore familiarità con le diverse situazioni che possono sorgere durante l'annotazione e fornire chiarezza sugli oggetti rilevati. Il creatore osserva che mentre l'annotazione dei dati può essere eseguita utilizzando servizi esterni, è fondamentale annotare personalmente alcune delle immagini per una migliore comprensione dei dati.
  
  
• 00:15:00 In questa sezione viene discussa l'importanza dei criteri per l'annotazione delle immagini, con l'esempio di un set di dati di alpaca. Vengono inoltre mostrati i diversi modi di definire i riquadri di delimitazione per gli oggetti, incluso l'adattamento del riquadro all'oggetto o l'utilizzo di un riquadro di delimitazione più rilassato. Lo strumento di annotazione cb80 è evidenziato come un'applicazione Web utile e facile da usare per la formattazione e l'annotazione dei dati, sottolineando l'importanza dell'annotazione dei dati nell'addestramento degli algoritmi di rilevamento degli oggetti.
  
  
• 00:20:00 In questa sezione del video, il presentatore spiega il formato dati specifico richiesto per YOLOv8 per addestrare un rilevatore di oggetti. Ogni algoritmo nell'apprendimento automatico ha i propri requisiti di input dei dati e YOLO ha bisogno dei dati in un formato molto specifico. Il presentatore dimostra come esportare dati annotati da CV80 e convertirli in formato YOLO. Il formato YOLO richiede che le annotazioni e le immagini corrispondenti abbiano lo stesso nome e diverse estensioni di file, con ogni annotazione del riquadro di delimitazione contenente un numero di classe e quattro numeri float che definiscono la posizione centrale, la larghezza e l'altezza del riquadro di delimitazione. Si sottolinea che avere i dati nel formato corretto è fondamentale per l'addestramento di un rilevatore di oggetti.
  
  
• 00:25:00 In questa sezione, il relatore spiega come strutturare i dati per l'addestramento al rilevamento degli oggetti utilizzando YOLOv8 su un set di dati personalizzato. Il primo passaggio consiste nel creare due directory: una per le immagini e una per le etichette, con nomi di directory specifici che non possono essere modificati. All'interno della directory delle immagini, dovrebbero essere posizionate tutte le immagini che verranno utilizzate per l'addestramento e, per comodità, è possibile utilizzare una directory dei treni. All'interno della directory delle etichette, dovrebbero essere presenti file di annotazione per ogni immagine, seguendo un formato standard in cui ogni riga specifica l'ID classe, la posizione X/Y del centro del riquadro di delimitazione e la larghezza e l'altezza del riquadro di delimitazione. Il relatore spiega anche come utilizzare directory aggiuntive per la convalida o i dati di test o per diverse versioni dei dati.
  
  
• 00:30:00 In questa sezione, il video tutorial discute il processo di addestramento del tuo rilevatore di oggetti con YOLO V8 utilizzando Python o l'utilità della riga di comando. Il repository ufficiale YOLO V8 offre la possibilità di allenarsi con poche istruzioni Python o eseguendo un comando nel terminale. Il tutorial passa quindi attraverso una guida passo passo su come addestrare un rilevatore di oggetti utilizzando YOLO V8 in un progetto PyCharm, inclusa l'importazione della libreria Ultralytics e la creazione di un file YAML di configurazione. Il tutorial evidenzia inoltre che gli utenti possono scegliere tra lavorare in un ambiente locale o Google Colab.
  
  
• 00:35:00 In questa sezione del video, il relatore discute il file di configurazione per l'addestramento di un rilevatore di oggetti utilizzando YOLO V8 su un set di dati personalizzato. Spiegano come impostare i nomi delle diverse classi rilevate, il percorso assoluto della directory contenente le immagini e le annotazioni e il percorso relativo in cui si trovano le immagini. Il relatore cita anche le due parole chiave "treno" e "val" che si riferiscono rispettivamente ai dati di addestramento e di validazione. Sottolineano l'importanza di utilizzare un percorso assoluto invece di un percorso relativo per evitare qualsiasi problema. L'oratore mostra quindi come eseguire il file e inizia il processo di addestramento per un'epoca, sottolineando la necessità di attendere fino al completamento del processo. Infine, mostrano i file di output generati al termine del processo di addestramento.
  
  
• 00:40:00 In questa sezione del video tutorial, il relatore mostra i batch di immagini utilizzati per addestrare l'algoritmo di rilevamento degli oggetti YOLOv8, nonché immagini simili per la convalida. L'oratore spiega che stanno conducendo un addestramento superficiale e fittizio e mostrano i file utilizzati a tale scopo. Il relatore mostra quindi come addestrare l'algoritmo dalla riga di comando utilizzando il terminale e anche da un taccuino collaborativo di Google. Il notebook è composto solo da cinque celle e l'oratore dimostra quanto sia semplice caricare dati, montare Google Drive e addestrare l'algoritmo semplicemente specificando il percorso relativo alla posizione dei dati.
  
  
• 00:45:00 In questa sezione, il video tutorial mostra come utilizzare Google Colab per addestrare un rilevatore di oggetti YOLOv8 su un set di dati personalizzato. Il processo prevede il salvataggio di una variabile specifica e l'esecuzione del comando "pip install ultralytics" nell'ambiente Google Colab tramite il comando punto esclamativo. Il tutorial mostra come inserire le stesse righe di codice utilizzate nell'ambiente locale e come specificare un percorso assoluto alla directory di Google Drive. Una volta caricati i file ed eseguiti i comandi, il processo di addestramento è simile a quello nell'ambiente locale. Il tutorial indica agli utenti di attendere il completamento dell'esecuzione e ricordarsi di eseguire il comando che copia la directory dei risultati nella directory scelta in Google Colab.
  
  
• 00:50:00 In questa sezione, il video tutorial si concentra sul test delle prestazioni del rilevatore di oggetti Yolov8 che è stato addestrato su un set di dati personalizzato. Il primo passaggio per testare il modello prevede l'accesso alla directory in cui sono state salvate tutte le informazioni relative al processo di addestramento. Il video mostra quindi diversi output e grafici che possono essere utilizzati per analizzare le prestazioni del modello, tra cui matrici di confusione, curve di confidenza F1 e grafici della funzione di perdita. Il video consiglia di concentrarsi sui grafici delle perdite, assicurandosi che tutte le perdite stiano diminuendo, in quanto questo è un modo semplice ma potente per analizzare le prestazioni del modello. Vengono inoltre discusse diverse situazioni nei grafici della funzione di perdita, come una funzione di perdita flatlining, che potrebbe indicare che il modello ha appreso tutto ciò di cui aveva bisogno per imparare.
  
  
• 00:55:00 In questa sezione del video, il relatore discute l'analisi della funzione di perdita per ottenere informazioni sul processo di addestramento di un modello di rilevamento di oggetti. Se la funzione di perdita scende, tutto va bene, ma se sale, c'è un problema con l'allenamento. Guardare i grafici e analizzare queste informazioni riguarda più la ricerca, ma il relatore propone un modo più visivo per valutare le prestazioni del modello, ovvero guardare esempi reali e vedere come si comporta il modello su dati reali. Il presentatore mostra esempi del modello che rileva alpaca nella vita reale nei video, che sono dati completamente invisibili per testare le prestazioni del modello. Anche se i risultati non sono perfetti, le prestazioni sono buone e il presentatore sostiene che questa valutazione visiva è più rilevante per un libero professionista che lavora al progetto di un cliente poiché al cliente potrebbe non interessare le trame e le metriche, ma piuttosto desidera vedere come il il modello esegue su dati reali.

• 01:00:00 In questa sezione, il relatore dimostra le prestazioni del modello di rilevamento degli oggetti YOLOv8 addestrato su un set di dati di alpaca su dati invisibili attraverso uno script Python che carica video ed esegue previsioni. I rilevamenti sembrano funzionare bene, con un rilevamento quasi perfetto in alcuni casi e un rilevamento stabile in altri, ad eccezione di alcuni rilevamenti mancati in un video. Il relatore consiglia di analizzare le funzioni di perdita di addestramento e convalida, controllando la loro tendenza al ribasso e l'esistenza di margini di miglioramento per decidere se addestrare nuovamente il modello, che è ciò che fa il relatore per ottenere un modello più potente e più performante.

[MetaQuotes]

Rilevamento oggetti Yolov8 + tracciamento oggetti deep sort | Esercitazione sulla visione artificiale

Codice: https://github.com/computervisioneng/object-tracking-yolov8-deep-sort

Rilevamento oggetti Yolov8 + tracciamento oggetti deep sort | Esercitazione sulla visione artificiale

Questo tutorial video mostra come implementare un sistema di rilevamento e tracciamento degli oggetti utilizzando YOLOv8 e deep sort. Il relatore passa attraverso il processo passo dopo passo, dall'impostazione dell'ambiente, al caricamento e al rilevamento di oggetti in un video utilizzando YOLOv8, al monitoraggio degli oggetti rilevati nel tempo utilizzando il deep sort. Spiegano anche l'importanza di creare la corretta struttura dei file e installare le dipendenze necessarie. Una volta estratti i rilevamenti da YOLOv8, viene applicato il monitoraggio degli oggetti Deep Sort per tenere traccia degli oggetti rilevati nel tempo. Infine, il presentatore spiega come salvare i frame di output finali in un file video e incoraggia gli spettatori a modificare la soglia di rilevamento per una maggiore precisione.

• 00:00:00 In questa sezione del video, l'host introduce il progetto di lavorare con il rilevamento degli oggetti utilizzando YOLOv8 e il tracciamento degli oggetti utilizzando il deep sort. L'obiettivo è creare un algoritmo di tracciamento in grado di tenere traccia delle persone che si muovono in un video e utilizzare riquadri di delimitazione di colori diversi per indicare gli oggetti monitorati. L'host mostra i repository YOLOv8 e deep sort che verranno utilizzati, nonché i dati video che verranno testati. Infine, l'host introduce un file chiamato "tracker.py", che è un wrapper per il deep sort che semplifica il processo di tracciamento degli oggetti utilizzando funzioni di alto livello.
  
  
• 00:05:00 In questa sezione del video, il presentatore spiega come configurare l'ambiente per il tutorial clonando il repository necessario, scaricando i file richiesti e importando le librerie necessarie. Spiegano l'importanza di creare la struttura di file corretta e installare le dipendenze corrette per garantire la compatibilità con il codice. Il presentatore mostra quindi come caricare un video e leggere i frame da esso utilizzando OpenCV e come mostrare i frame in una finestra.
  
  
• 00:10:00 In questa sezione, il relatore dimostra come utilizzare il modello pre-addestrato YOLOv8 per produrre rilevamenti su un video. Utilizzando Ultralytics, il modello pre-addestrato viene importato e la funzione viene richiamata su un fotogramma del video. I risultati del rilevamento dell'output vengono stampati, ma poiché i risultati si trovano in un tipo di oggetto personalizzato, devono essere scartati e trasformati in un elenco utilizzando un ciclo for. I rilevamenti dell'output finale vengono salvati in un nuovo oggetto. Una volta eseguito correttamente il codice, i risultati possono essere utilizzati come dati di input per gli algoritmi di tracciamento degli oggetti.
  
  
• 00:15:00 In questa sezione del video tutorial, il relatore mostra come scartare tutte le importanti informazioni di rilevamento dal rilevatore di oggetti YOLOv8 e tracciare gli oggetti rilevati utilizzando il monitoraggio degli oggetti Deep Sort. Mostrano come estrarre informazioni come l'ID della classe, il valore di confidenza e le coordinate per ogni rilevamento per trasmetterle all'algoritmo di tracciamento. Lo speaker mostra anche come inizializzare e richiamare il tracker Deep Sort con le rilevazioni e i frame in modo da tenere traccia nel tempo degli oggetti rilevati.
  
  
• 00:20:00 In questa sezione, il relatore spiega il processo di tracciamento di oggetti con ordinamento approfondito, che prevede il calcolo delle caratteristiche sopra l'inquadratura e gli oggetti rilevati. L'algoritmo ritaglia il fotogramma ed estrae le caratteristiche e, per scorrere tutte le tracce, il presentatore utilizza un ciclo per accedere al riquadro di delimitazione e all'ID della traccia. A ogni persona o oggetto rilevato nel video è assegnato un ID che rimane stabile in tutti i fotogrammi. Per ogni nuovo ID rilevato, il relatore lo traccia con un colore diverso utilizzando un elenco di colori casuali nella visualizzazione.
  
  
• 00:25:00 In questa sezione del video, l'oratore risolve il problema di salvare il video con tutti i diversi fotogrammi e rilevamenti sul computer locale. Viene creato un nuovo oggetto, CV2 video writer, per salvare il video con un nome e una posizione specificati. Il video viene salvato utilizzando un codec MP4 e lo stesso frame rate del video originale. L'oratore sottolinea che tutto funziona correttamente, anche se il rilevamento in tempo reale non viene raggiunto a causa dei numerosi oggetti caricati e dell'esecuzione eseguita su una CPU. Nel complesso, il problema del rilevamento degli oggetti tramite YOLOv8 e del tracciamento degli oggetti tramite Deep SORT è stato risolto con successo.
  
  
• 00:30:00 In questa sezione, il relatore conclude il tutorial esaminando i passaggi finali necessari per implementare con successo un sistema di rilevamento e tracciamento degli oggetti utilizzando YOLOv8 e deep sort. Dimostrano come salvare i frame di output in un file out.mp4 e ne mostrano il completamento con successo. Inoltre, il relatore menziona i possibili rilevamenti errati e incoraggia gli spettatori a modificare la soglia di rilevamento al fine di migliorare la precisione del sistema per il rilevamento di oggetti come gli uccelli. Nel complesso, questo tutorial funge da guida utile per chiunque desideri implementare un sistema di rilevamento e tracciamento degli oggetti utilizzando tecniche di visione artificiale.

[MetaQuotes]

Segmentazione delle immagini con set di dati personalizzato Yolov8 | Esercitazione sulla visione artificiale

Codice: https://github.com/computervisioneng/image-segmentation-yolov8

Dati: https://drive.google.com/drive/folders/1JvA2IvHBy2QOnAtPtoy4JbEEmtbz5dnK

Segmentazione delle immagini con set di dati personalizzato Yolov8 | Esercitazione sulla visione artificiale

Questo tutorial illustra il processo di annotazione delle immagini e la creazione di una maschera binaria per la segmentazione semantica, la formattazione e la strutturazione del set di dati per l'addestramento con YoloV8, l'addestramento del modello in Google Collab, l'analisi dei risultati dell'addestramento e l'esecuzione di previsioni utilizzando uno script Python. Il relatore sottolinea l'importanza di strutturare il file system e analizzare la funzione di perdita e le metriche di convalida per addestrare un buon modello per il set di dati personalizzato YoloV8. Discutono anche dell'impatto dei dati errati sulla qualità delle previsioni e raccomandano di utilizzare le previsioni del modello corrente per addestrarne uno nuovo e migliorato. Nel complesso, il tutorial fornisce una guida completa alla segmentazione delle immagini con il set di dati personalizzato YoloV8.

• 00:00:00 In questa sezione del video, l'istruttore mostra il set di dati che verrà utilizzato per la segmentazione semantica: un set di immagini di papere con le corrispondenti maschere binarie. La maschera binaria ha tutti i pixel bianchi per un oggetto nell'immagine e tutti i pixel neri per tutto il resto. L'istruttore scarica questo set di dati dalla versione 7 delle risorse di immagini aperte e mostra il sito Web cvat.ai nel caso in cui sia necessario annotare i propri dati di immagine. Quindi, l'istruttore mostra come utilizzare questo strumento per creare una maschera binaria per un'immagine in una sola annotazione dell'immagine.
  
  
• 00:05:00 In questa sezione del tutorial, il relatore mostra come annotare un'immagine e creare una maschera binaria per la segmentazione semantica. Usando l'immagine di un'anatra come esempio, guidano lo spettatore attraverso il processo di disegno di un poligono per creare la maschera attorno al corpo dell'anatra, inclusa una discussione sull'opportunità o meno di annotare alcune parti sotto l'acqua come parte dell'anatra. Il presentatore sottolinea che la maschera non deve essere perfetta al pixel, ma dovrebbe essere abbastanza precisa da creare una buona maschera. Infine, mostrano come salvare e scaricare i dati annotati per utilizzarli nella creazione di un set di dati.
  
  
• 00:10:00 In questa sezione, il relatore spiega come formattare e strutturare il set di dati per addestrare un modello di segmentazione semantica con YoloV8. Il primo passaggio consiste nel scaricare i dati richiesti utilizzando l'opzione Esporta set di dati attività e selezionando la maschera di segmentazione. Una volta scaricati, i dati devono essere organizzati in una struttura di directory contenente le immagini, le maschere e le etichette. Le maschere generate dalle immagini devono essere convertite in un diverso formato di file tramite uno script Python fornito dal relatore. Questo formato di file è richiesto da YoloV8 e contiene le stesse informazioni delle maschere binarie. Il relatore sottolinea anche l'importanza di strutturare il file system in un modo particolare in modo che YoloV8 possa trovare e utilizzare i dati.
  
  
• 00:15:00 In questa sezione, il presentatore spiega la struttura di directory necessaria per la segmentazione delle immagini con il set di dati personalizzato Yolov8. Gli utenti devono disporre di due directory: una denominata "train", che contiene tutti i dati di addestramento per il modello di segmentazione semantica, e l'altra denominata "ball", contenente le immagini che verranno utilizzate per convalidare il modello. All'interno di queste directory ci sono altre due directory -- "images" e "labels" -- che hanno entrambe due sottodirectory chiamate "train" e "ball". Il primo contiene tutte le annotazioni generate dalle maschere di addestramento. Il relatore imposta la struttura in pycharm e procede spiegando come addestrare il modello utilizzando un modello Yolov8 pre-addestrato da Ultralytics, inclusa l'implementazione del codice e la modifica del file di configurazione.
  
  
• 00:20:00 In questa sezione, il relatore spiega che il modello di segmentazione semantica viene addestrato in Google Collab grazie all'accesso a una GPU gratuita, rendendo il processo molto più veloce. Il relatore consiglia di caricare i dati, incluse directory e immagini, e il file config.yaml prima di iniziare il processo. Inoltre, il relatore mostra e spiega come eseguire ogni singola cella sul notebook Jupiter e condivide la posizione dei propri dati su Google Drive, incoraggiando l'utente a fare lo stesso durante il caricamento dei propri dati. Infine, il relatore menziona l'installazione di Ultralytics in modo che possano utilizzare YOLOv8 nel Notebook e sottolinea la garanzia dell'utilizzo di Google Collab con GPU durante il controllo del tipo di runtime.
  
  
• 00:25:00 In questa sezione del tutorial, il relatore addestra il modello per 10 epoche e salva i risultati nella cartella segment train 2. Il passaggio successivo consiste nell'analizzare i risultati dell'allenamento per verificare che tutto funzioni correttamente. Il modo più semplice per farlo è copiare tutto il contenuto nella directory in cui vengono salvati i risultati su Google Drive. Una volta scaricati i risultati su un computer locale, il relatore consiglia di concentrarsi sull'analisi dei grafici della funzione di perdita, della perdita di segmentazione, della perdita di addestramento e della perdita di convalida per assicurarsi che la funzione di perdita stia diminuendo. Questo è un buon segno che le cose stanno funzionando bene, mentre una funzione di perdita crescente indica un problema serio.
  
  
• 00:30:00 In questa sezione, il relatore parla dell'analisi della funzione di perdita e delle metriche di convalida per addestrare un buon modello per il set di dati personalizzato Yolov8. È un buon segno se la perdita di addestramento e convalida sta diminuendo, indicando una tendenza al miglioramento della qualità della previsione. Tuttavia, il relatore avverte che le annotazioni mancanti e altri difetti nei dati di addestramento possono influire sulla qualità della previsione, portando a tendenze impreviste nel grafico della funzione di perdita. Pertanto, il relatore consiglia di non impazzire analizzando questi grafici e di includere un'analisi delle previsioni per valutare le prestazioni complessive del modello.
  
  
• 00:35:00 In questa sezione, il relatore discute l'importanza di analizzare i risultati di convalida e valutazione di un modello addestrato su un set di dati, che non è perfetto e presenta errori. Questi errori possono essere risolti utilizzando le previsioni del modello corrente per addestrarne uno nuovo e migliorato. Il relatore mostra la directory in cui sono salvati i pesi del modello, spiegando che last.pt e best.pt rappresentano rispettivamente l'ultimo e il modello con le migliori prestazioni durante l'addestramento. Infine, il relatore consiglia di utilizzare less.pt poiché considera molte più informazioni rispetto al modello best.pt.
  
  
• 00:40:00 In questa sezione del video tutorial sulla segmentazione delle immagini con il set di dati personalizzato YOLOv8, il relatore mostra come fare previsioni utilizzando uno script Python. Inizia importando il pacchetto YOLO da Ultralytics e definisce il modello utilizzando less.pt dalla directory dei risultati. Quindi specifica il percorso dell'immagine e importa CV2 per aprire e leggere questa immagine. Il relatore ottiene i risultati del modello chiamando il modello sull'immagine e scorre i risultati per ottenere la maschera prevista. Ridimensiona la maschera alla dimensione dell'immagine originale e la salva come output.png. Il presentatore mostra anche come sovrapporre la maschera all'immagine originale per garantire una buona previsione.
  
  
• 00:45:00 In questa sezione, il relatore mostra il risultato del modello di segmentazione semantica che ha addestrato con YOLOv8. Utilizzando un'immagine sovrapposta e la trasparenza, mostrano che sebbene la maschera non sia perfetta al 100%, è un ottimo risultato considerando gli errori nei dati. Il relatore riassume quindi l'intero processo dall'annotazione dei dati, all'addestramento del modello, alla convalida fino all'elaborazione di previsioni. Infine, incoraggiano gli spettatori a iscriversi al proprio canale e a guardare altri video che hanno pubblicato.

[MetaQuotes]

Rilevamento di oggetti Tensorflow in 5 ore con Python | Corso completo con 3 progetti

Ottieni il codice Tensorflow Object Detection Python Course Code: https://github.com/nicknochnack/TFODCourse

App React per il rilevamento di oggetti Tensorflow: https://github.com/nicknochnack/TFODApp

Rilevamento di oggetti Tensorflow per Raspberry Pi: https://github.com/nicknochnack/TFODRPi

Rilevamento di oggetti Tensorflow in 5 ore con Python | Corso completo con 3 progetti

Parte 1

• 00:00:00 In questa sezione, l'istruttore introduce il corso di rilevamento di oggetti che ha lo scopo di portare i principianti assoluti nel rilevamento di oggetti a un livello avanzato come professionisti. Il corso è completo e copre l'installazione e la configurazione dell'API di rilevamento degli oggetti TensorFlow, la raccolta e l'etichettatura delle immagini, l'addestramento del modello, l'esportazione del modello di rilevamento in diversi formati e il test dei modelli su vari casi d'uso. Tutto il corso viene svolto utilizzando strumenti open source, principalmente Python e rilevamento di oggetti TensorFlow, che semplificano il riutilizzo del codice per rilevare vari oggetti. L'istruttore spiega anche i vantaggi dell'utilizzo dell'API di rilevamento degli oggetti TensorFlow, che accelera il processo di creazione dei modelli di rilevamento degli oggetti grazie alle varie funzionalità aggiuntive che fornisce.
  
  
• 00:05:00 In questa sezione, l'istruttore spiega la differenza tra la programmazione tradizionale e l'apprendimento automatico, dove invece di definire regole esplicite per rilevare gli oggetti, l'apprendimento automatico utilizza dati e risposte per addestrare un modello di rilevamento degli oggetti per apprendere le regole. Il modello può rilevare oggetti in immagini statiche e feed video in tempo reale e può essere esportato e convertito in diversi formati come tensorflow.js e tf lite utilizzando il congelamento e la conversione. L'ottimizzazione delle prestazioni è fondamentale per migliorare la precisione del modello e l'istruttore copre questo argomento nel passaggio sei. Infine, l'istruttore dimostra tre progetti, incluso l'utilizzo di un microscopio USB per rilevare difetti in piccole parti, rilevare oggetti in un videogioco e contare il numero di oggetti che passano attraverso una webcam.
  
  
• 00:10:00 In questa sezione, l'istruttore introduce i tre progetti che saranno trattati nel tutorial, che prevedono l'addestramento di un modello di rilevamento di oggetti per identificare i difetti nei circuiti stampati, rilevare i gesti delle mani e integrare il modello in un'app Web, e condurre il rilevamento di oggetti in tempo reale utilizzando un Raspberry Pi. L'istruttore fornisce tre set di codice su Github per ciascuno dei progetti, che verranno utilizzati per costruire i modelli passo dopo passo. Il primo passo è clonare il codice e creare un ambiente virtuale, che viene spiegato come una stanza separata in una casa. Questa sezione include anche suggerimenti utili per seguire il tutorial, come rivedere ogni passaggio prima di andare avanti, prendere appunti e chiedere aiuto se necessario tramite il server Discord fornito.
  
  
• 00:15:00 In questa sezione del video, l'istruttore spiega l'importanza di utilizzare un ambiente virtuale mentre si lavora con i modelli di rilevamento degli oggetti TensorFlow. Lo descrive come la creazione di una nuova stanza in una casa in cui sono installate tutte le dipendenze di rilevamento degli oggetti per garantire che non siano in conflitto con le librerie installate in precedenza. L'istruttore parla quindi delle dipendenze necessarie per lavorare con TensorFlow, inclusi Visual C++ Build Tools e CUDA e CUDNN per l'accelerazione basata su GPU. Spiega che queste librerie sono essenziali per una formazione più rapida dei modelli di rilevamento degli oggetti e mostra come scaricarle e installarle. Nel complesso, questa sezione fornisce una base essenziale necessaria per configurare un ambiente di sviluppo per la creazione di modelli di rilevamento degli oggetti TensorFlow.
  
  
• 00:20:00 In questa sezione del video tutorial, l'istruttore discute i requisiti necessari per l'installazione di TensorFlow Object Detection, incluse le versioni specifiche di Python, compilatore GCC, Bazel, CUDA e cuDNN necessarie. L'istruttore sottolinea che la corrispondenza delle versioni di TensorFlow, CUDA e cuDNN è essenziale per l'utilizzo delle GPU durante l'addestramento. Forniscono collegamenti alle guide all'installazione per Windows e Linux/macOS e consigliano agli utenti di controllare la propria versione di TensorFlow e ottenere le versioni CUDA e cuDNN appropriate. Inoltre, l'istruttore afferma di aver creato una guida agli errori per problemi comuni che si verificano durante l'installazione o durante l'esecuzione del notebook di rilevamento degli oggetti. La guida include soluzioni a diversi errori e può essere trovata nel collegamento al repository GitHub fornito.
  
  
• 00:25:00 In questa sezione, l'istruttore mostra come configurare un ambiente virtuale per il rilevamento di oggetti TensorFlow utilizzando Python. Indica i passaggi da seguire per creare l'ambiente, che prevede la clonazione di un repository con il codice e le dipendenze necessarie, la creazione di un ambiente virtuale utilizzando il pacchetto venv di Python e l'attivazione dell'ambiente. La creazione di un ambiente virtuale è simile alla creazione di una nuova stanza in una casa, in cui è possibile isolare librerie e dipendenze per lavorare su progetti di rilevamento di oggetti TensorFlow in un ambiente isolato.
  
  
• 00:30:00 In questa sezione, il creatore del video illustra il processo di creazione di un ambiente virtuale per TensorFlow Object Detection (TFOD) al fine di mantenere separati l'addestramento, l'app e il codice Raspberry Pi. Il creatore del video esegue i passaggi per attivare l'ambiente virtuale, inclusa l'esecuzione di un comando su un computer Windows per attivare l'ambiente. C'è una dimostrazione dell'aggiornamento del programma di installazione pip e quindi dell'installazione di TensorFlow. Il vantaggio di questi aggiornamenti è la possibilità di vedere le installazioni in tempo reale all'interno della cartella dei pacchetti del sito. Si noti che a volte l'installazione di TensorFlow richiede più tentativi e il creatore del video dispone di uno script di verifica per garantire che tutto sia installato correttamente.
  
  
• 00:35:00 In questa sezione, il relatore spiega come installare i pacchetti necessari e configurare un ambiente virtuale con Jupyter Notebook utilizzando iPy Kernel. Forniscono inoltre istruzioni per l'installazione di Anaconda Python e Jupyter Notebook per coloro che sono nuovi. Quindi spiegano come installare iPy Kernel e associarlo a Jupyter Notebook per consentire un carico di lavoro di data science più efficiente. Infine, il relatore mostra come convalidare l'ambiente virtuale e iniziare a raccogliere ed etichettare le immagini come parte del passaggio successivo verso la creazione di un modello di rilevamento degli oggetti TensorFlow.
  
  
• 00:40:00 In questa sezione, l'istruttore sottolinea l'importanza di raccogliere ed etichettare buone immagini durante l'addestramento dei modelli di rilevamento degli oggetti. Per dimostrarlo, utilizza un taccuino Jupyter per raccogliere immagini da una webcam e la libreria LabelImg per etichettare le immagini. L'istruttore condivide le migliori pratiche da tenere a mente durante l'etichettatura, come mantenere le etichette il più strette possibile e includere immagini di oggetti da diverse angolazioni e in diverse condizioni di illuminazione. Un'altra best practice importante consiste nell'iniziare con 10-20 immagini di ogni classe, ma l'istruttore inizia con meno immagini e mostra come aggiungere ulteriori immagini per riaddestrare il modello se le prestazioni non sono ottimali. Infine, l'istruttore spiega che fornire al modello una varietà di immagini senza uno schermo verde dietro l'oggetto lo renderà più generalizzato e più in grado di rilevare gli oggetti.
  
  
• 00:45:00 In questa sezione, l'istruttore guida gli spettatori attraverso il componente di raccolta delle immagini del tutorial sul rilevamento degli oggetti TensorFlow. Il tutorial inizia con l'installazione di OpenCV, una popolare libreria di visione artificiale utilizzata per accedere alla webcam e raccogliere immagini. L'istruttore sottolinea l'importanza di garantire che le dipendenze vengano installate nell'ambiente virtuale per mantenere il controllo e garantire un funzionamento regolare. Il codice quindi importa le dipendenze necessarie tra cui UUID, sistema operativo e ora, che verranno utilizzate per garantire la conformità con diversi percorsi di file e acquisire immagini da diverse angolazioni. Il tutorial definisce quindi le diverse etichette da raccogliere e spiega che le etichette possono essere modificate in base agli oggetti desiderati da rilevare. Le etichette sono memorizzate in un elenco e l'istruttore spiega che il numero di immagini raccolte per ogni etichetta è definito dalla variabile "numero di immagini".
  
  
• 00:50:00 In questa sezione, l'istruttore discute l'impostazione della struttura delle cartelle per il rilevamento degli oggetti, l'importanza di disporre di un buon numero di immagini all'inizio e come acquisire immagini utilizzando una webcam o un altro dispositivo di acquisizione. La struttura delle cartelle viene creata utilizzando un percorso di file specifico che deve essere seguito durante l'esercitazione. Il codice scorre tutte le etichette, si collega alla webcam e acquisisce le immagini per ciascuna etichetta. L'istruttore sottolinea l'importanza di specificare correttamente il numero del dispositivo di acquisizione video per la webcam, in quanto possono verificarsi errori se questo non è corretto.
  
  
• 00:55:00 In questa sezione, l'istruttore spiega il codice per la raccolta di immagini per il rilevamento di oggetti. Il codice scorre le etichette e acquisisce i fotogrammi utilizzando la webcam. Crea una nuova immagine e la inserisce nella rispettiva cartella dell'etichetta con un nome identificativo univoco. Il comando cv2.iamwrite viene utilizzato per scrivere l'immagine su un file e mostrarla sullo schermo. Il codice consente inoltre all'utente di premere il tasto q per uscire in qualsiasi momento e chiude tutto al termine. L'istruttore sottolinea che è essenziale acquisire immagini in diverse posizioni per costruire un modello generalizzato.

Parte 2

• 01:00:00 In questa sezione, il relatore sottolinea l'importanza della prototipazione il più rapidamente possibile per i progetti scientifici per stabilire la fattibilità e la possibilità del progetto. Per illustrare, l'oratore fornisce un esempio di rilevamento di LED piegati, che richiederebbe un modello iper-accurato o un sensore come un microscopio. La prototipazione rapida con un modello di rete mobile e una webcam può mostrare prestazioni scadenti, il che indica la necessità di una tecnica o di un sensore diverso. La prototipazione aiuta rapidamente a stabilire una linea di base per il miglioramento e il relatore procede ad addestrare il modello con le immagini raccolte per il rilevamento del pollice in su, sottolineando l'importanza di eliminare le immagini di bassa qualità e acquisire più immagini di buona qualità per un migliore rilevamento.
  
  
• 01:05:00 In questa sezione, l'istruttore introduce il pacchetto Label Image che verrà utilizzato per etichettare le immagini. Gli utenti possono accedere al repository Github per controllare il pacchetto. Successivamente, l'istruttore mostra come installare le dipendenze richieste, pi qt5 e lxml, e creare una nuova cartella chiamata tensorflow e label image per salvare il pacchetto. Quindi, l'istruttore dimostra come clonare il repository Github e installare il pacchetto dell'immagine dell'etichetta eseguendo comandi specifici. Infine, l'istruttore apre l'applicazione etichetta immagine e si prepara a etichettare le immagini.
  
  
• 01:10:00 In questa sezione, l'istruttore dimostra il processo di etichettatura delle immagini per il rilevamento di oggetti utilizzando il software OpenCV Labeling. Il processo include l'apertura della directory specifica nel software e la selezione delle immagini da etichettare. L'istruttore consiglia di essere il più preciso possibile con le etichette di rilevamento e di assicurarsi che i nomi delle etichette corrispondano a quelli nelle annotazioni e nella fase di addestramento. Inoltre, l'istruttore incoraggia gli spettatori a pensare a diverse applicazioni di rilevamento degli oggetti e a provarle utilizzando lo stesso processo di definizione delle etichette, raccolta delle immagini ed etichettatura. Viene inoltre sottolineata l'importanza di garantire che le annotazioni corrispondenti esistano per ciascuna immagine.
  
  
• 01:15:00 In questa sezione, l'istruttore spiega come etichettare un'immagine creando un file di annotazione. Il file di annotazione è un file xml che descrive la posizione dell'oggetto nell'immagine. L'istruttore mostra come etichettare un'immagine con più oggetti e spiega come salvare correttamente le annotazioni. Il processo di etichettatura delle immagini può essere ampliato esternalizzando o utilizzando strumenti più recenti che automatizzano il processo di etichettatura utilizzando modelli di rilevamento degli oggetti leggeri.
  
  
• 01:20:00 In questa sezione, l'istruttore video mostra come etichettare le immagini utilizzando label image e come prototipare per assicurarsi di utilizzare la tecnica giusta prima di creare un enorme modello di rilevamento di oggetti con migliaia di immagini. Raccomanda di iniziare etichettando 10-25 immagini per mantenerlo super veloce e utilizzando i sensori giusti per ottenere i giusti livelli di dati. L'istruttore spiega anche l'importanza di suddividere le immagini in una partizione di addestramento e test per addestrare il modello su un segmento di immagini e testarlo su una serie di immagini che non ha mai visto prima. Crea due nuove cartelle denominate train e test all'interno della cartella delle immagini per archiviare le immagini e le annotazioni di training e test.
  
  
• 01:25:00 In questa sezione, impariamo come preparare i dati immagine raccolti ed etichettati per l'addestramento del nostro modello di rilevamento degli oggetti. Creiamo due cartelle, formazione e test, per archiviare le nostre immagini e annotazioni, assicurandoci di prendere sia i file di immagine che di annotazione per ogni classe. Spieghiamo quindi come convertirli in record TensorFlow da utilizzare per l'addestramento. Copriamo anche alcune best practice per la denominazione e l'organizzazione dei nostri dati. Infine, introduciamo le dipendenze necessarie per l'addestramento di un modello di rilevamento degli oggetti TensorFlow e come valutare il nostro modello utilizzando le metriche di valutazione.
  
  
• 01:30:00 In questa sezione, il relatore discute le metriche di valutazione ottenute dopo aver addestrato il modello di rilevamento degli oggetti. Queste metriche includono la precisione e la precisione media media (MAP), che calcola la proporzione di rilevamenti corretti. Sono calcolati in base al numero di veri positivi, falsi positivi, veri negativi e falsi negativi. Il relatore spiega che la precisione e il richiamo sono molto importanti quando si valutano le prestazioni del modello. Inoltre, il relatore afferma che la scelta dello zoo del modello TensorFlow influisce sulla precisione e sulla velocità del modello. Modelli diversi hanno architetture diverse che si traducono in diversi livelli di accuratezza e velocità e i professionisti devono scegliere il modello appropriato per il loro caso d'uso.
  
  
• 01:35:00 In questa sezione, la trascrizione discute i compromessi tra velocità e accuratezza del modello quando si sceglie un'architettura del modello per TensorFlow Object Detection. Il video presenta diverse opzioni di modello e le corrispondenti velocità dei fotogrammi e punteggi di precisione medi medi. Il relatore osserva che alcune architetture possono essere veloci e molto accurate, mentre altre possono essere più lente ma più precise. Vengono anche menzionati i vantaggi dell'utilizzo dell'API del modello di rilevamento degli aggiornamenti di TensorFlow, come l'uso di tecniche di pre-elaborazione e post-elaborazione e aumento delle immagini. La sezione si conclude con una discussione su come addestrare un modello utilizzando un'istanza cloud, se lo si desidera.
  
  
• 01:40:00 In questa sezione, l'istruttore spiega la configurazione per il modello TensorFlow Object Detection, che comporta l'impostazione del nome e dell'URL del modello pre-addestrato, oltre a variabili come lo script di generazione del record tf e il nome della mappa dell'etichetta. Viene mostrata anche la struttura delle cartelle per il modello, con l'area di lavoro contenente cartelle per annotazioni, immagini, modelli e punti di controllo. Il passaggio successivo consiste nel scaricare i modelli TensorFlow dallo zoo del modello TensorFlow e installare il pacchetto TensorFlow Object Detection, che l'istruttore esamina passo dopo passo per garantire un'installazione corretta. Il processo prevede la clonazione del repository TensorFlow Object Detection e l'installazione delle dipendenze necessarie.
  
  
• 01:45:00 In questa sezione, il relatore spiega come clonare e installare l'API del modello TensorFlow Object Detection. L'API del modello può essere scaricata dal giardino del modello TensorFlow, che ha molta documentazione e tutorial open source. Il relatore mostra quindi come accedere alla cartella di ricerca, che contiene tutti i file necessari per utilizzare l'API TensorFlow Object Detection Model. Dopo aver clonato la cartella di ricerca, il relatore procede a spiegare come installare protoc e altri componenti necessari per installare correttamente l'API del modello TensorFlow Object Detection. Infine, il relatore mostra come verificare l'installazione eseguendo uno script di verifica per verificare se l'API TensorFlow Object Detection è stata installata correttamente.
  
  
• 01:50:00 In questa sezione, l'istruttore passa attraverso il processo di verifica e installazione di Tensorflow per il rilevamento degli oggetti. Spiega che viene utilizzato uno script di verifica per garantire che Tensorflow sia installato correttamente e che possa essere eseguito per verificare eventuali errori. Lo script è uno script standard di rilevamento degli oggetti Tensorflow che indica se Tensorflow è installato o meno durante l'esecuzione. Se Tensorflow non è installato correttamente, l'istruttore fornisce indicazioni su come configurarlo, inclusa l'installazione di pacchetti aggiuntivi come matplotlib e yaml. L'istruttore assicura allo spettatore che se riscontra errori, può cercarli su Google, poiché sono comunemente riscontrati e facili da risolvere. Infine, afferma che raggiungere con successo il segno "okay" nella parte inferiore dello script di verifica significa che Tensorflow è stato installato correttamente.
  
  
• 01:55:00 In questa sezione, il video illustra il processo di installazione di TensorFlow e i pacchetti necessari per il rilevamento degli oggetti. L'istruttore mostra come installare TensorFlow, Matplotlib, Protobuf, Pillow e Pymel. L'istruttore consiglia di controllare il processo di installazione, poiché potrebbe essere diverso a seconda dell'ambiente. Il video illustra anche i passaggi per installare CUDA e CuDNN, necessari se si desidera utilizzare la GPU per l'addestramento. L'istruttore spiega come trovare la versione corretta di CUDA e CuDNN e passa attraverso il processo di installazione. Infine, l'istruttore dimostra come importare correttamente l'API Object Detection nel notebook riavviando il kernel.

Parte 3

• 02:00:00 In questa sezione, l'istruttore passa attraverso il processo di download e installazione di Nvidia cuDNN, che è necessario se ti alleni su una GPU. Innanzitutto, devi registrarti per un account sviluppatore Nvidia gratuito, quindi selezionare download cuDNN e accedere. Sono disponibili due versioni e devi scaricare la versione compatibile con la tua versione di TensorFlow. L'istruttore spiega come estrarre il file zippato e copiare i file cuDNN nelle rispettive cartelle all'interno della posizione di installazione di CUDA. Dopo aver copiato i file, l'ultimo passaggio consiste nell'assicurarsi che la cartella CUDA venga aggiunta al percorso su un computer Windows.
  
  
• 02:05:00 In questa sezione del video, l'istruttore spiega il processo di installazione di TensorFlow e come verificare se funziona correttamente. Il video passa quindi al processo di download di un modello di rilevamento di oggetti pre-addestrato dallo zoo del modello TensorFlow, che verrà utilizzato per trasferire l'apprendimento per rilevare oggetti personalizzati. L'istruttore dimostra come scaricare il modello e spiega i diversi componenti dei file scaricati. Infine, viene creata una mappa di etichette per rappresentare le diverse etichette per il rilevamento dell'oggetto personalizzato.
  
  
• 02:10:00 In questa sezione, l'istruttore spiega la creazione di una mappa di etichette e la generazione di record tf. Sottolinea l'importanza di un'etichettatura corretta poiché il file della mappa delle etichette verrà utilizzato successivamente durante il processo di formazione. Il video guida attraverso la generazione di un treno e un record di prova e su come aggiornare i componenti del percorso per il modello, in particolare il checkpoint di fine tuning, il percorso della mappa delle etichette e il percorso di input. Infine, sottolinea l'importanza del file di configurazione della pipeline, che determina l'architettura del modello e dovrebbe essere personalizzato per modelli specifici.
  
  
• 02:15:00 In questa sezione del video, l'istruttore spiega come impostare il file di configurazione per addestrare il modello. Il file della pipeline viene copiato dalla cartella dei modelli pre-addestrati e quindi la configurazione viene eseguita tramite codice impostando tutti i diversi percorsi di file insieme al numero di classi e impostando il checkpoint di fine tuning, il percorso della mappa delle etichette, il percorso di input, ecc. Una volta completata la configurazione, il modello può essere addestrato eseguendo lo script di addestramento del modello con gli argomenti necessari come il percorso del file pipeline.config, la configurazione della pipeline e il numero di passaggi di addestramento. Si consiglia di eseguire il comando in un prompt dei comandi separato all'esterno del notebook per visualizzare lo stato di avanzamento dell'addestramento del modello.
  
  
• 02:20:00 In questa sezione, l'istruttore risolve gli errori che si verificano durante il processo di addestramento al rilevamento degli oggetti. Spiega che la maggior parte degli errori viene risolta installando la libreria giusta o cercando soluzioni online. Nota inoltre che gli utenti dovrebbero assicurarsi di aver installato la versione corretta della GPU TensorFlow se desiderano sfruttare la GPU. L'istruttore guida quindi gli spettatori attraverso il processo di disinstallazione e reinstallazione delle librerie per risolvere errori specifici, sottolineando che questo processo potrebbe richiedere del tempo ma è necessario per una corretta esecuzione dell'addestramento al rilevamento degli oggetti. Infine, mostra agli spettatori come verificare di aver installato le librerie corrette e come monitorare l'avanzamento della corsa di formazione.
  
  
• 02:25:00 In questa sezione, l'istruttore discute il processo di addestramento del modello e la valutazione delle sue metriche di prestazione. Una volta avviato l'addestramento, le metriche di perdita vengono visualizzate ogni 100 passaggi, a indicare che il modello viene addestrato correttamente. Viene generato l'output del modello di addestramento per 2000 passaggi, a indicare che il modello è stato addestrato correttamente con una perdita finale di 0,188. L'istruttore spiega quindi come valutare il modello utilizzando la libreria di rilevamento degli oggetti TensorFlow ed eseguire lo script di valutazione, che genera metriche delle prestazioni per il modello addestrato. La precisione media e le metriche di richiamo possono quindi essere visualizzate utilizzando TensorBoard, uno strumento di monitoraggio interattivo per TensorFlow.
  
  
• 02:30:00 In questa sezione, l'istruttore guida gli spettatori attraverso l'utilizzo di Tensorboard per visualizzare e tenere traccia delle metriche durante la formazione e la valutazione. Passando alla cartella train, possono visualizzare le metriche di perdita nel tempo e, andando alla cartella eval, possono vedere le metriche di valutazione come precisione media media, precisione e richiamo. Gli spettatori possono anche vedere le prestazioni in tempo reale del modello visualizzando le immagini e se le classifica correttamente, e imparano come esportare il grafico dopo averlo bloccato.
  
  
• 02:35:00 In questa sezione, il modello addestrato viene caricato dal checkpoint e il rilevamento dell'oggetto viene eseguito su un'immagine. L'ultimo checkpoint è disponibile nella cartella del modello personalizzato, che contiene la pipeline e tutti i checkpoint. Una volta importato l'ultimo punto di controllo, è possibile selezionare un'immagine ed eseguire il rilevamento degli oggetti utilizzando la funzione di rilevamento. La funzione di rilevamento viene utilizzata anche per effettuare rilevamenti di oggetti in tempo reale da una webcam. Nonostante l'allenamento per soli 2000 passaggi con poche immagini, il modello si comporta bene nel rilevare diversi gesti delle mani.
  
  
• 02:40:00 In questa sezione, l'istruttore dimostra le prestazioni del modello di rilevamento degli oggetti su diversi gesti delle mani, come pollice in alto, pollice in basso, live long e dual hands. Le prestazioni del modello variano a seconda del gesto della mano e della distanza dalla fotocamera, ma possono essere perfezionate aggiungendo più immagini al training set. La sezione passa quindi al congelamento e alla conversione del modello creando un grafico congelato ed esportandolo in TensorFlow.js e TFLite. Il modello convertito può essere utilizzato per un'app Web o per un progetto Raspberry Pi. L'output finale del modello personalizzato è simile ai modelli con training preliminare, con checkpoint, risorse del modello salvate, variabili e configurazione della pipeline.
  
  
• 02:45:00 In questa sezione, l'oratore discute l'ultima conversione che deve essere fatta, che è la conversione alla luce. Questo viene fatto in due parti: in primo luogo, il grafico viene esportato in un grafico tf lite, quindi viene eseguito utilizzando il convertitore tf lite per produrre l'output esatto necessario per sfruttarlo. L'oratore osserva che questo è il modello end-to-end e che hanno congelato il grafico, esportato in tfjs e tf lite, completando così l'intera procedura dettagliata per lavorare con l'API di rilevamento degli oggetti tensorflow. Il relatore passa anche a discutere l'ottimizzazione delle prestazioni e rileva tre cose fondamentali che possono essere fatte per migliorare le prestazioni del modello: aggiungere più immagini di una classe a basso rendimento al set di dati di addestramento, addestrare il modello più a lungo e modificare l'architettura del modello.
  
  
• 02:50:00 In questa sezione del video, il relatore mostra come migliorare le prestazioni delle classi a basso rendimento nel modello di rilevamento degli oggetti aggiungendo immagini di addestramento più pertinenti. Invece di raccogliere immagini di ogni singola classe, il presentatore raccoglie più immagini di pollici in su e pollici in giù, che non hanno funzionato bene con mani diverse. Il relatore importa OpenCV e aggiorna la mappa dell'etichetta prima di raccogliere solo le immagini del pollice in su e del pollice in giù. Le immagini raccolte vengono archiviate all'interno dell'area di lavoro di Tensorflow, dove il presentatore le valuta e rimuove quelle di scarsa qualità. Infine, il presentatore aggiunge qualche altra immagine di pollice in giù con una mano diversa per migliorare le prestazioni del modello.
  
  
• 02:55:00 In questa sezione del video, l'istruttore esegue il codice per acquisire più immagini per i gesti delle mani pollice su e pollice giù. Dopo aver catturato le immagini, l'istruttore controlla la qualità delle immagini e decide di conservare tutte le immagini con il pollice in su e rimuove alcune delle immagini con il pollice in giù che sono fuori dallo schermo. L'istruttore apre quindi lo strumento LabelImg ed etichetta nuovamente le nuove immagini, prestando attenzione alla distinzione tra maiuscole e minuscole dei nomi delle etichette. L'istruttore afferma che questa fase di etichettatura delle immagini è una prova ed errore, e si può valutare e vedere cosa rende il modello migliore. L'istruttore suggerisce di esaminare gli strumenti di etichettatura automatica per migliorare l'efficienza, ma consiglia di prestare attenzione alle loro prestazioni per evitare qualsiasi necessità di modifiche manuali.

Parte 4

• 03:00:00 In questa sezione, l'istruttore dimostra come etichettare rapidamente le immagini per migliorare l'addestramento del modello TensorFlow Object Detection. Spiega che è importante copiare le immagini etichettate nelle cartelle di addestramento e test per valutare l'accuratezza del modello. Successivamente, mostra come addestrare un modello "ottimizzato" modificando il nome del modello personalizzato nel notebook di addestramento e rilevamento per creare una nuova cartella. Discute quindi su come copiare la configurazione della pipeline pre-addestrata nel nuovo modello ottimizzato e apportare aggiornamenti nella configurazione della pipeline. Infine, configura tutti i percorsi necessari utilizzando il codice fornito per creare i nuovi file record tf necessari per l'addestramento.
  
  
• 03:05:00 In questa sezione, l'istruttore aggiorna la configurazione della pipeline che definisce tutti i percorsi della mappa delle etichette per l'addestramento utilizzando la configurazione standard. L'aggiornamento della pipeline è un passaggio essenziale in quanto apre la strada all'esecuzione dello script di training. Il numero di passaggi di addestramento viene aggiornato dalla configurazione precedente a 3000 e il comando viene eseguito per creare il modello addestrato. Dopo il completamento delle fasi di addestramento, questo modello viene valutato e confrontato con il modello precedente eseguendo il codice nel passaggio 7. Le metriche di valutazione mostrano che la precisione media è aumentata da 0,7 a 0,834 e il rilevamento è più rapido e accurato. Aggiungendo più immagini, etichette aggiuntive e posizioni diverse, l'istruttore dimostra il miglioramento del modello e la produzione di un modello di rilevamento degli oggetti migliore. Infine, viene caricato il nuovo modello e viene eseguito il codice per il rilevamento in tempo reale, che rileva gli oggetti in modo molto rapido e preciso.
  
  
• 03:10:00 In questa sezione, l'istruttore discute i modi per migliorare le prestazioni del modello Tensorflow Object Detection modificando l'architettura del modello. A tale scopo, l'utente deve aggiornare il collegamento del modello con training preliminare che desidera utilizzare nel notebook di rilevamento. Copiando e incollando il nuovo collegamento e il nuovo nome, l'utente può quindi scaricare il nuovo modello pre-addestrato nella cartella dei modelli pre-addestrati. Tuttavia, l'istruttore sottolinea che si ottengono prestazioni migliori migliorando la qualità dell'immagine, ad esempio utilizzando diversi stili di immagini, immagini con diverse angolazioni e allenandosi per periodi più lunghi. L'istruttore mostra anche come addestrare un modello in Google Colab comprimendo le immagini e archiviandole prima di importarle nel taccuino di addestramento e rilevamento su Colab.
  
  
• 03:15:00 In questa sezione, l'istruttore guida gli spettatori attraverso il processo di caricamento delle immagini da utilizzare nel programma di rilevamento degli oggetti TensorFlow, nonché la clonazione del repository dei modelli TensorFlow e l'installazione del software di rilevamento degli oggetti TensorFlow. Viene importato il modello pre-addestrato e viene creata la mappa delle etichette. L'istruttore stabilisce quindi una configurazione personalizzata all'interno della cartella models/my_ssd_mobnet prima di addestrare il modello. Lo spettatore viene avvisato che il rilevamento di oggetti in tempo reale non può essere effettuato con una webcam utilizzando Colab, ma può essere eseguito con un'immagine. Man mano che lo spettatore procede passo dopo passo attraverso il processo, può valutare il proprio modello per vedere la precisione media media e il richiamo medio.
  
  
• 03:20:00 In questa sezione del video, l'istruttore dimostra come rilevare gli oggetti in un'immagine utilizzando il modello addestrato. Viene caricato l'ultimo checkpoint e viene specificato il nome dell'immagine per eseguire lo script di rilevamento. L'istruttore evidenzia che l'immagine deve essere valida e trovarsi nella cartella delle immagini. Dopo aver eseguito la cella, il modello di rilevamento oggetto addestrato identifica l'oggetto nell'immagine. L'istruttore spiega inoltre come comprimere ed esportare i file e sottolinea la necessità di installare l'API di rilevamento degli oggetti durante l'esecuzione del codice in locale. La sezione si conclude con un'anteprima dei tre progetti che verranno trattati successivamente, tra cui l'utilizzo di un microscopio per il rilevamento di oggetti, la creazione di un'app Web TensorFlow.js e l'esecuzione del rilevamento del sentiment di Raspberry Pi.
  
  
• 03:25:00 In questa sezione, l'istruttore inizia spiegando il primo progetto, che prevede l'utilizzo di un microscopio USB per rilevare i difetti nei piccoli LED. Il microscopio viene trattato come qualsiasi altra fotocamera e il feed video viene ottenuto utilizzando la libreria OpenCV. L'istruttore dimostra come posizionare e ingrandire il microscopio utilizzando il codice Python e visualizza il feed video. Il feed video viene quindi utilizzato per raccogliere immagini di addestramento per il rilevamento di oggetti. L'obiettivo di questo progetto è addestrare un modello per rilevare i difetti nei LED e classificarli come piegati o non piegati.
  
  
• 03:30:00 In questa sezione del corso completo TensorFlow Object Detection con tre progetti, l'istruttore mostra come utilizzare OpenCV per acquisire immagini da una webcam o da un microscopio. Esamina le migliori pratiche per il rilascio del dispositivo di acquisizione e la distruzione di qualsiasi finestra OpenCV, inclusa l'esecuzione di "cap.release" dopo aver chiuso qualsiasi acquisizione Web cv2. Dimostra quindi come regolare la posizione e la messa a fuoco del microscopio per acquisire immagini di pin LED e come creare due nuove cartelle per la memorizzazione di immagini di pin difettosi e non difettosi. Infine, verifica il feed della webcam per l'acquisizione delle immagini per assicurarsi che tutto funzioni come previsto.
  
  
• 03:35:00 In questa sezione del video, l'istruttore mostra come raccogliere immagini di un pin difettoso e di un pin non difettoso per il rilevamento di oggetti. Posizionano i perni e regolano il tempo di sospensione tra le acquisizioni di immagini, quindi utilizzano la funzione di sospensione per mettere in pausa tra le acquisizioni. L'istruttore spiega anche come etichettare le immagini utilizzando la linea di etichettatura e la posizione della cartella. Incoraggiano gli spettatori a chiedere chiarimenti o fornire feedback nella sezione dei commenti o nel server Discord.
  
  
• 03:40:00 In questa sezione del video, l'istruttore passa attraverso il processo di etichettatura delle immagini per addestrare un modello di rilevamento di oggetti personalizzato utilizzando TensorFlow. Utilizzando un microscopio, l'istruttore acquisisce immagini di pin difettosi e non difettosi e li etichetta di conseguenza. Quindi copiano le immagini nelle cartelle di addestramento e test prima di impostare la pipeline di addestramento. L'istruttore spiega come creeranno una nuova cartella per il loro modello di rilevamento degli oggetti personalizzato e aggiorneranno la mappa delle etichette per includere le nuove etichette. La base di codice utilizzata in questa sezione è piuttosto generica, consentendo molte personalizzazioni e l'istruttore fornisce suggerimenti sull'ottimizzazione delle prestazioni.
  
  
• 03:45:00 In questa sezione del tutorial, l'attenzione si concentra sulla creazione di record TensorFlow, che consentono l'addestramento del modello. Vengono discusse le celle necessarie per il download di modelli pre-addestrati e la creazione di mappe di etichette, ma l'attenzione è rivolta alla creazione di record TensorFLow che consentiranno l'addestramento del modello. Una volta creati i record TensorFlow, il modello viene aggiornato con le nuove classi e la configurazione aggiornata viene salvata. Il modello viene addestrato per 2000 passaggi e il nuovo modello viene testato per rilevare pin difettosi e non difettosi. Il taccuino è delineato e l'utente viene indirizzato verso celle specifiche che consentono lo sviluppo di questo modello.
  
  
• 03:50:00 In questa sezione, l'istruttore aggiorna l'immagine per rilevare un pin difettoso e un pin non difettoso. Il sistema rileva correttamente entrambi i pin con elevata affidabilità. Tuttavia, l'istruttore nota che il sistema non funziona bene con il perno difettoso in una posizione specifica, evidenziando un compromesso di messa a punto. L'istruttore mostra che il frame di rilevamento ha parametri che possono essere modificati per determinare il livello di accuratezza del rilevamento. Riducendo la soglia del punteggio minimo, il sistema può rilevare ragionevolmente bene il pin difettoso, ma a costo di rilevare molte altre cose come difettose. L'istruttore testa il sistema con pin di colore diverso, incluso uno su cui non è stato addestrato, e ad angolo, mostrando la robustezza del sistema.
  
  
• 03:55:00 In questa sezione, l'istruttore dimostra i risultati del primo progetto utilizzando un microscopio come metodo di rilevamento degli oggetti. Indica i pin rilevati e come vengono classificati come difettosi o non difettosi modificando gli angoli e le posizioni dei pin. Riassume il processo del primo progetto, che prevede l'acquisizione e l'etichettatura delle immagini, l'impostazione di una cartella del microscopio e l'addestramento del modello. Il prossimo progetto si concentra sulla creazione di un'app Web per rilevare la direzione di un oggetto. Ciò comporta la combinazione del codice del corso TensorFlow Object Detection con il repository Github dell'app TensorFlow Object Detection. L'obiettivo è rilevare il movimento su-giù-sinistra-destra che può essere implementato come sito Web in futuro.

Parte 5

• 04:00:00 In questa sezione del video, l'istruttore spiega come impostare e reimpostare le etichette per il rilevamento degli oggetti Tensorflow. Invece di definire etichette come pollice su o giù o pin difettosi e non difettosi, dimostrano invece come definire movimenti direzionali come sinistra, destra, su e giù. Quindi mostrano come creare cartelle per le diverse direzioni e raccogliere immagini da utilizzare per la formazione. L'istruttore spiega anche come etichettare le immagini utilizzando LabelImg, prestando attenzione ai casi di immagine e suggerisce l'ottimizzazione delle prestazioni in caso di risultati poco brillanti. Infine, passano a dimostrare come etichettare le immagini per la giusta direzione.
  
  
• 04:05:00 In questa sezione del video, l'istruttore mostra come etichettare le immagini da utilizzare nel modello di rilevamento degli oggetti. Vengono utilizzate solo cinque immagini per oggetto/classe, ma l'utente può regolare il numero come desiderato. L'istruttore avvisa che si tratta di un processo iterativo e va bene sperimentare con diversi numeri di immagini. Una volta che le immagini sono state etichettate, vengono ordinate in cartelle di addestramento e test, con una suddivisione 80/20 per ogni immagine/classe. Quando le cartelle sono impostate, l'istruttore cambia il nome della cartella e crea un nuovo percorso di file chiamato "directions". Infine, l'istruttore osserva che l'ambiente virtuale è già configurato e non è necessario eseguire ulteriori passaggi.
  
  
• 04:10:00 In questa sezione, la mappa delle etichette viene aggiornata con nuove etichette per "sinistra", "destra", "su" e "giù" ea ciascuna di esse vengono assegnati identificatori univoci. Le annotazioni vengono quindi eseguite per aggiornare la mappa delle etichette e generare i file tfrecord di train e test richiesti. Il modello viene quindi addestrato utilizzando un comando per generare lo script di addestramento e la perdita viene calcolata pari a 0,299. Il checkpoint 3 viene ripristinato per importare le dipendenze per i rilevamenti in tempo reale e la soglia del punteggio minimo viene impostata su 90. Infine, la webcam viene attivata per generare rilevamenti in tempo reale per il modello di rilevamento degli oggetti.
  
  
• 04:15:00 In questa sezione, l'istruttore mostra come valutare il modello e migliorarne l'accuratezza aggiungendo più immagini delle classi particolari che non stanno funzionando bene. Lo dimostra indicando
  in diverse direzioni usando entrambe le mani e osservando come si comporta il modello. Quindi passa a bloccare il grafico, esportarlo e convertirlo in tensorflow.js. Spiega inoltre come caricare il modello su IBM Cloud Object Store e illustrare i passaggi disponibili nel repository github. L'istruttore procede quindi alla clonazione del repository, apre un nuovo prompt dei comandi e mostra come navigare nelle cartelle appropriate.
  
  
• 04:20:00 In questa sezione del video, l'istruttore fornisce una procedura dettagliata su come preparare un ambiente di sviluppo per l'utilizzo del rilevamento di oggetti TensorFlow per il riconoscimento delle immagini. L'istruttore mostra innanzitutto come navigare nelle cartelle necessarie e clonare il repository di rilevamento degli oggetti TensorFlow. Quindi, l'istruttore mostra come installare Node.js e le dipendenze per il repository. Infine, l'istruttore mostra come creare un nuovo bucket di storage di oggetti cloud su IBM Cloud e come assegnargli un nome. Questo processo è necessario per utilizzare l'interfaccia utente basata sul Web nelle sezioni successive del video.
  
  
• 04:25:00 In questa sezione, l'istruttore continua con la fase cinque dell'esercitazione, ovvero creare un bucket in IBM Cloud Object Storage e caricarvi i file model.json e .bin. Successivamente, abilita un criterio di accesso pubblico, consentendo l'accesso al modello da qualsiasi posizione e mostra come acquisire l'URL del file model.json per un uso successivo nell'app. Quindi passa attraverso il processo di abilitazione di Cross-Origin Resource Sharing (CORS) eseguendo i comandi CLI dopo aver installato la CLI IBM Cloud Object Storage.
  
  
• 04:30:00 In questa sezione, il video mostra come installare la CLI IBM Cloud e la CLI IBM Cloud Object Storage tramite un'interfaccia della riga di comando, abilitando la condivisione delle risorse tra le origini (CORS), che consente a un'applicazione Web di accedere a un URL da qualche altra parte. Il comando installa anche IBM Cloud Storage Client e lo configura con un file di configurazione. Il video mostra come sostituire il nome del bucket di un utente in un comando che inserisca la causa policy nella cartella principale del bucket. Infine, il video spiega che la causa policy è contenuta nel file di configurazione del cloud e fa parte del repository clonato, il che significa che non è necessaria la creazione di file.
  
  
• 04:35:00 In questa sezione, l'istruttore spiega come aggiornare i file necessari per eseguire l'app Web TensorFlow.js. I passaggi includono l'impostazione delle credenziali di Google Cloud Storage, l'aggiornamento dell'URL del modello in app.js, l'aggiornamento della mappa delle etichette in utilities.js e l'avvio dell'app utilizzando npm start. L'istruttore spiega anche come eseguire il debug dell'app se non funziona, inclusa la modifica della metrica di confidenza e il controllo dell'ordine degli oggetti nell'array dei risultati del rilevamento. Nel complesso, questi passaggi consentono agli utenti di personalizzare l'app Web in base al loro caso d'uso specifico e assicurarsi che funzioni correttamente.
  
  
• 04:40:00 In questa sezione, il video mostra come capire dove sono gli oggetti e come manipolare l'array dei risultati. Esaminando il codice, l'utente può identificare che l'array dei risultati contiene cinque valori e ogni array ha classi diverse disponibili per una particolare app. Il video guida ulteriormente l'utente su come utilizzare correttamente ciascun array di oggetti, come l'oggetto tre, che sono classi box non post-processo rappresentate da numeri molto bassi. Il video mostra quindi come modificare la metrica di confidenza e i valori del punteggio e regolare il valore della casella, operazione che l'utente può eseguire rapidamente modificando i valori dell'array delle caselle.
  
  
• 04:45:00 In questa sezione, il video conclude il secondo progetto e passa al terzo progetto che prevede l'esecuzione di modelli di rilevamento di oggetti su un Raspberry Pi. Il relatore osserva che l'esecuzione di modelli di rilevamento degli oggetti sul Raspberry Pi è diversa dai due progetti precedenti a causa della mancanza di una GPU, e quindi convertiranno specificamente il modello in un formato Tensorflow lite. Raccoglieranno immagini di volti felici e tristi e addestreranno il loro modello utilizzando lo stesso processo di prima. Tuttavia, useranno il Raspberry Pi per questo progetto e vi accederanno tramite desktop remoto per i rilevamenti. Il video termina menzionando la possibilità di eseguire più modelli diversi su dispositivi diversi e incoraggia gli spettatori a condividere le proprie idee su questo argomento.
  
  
• 04:50:00 In questa sezione del video, l'istruttore mostra come raccogliere ed etichettare le immagini per un rilevatore di sentimenti che riconosca i volti felici e quelli tristi. Il processo prevede l'eliminazione di immagini esistenti, la creazione di percorsi per nuove immagini, la raccolta di cinque immagini di ciascuna emozione, l'etichettatura delle immagini e il salvataggio di ciascun oggetto. L'istruttore ricorda agli spettatori che la distinzione tra maiuscole e minuscole è fondamentale nell'etichettatura e che gli schermi verdi non sono necessari per questo esercizio. Inoltre, l'istruttore osserva che gli utenti possono sempre tornare alla directory delle immagini per aggiornare un'etichetta dell'immagine.
  
  
• 04:55:00 In questa sezione, l'istruttore mostra come organizzare e spostare le immagini e le annotazioni raccolte nelle cartelle di addestramento e test. Dimostrano come creare un nuovo modello personalizzato ed etichettare le immagini raccolte come felici e tristi aggiornando la mappa delle etichette. Quindi creano record tf e copiano la configurazione del modello pre-addestrato nella cartella del modello personalizzato. Dopo aver aggiornato la configurazione, addestrano il modello utilizzando il comando generato, che viene eseguito nell'ambiente virtuale, e attendono il completamento del processo.

Parte 6

• 05:00:00 In questa sezione, l'istruttore parla di un errore comune che potrebbe verificarsi durante l'esecuzione dell'addestramento del modello di sentiment quando si lavora su una macchina GPU. Il messaggio di errore indica che la GPU è completamente consumata, causando un brutto momento al sistema. Per risolvere questo problema, gli utenti devono interrompere tutto ciò che potrebbe utilizzare la GPU in qualsiasi momento e quindi riavviare l'esecuzione dell'addestramento. Una volta completata la formazione, gli utenti possono importare il sistema operativo e questi percorsi e controllare anche l'ultimo checkpoint. L'istruttore dimostra anche l'uso del modello di sentiment in tempo reale, che è un processo rapido e semplice una volta configurato il sistema.
  
  
• 05:05:00 In questa sezione, l'istruttore spiega i passaggi necessari per creare un modello di rilevamento Raspberry Pi utilizzando il rilevamento di oggetti TensorFlow. Il primo passo è creare i file TfLite seguendo il corso di rilevamento degli oggetti TensorFlow. Successivamente, gli utenti devono clonare il repository di rilevamento Raspberry Pi, scaricarlo sul proprio PC o clonarlo dal Raspberry Pi. Una volta eseguita questa operazione, gli utenti devono installare le dipendenze richieste, copiare il modello convertito ed eseguirlo utilizzando il modello detect.tf lite esistente. L'istruttore dimostra anche come eseguire il desktop remoto nel Raspberry Pi utilizzando xrdp, semplificando il processo.
  
  
• 05:10:00 In questa sezione, l'istruttore illustra il processo di installazione di tutte le dipendenze necessarie per lavorare con l'API Object Detection di TensorFlow su un Raspberry Pi. L'istruttore dimostra come installare OpenCV Python, oltre a molte altre dipendenze necessarie affinché OpenCV funzioni su Raspberry Pi. Successivamente, l'istruttore installa il runtime TensorFlow Lite, necessario per eseguire i modelli TensorFlow Lite sul Raspberry Pi. Una volta installate tutte le dipendenze, eseguono un modello di rilevamento degli oggetti di esempio sul Raspberry Pi per mostrare come funziona. Infine, l'istruttore spiega come aggiungere un modello personalizzato ed etichette al sistema.
  
  
• 05:15:00 In questa sezione, l'istruttore discute il rilevamento di oggetti personalizzati e come regolare la soglia di rilevamento per ottenere risultati migliori. Il rilevamento di oggetti personalizzati include due etichette; felice e triste. L'istruttore regola l'ordine delle etichette in felice come primo oggetto e triste come secondo oggetto. Eseguendo il modello personalizzato, non rileva alcun oggetto e l'istruttore decide di abbassare la soglia di rilevamento al 20%. Dopo aver eseguito nuovamente il comando, il modello rileva gli oggetti; un grande oggetto triste e uno felice. L'istruttore sottolinea la necessità di addestrare il modello con più immagini per ottenere migliori risultati prestazionali. L'istruttore esegue un'ulteriore messa a punto delle prestazioni aggiungendo più immagini delle classi in esecuzione e addestrando il modello più a lungo.
  
  
• 05:20:00 In questa sezione, il relatore spiega come ha migliorato le prestazioni del suo modello di analisi dei sentimenti. In primo luogo, ha aggiunto ulteriori immagini di se stesso da diverse angolazioni, il che aumenta le possibilità che il modello si generalizzi bene. In secondo luogo, ha addestrato il suo modello per altri 5600 passaggi, ottenendo un modello nuovo di zecca con un punto di controllo dell'indice maggiore. Poi è andato e ha convertito quel nuovo modello in un grafico tf-lite congelato e lo ha portato in Raspberry Pi, che ha usato per rilevare se era felice o triste. L'oratore dimostra che lo schermo verde in alto o in basso non ha influito sulle prestazioni del suo modello ed è stato in grado di rilevare correttamente quando era felice o triste. L'oratore sottolinea il potere della messa a punto delle prestazioni e come può essere utilizzato per migliorare la precisione del modello.
  
  
• 05:25:00 Questo estratto finale conclude il corso Tensorflow Object Detection in 5 Hours with Python, con l'istruttore che ricorda agli spettatori di contattarci nei commenti o attraverso il canale Discord se hanno bisogno di ulteriore assistenza. Il corso è vantaggioso per gli spettatori che desiderano conoscere il rilevamento di oggetti e desiderano una conoscenza approfondita di Tensorflow, in quanto copre tre progetti all'interno del corso stesso.

[MetaQuotes]

Riconoscimento automatico della targa utilizzando Tensorflow e EasyOCR Corso completo in 2 ore | Pitone

Taccuino finale: https://github.com/nicknochnack/RealTimeAutomaticNumberPlateRecognition

Codice di base: https://github.com/nicknochnack/TFODCourse

Riconoscimento automatico della targa utilizzando Tensorflow e EasyOCR Corso completo in 2 ore | Pitone

Il video di YouTube intitolato "Automatic Number Plate Recognition using Tensorflow and EasyOCR Full Course in 2 Hours | Python" fornisce una guida completa alla creazione di un sistema ANPR (Automatic Number Plate Recognition) accurato ed efficiente utilizzando Tensorflow e EasyOCR. Il sistema ANPR utilizza un sistema in due parti, con TensorFlow utilizzato per rilevare la regione di interesse della targa, mentre EasyOCR estrae il testo dalla regione rilevata. Il video copre una vasta gamma di argomenti, dalla configurazione di ambienti virtuali e l'installazione delle dipendenze necessarie, alla preparazione dei dati per l'addestramento e la risoluzione degli errori che possono verificarsi durante l'addestramento. Nel complesso, gli spettatori possono acquisire una comprensione dettagliata di come costruire un sistema ANPR di livello produttivo con funzionalità di rilevamento delle immagini in tempo reale o standard.

Il tutorial di YouTube sul riconoscimento automatico delle targhe (ANPR) con TensorFlow e EasyOCR illustra come rilevare accuratamente le targhe utilizzando il rilevamento degli oggetti e come estrarre i numeri di targa utilizzando l'OCR. L'istruttore spiega come filtrare il testo in base alle dimensioni e alle coordinate per estrarre solo le informazioni rilevanti dalla lastra. Dimostrano come allocare le risorse della GPU e limitare il consumo di memoria per TensorFlow, estrarre punteggi di immagini, classi e caselle che superano la soglia di rilevamento e applicare l'OCR utilizzando EasyOCR. Inoltre, il video illustra come salvare i risultati dell'output in un file CSV e nel percorso della cartella sia per i risultati in tempo reale che per le immagini. L'oratore sottolinea che il codice è disponibile per gli spettatori e li incoraggia a chiedere aiuto e condividere il proprio feedback.

• Il sistema 00:00:00 è l'OCR o il riconoscimento ottico dei caratteri. Questo passaggio prevede l'utilizzo di una libreria chiamata EasyOCR per estrarre il testo dal feed delle targhe rilevato, consentendoci di leggere e analizzare il testo dalle targhe in tempo reale o su immagini standard. Inoltre, il corso copre anche la costruzione di un sistema più avanzato che imita i sistemi AMPR pre-costruiti di produzione salvando e registrando le lastre rilevate in precedenza e le loro regioni di interesse. Nel complesso, il corso offre una guida completa alla creazione di un sistema di riconoscimento automatico delle targhe accurato ed efficiente utilizzando Tensorflow e EasyOCR.
  
  
• 00:05:00 questa sezione, il presentatore spiega il sistema in due parti utilizzato per il riconoscimento automatico delle targhe. La prima parte utilizza il modello di rilevamento degli oggetti TensorFlow per rilevare la regione di interesse che è la targa. La seconda parte utilizza EasyOCR per estrarre il testo dalla regione rilevata. Il presentatore mostra come installare i componenti necessari, inclusi TensorFlow e EasyOCR, e fornisce un collegamento al repository GitHub contenente i file richiesti. Il presentatore spiega come clonare il repository e mostra il contenuto della cartella che viene creata di conseguenza. La cartella contiene un file notebook utilizzato per l'addestramento e il rilevamento della targa.
  
  
• 00:10:00 In questa sezione del video, il relatore illustra i passaggi per configurare un ambiente virtuale e installare le dipendenze necessarie per eseguire il riconoscimento automatico della targa (ANPR) utilizzando TensorFlow e EasyOCR. Il relatore prima clona il repository ANPR e crea un ambiente virtuale con Python. Quindi attiva l'ambiente virtuale e installa dipendenze importanti come ipi kernel e aggiorna pip. Attraverso questi passaggi, dimostra come associare l'ambiente virtuale a un notebook Jupyter per sfruttare tutta la potenza di ANPR.
  
  
• 00:15:00 In questa sezione, l'istruttore guida lo spettatore attraverso il processo di associazione del proprio ambiente virtuale al notebook Jupyter utilizzando l'ambiente "ampr sys" come esempio. L'istruttore osserva che questo è importante perché spesso le persone che lavorano con ambienti virtuali installeranno tutto nel loro ambiente, ma quando entrano nel loro Jupyter Notebook, continua a dire che non c'è. Una volta che l'ambiente virtuale è associato al Jupyter Notebook, l'istruttore guida lo spettatore attraverso il processo di installazione dell'API di rilevamento degli oggetti TensorFlow e l'impostazione della struttura delle cartelle per poter eseguire il rilevamento degli oggetti utilizzando TensorFlow.
  
  
• 00:20:00 In questa sezione, l'istruttore inizia spiegando il concetto di transfer learning, in base al quale un modello all'avanguardia già esistente può essere messo a punto per un caso d'uso specifico, come il rilevamento delle targhe. L'istruttore procede quindi a scaricare i modelli pre-addestrati dal TensorFlow Model Zoo e installa l'API TensorFlow Object Detection eseguendo diverse celle di codice. L'API e i suoi componenti, come la cartella di rilevamento degli oggetti, vengono clonati nel repository del giardino del modello TensorFlow e viene avviata l'installazione del modello di rilevamento degli oggetti TensorFlow. L'installazione coinvolge diverse dipendenze e protoc, il sistema di buffer del protocollo, e potrebbe richiedere del tempo per il completamento.
  
  
• 00:25:00 In questa sezione, l'istruttore illustra l'installazione di TensorFlow e della sua versione GPU. Installano TensorFlow 2.4.1 e TensorFlow GPU 2.4.1, che è compatibile solo con le GPU Nvidia. Mostrano come verificare che l'installazione abbia esito positivo eseguendo uno script di verifica, che dovrebbe restituire "Ok" alla fine. L'istruttore dimostra anche come risolvere eventuali errori di "modulo non trovato" che possono sorgere durante il processo di installazione, come l'installazione delle librerie Matplotlib e Pillow utilizzando pip. Lo script di verifica assicura che tutte le dipendenze necessarie siano installate prima di passare alla sezione successiva.
  
  
• 00:30:00 In questa sezione del video, il presentatore illustra l'installazione di vari moduli necessari per costruire un modello di rilevamento degli oggetti, in particolare per il riconoscimento delle targhe. Incontrano diversi errori durante il processo di installazione, ma spiegano come risolverli. Una volta installati tutti i moduli necessari, inclusi TensorFlow Object Detection e EasyOCR, il relatore passa alla fase successiva, lavorando con i dati, e introduce un set di dati Kaggle che contiene immagini di auto e annotazioni per le targhe. Dimostrano come scaricare e preparare il set di dati da utilizzare nel modello.
  
  
• 00:35:00 In questa sezione, l'istruttore spiega come scaricare i dati necessari per il riconoscimento automatico della targa (ANPR) e organizzarli in set di addestramento e test per il rilevamento di oggetti. I dati, che contengono annotazioni e immagini corrispondenti, vengono scaricati da Kaggle e decompressi nella cartella ANPR. All'interno della cartella delle immagini vengono create due nuove cartelle, una per l'addestramento e una per il test, e le immagini scaricate vengono copiate nella cartella del treno. Le annotazioni sono inoltre suddivise in set di addestramento e test, con le annotazioni di addestramento posizionate nella cartella del treno insieme alle immagini corrispondenti. Lo scopo di questi set separati è addestrare il modello di rilevamento degli oggetti su un set di dati e testarlo su un set indipendente per valutarne le prestazioni.
  
  
• 00:40:00 In questa sezione, il video illustra il processo di preparazione dei dati per l'addestramento di un modello di rilevamento delle targhe. Il presentatore spiega di aver scaricato le immagini delle targhe da Kaggle e di aver copiato le annotazioni corrispondenti in due nuove cartelle, "train" e "test", all'interno dell'area di lavoro di TensorFlow. Il passaggio successivo consiste nell'addestrare il modello di rilevamento degli oggetti, che prevede l'aggiornamento delle etichette, la creazione di record tf, la preparazione della configurazione e, infine, l'addestramento del modello. Il relatore utilizza una "mappa delle etichette" per identificare l'unica etichetta che utilizzerà, "licenza", quindi crea un record tf, che è il formato richiesto dal modello di rilevamento degli oggetti. Il processo è descritto come semplice e viene fornito uno script per generare il record tf.
  
  
• 00:45:00 In questa sezione, il video illustra come preparare i dati per l'addestramento con TensorFlow e EasyOCR. Lo script discusso qui converte i dati grezzi, comprese le immagini e le annotazioni, in un formato record tf, ma deve essere aggiornato a causa del formato leggermente diverso delle annotazioni nel set di dati Kaggle. Il video mostra come correggere gli errori che si verificano a causa di questa discrepanza, inclusa l'installazione di moduli mancanti, la modifica dell'indice per raccogliere le metriche del riquadro di delimitazione corrette e la copia della configurazione del modello pre-addestrato nella cartella di addestramento.
  
  
• 00:50:00 In questa sezione, il relatore esamina i dettagli della pipeline del modello pre-addestrato, che contiene diverse righe di configurazioni che devono essere aggiornate prima di addestrare il modello. Il relatore mostra come copiare il file di configurazione aggiornato che garantisce che i parametri siano aggiornati e come eseguire il comando training per addestrare il modello. Menzionano anche l'importanza di eseguire il comando esternamente per vedere correttamente i progressi e come attivare un ambiente virtuale per eseguire il comando. Infine, spiegano come risolvere un errore standard che può verificarsi durante l'installazione del modello.
  
  
• 00:55:00 In questa sezione del corso, l'istruttore risolve gli errori che possono verificarsi durante l'allenamento. Dimostra come risolvere problemi specifici come un errore di valore relativo a un punto numpy e una modifica della dimensione dell'array, un errore di modulo non trovato per cv2, un errore di modulo non trovato per i componenti aggiuntivi tensorflow e un errore di modulo non trovato per gin. L'istruttore spiega che questi errori non sono rari ed è essenziale installare le librerie necessarie per risolverli. Una volta addestrato il modello, l'istruttore mostra come leggere le metriche di perdita e come trovare il punto di controllo del modello addestrato più recente.
  
  
• 01:00:00 In questa sezione del video tutorial sul riconoscimento automatico delle targhe utilizzando Tensorflow e EasyOCR, l'istruttore illustra come rilevare le targhe dalle immagini o in tempo reale utilizzando lo stesso modello. Modificando il nome del file immagine, il modello può rilevare e classificare con precisione diversi tipi di lastre. Si è scoperto che questo metodo funziona molto meglio attraverso il rilevamento degli oggetti rispetto allo sfruttamento delle tradizionali tecniche di visione artificiale poiché i formati delle lastre possono variare. Il modello può anche rilevare le targhe da un flusso video in diretta o tenendo un telefono davanti alla targa dell'auto. L'istruttore sottolinea che il metodo è efficiente ed è un buon inizio per costruire un rilevatore di targhe, e il passo successivo sarebbe applicare componenti OCR per estrarre dati significativi dall'immagine.
  
  
• 01:05:00 In questa sezione, il video tutorial illustra come utilizzare la libreria open source EasyOCR per rilevare ed estrarre il testo da un'immagine al fine di identificare un numero di targa. Il tutorial rileva che mentre sono disponibili modelli OCR più accurati, EasyOCR viene utilizzato poiché viene eseguito su PyTorch, richiedendo un po' di spazio affinché la GPU sia in grado di eseguirlo insieme a TensorFlow senza consumare tutta la memoria della GPU. Il tutorial mostra come allocare le risorse della GPU e limitare il consumo di memoria per TensorFlow per consentire a EasyOCR di funzionare senza problemi.
  
  
• 01:10:00 In questa sezione, il relatore spiega come caricare i percorsi e le etichette dei file necessari per il riconoscimento automatico della targa (ANPR) utilizzando TensorFlow e EasyOCR e come installare EasyOCR e PyTorch con l'accelerazione CUDA. Dimostrano che dopo aver caricato un'immagine di esempio ed eseguito ANPR, i numeri di targa e i punteggi di rilevamento vengono memorizzati in una variabile chiamata "rilevamenti", che vengono quindi utilizzati per applicare l'OCR utilizzando EasyOCR. Una soglia di rilevamento è impostata su 0,7, consentendo di elaborare ulteriormente solo i rilevamenti con punteggi superiori a 0,7.
  
  
• 01:15:00 In questa sezione, l'istruttore spiega come estrarre punteggi di immagini, classi e riquadri che superano la soglia di rilevamento utilizzando poche righe di codice. Dimostrano come scorrere ogni valore nell'array del punteggio di rilevamento e restituire solo i punteggi che superano la soglia. Applicano anche filtri alle caselle e alle classi per garantire che siano della dimensione e del formato corretti per la webcam. Infine, prendono la larghezza e l'altezza dell'immagine per ricalcolare le coordinate del riquadro e applicano il filtro all'immagine per determinare la regione di interesse.
  
  
• 01:20:00 In questa sezione, il video mostra come estrarre la regione di interesse dall'immagine e applicare il riconoscimento ottico dei caratteri (OCR) per estrarre i risultati della lastra. Innanzitutto, i parametri di larghezza e altezza dell'immagine sono ottenuti utilizzando image.shape. Per estrarre il ROI, scorrere ogni casella nella variabile box, che rappresenta le coordinate del rilevamento, e filtrare la regione di interesse. Infine, l'OCR viene applicato alla ROI utilizzando EasyOCR e i risultati vengono stampati sulla console. Il video accompagna lo spettatore attraverso il processo di configurazione del lettore EasyOCR, passando attraverso i parametri della lingua e analizzando l'immagine per estrarre i risultati della lastra.
  
  
• 01:25:00 In questa sezione, il relatore discute su come estrarre efficacemente la lastra stampata o il testo dalla lastra utilizzando l'OCR (riconoscimento ottico dei caratteri). Mostrano un'immagine di esempio in cui è presente del testo aggiuntivo oltre al numero di targa, che può confondere il lettore OCR. Per risolvere questo problema, il presentatore suggerisce di filtrare i risultati in base a dimensioni e coordinate. Dimostrano come scrivere una funzione per eseguire questo filtraggio e applicarlo all'immagine per ottenere il testo appropriato. I risultati mostrano che il lettore OCR può estrarre con precisione il numero di targa, anche se c'è ancora spazio per miglioramenti con il modello OCR.
  
  
• 01:30:00 In questa sezione, il relatore introduce una nuova funzione chiamata "filter text". Questa funzione accetta tre argomenti: regione, risultato OCR e soglia regione. La regione rappresenta l'immagine, il risultato OCR rappresenta il testo estratto da EasyOCR e la soglia della regione è la soglia della dimensione per il rilevamento delle regioni della targa. La funzione scorre i risultati OCR, estrae la lunghezza e la larghezza di ciascuno, li moltiplica e li confronta con la soglia della regione. Se passa questo filtro, viene considerato testo e la sua regione viene memorizzata in una variabile chiamata "plate". Il relatore spiega anche alcune porzioni di codice che calcolano la dimensione della regione e illustrano il funzionamento del filtro.
  
  
• 01:35:00 In questa sezione, l'autore mostra come filtrare efficacemente il testo nelle immagini utilizzando il motore OCR. L'algoritmo filterText consentirà all'utente di specificare una soglia per la regione, che filtrerà solo i blocchi di testo che soddisfano o superano questa soglia. Usano questa funzione per estrarre i componenti di cui hanno bisogno piuttosto che recuperare tutto dalla piastra. Hanno anche creato una funzione OCR_it che combina il filtro OCR e i componenti OCR e può essere applicata a qualsiasi immagine al superamento dell'immagine e dei rilevamenti con le soglie corrispondenti.
  
  
• 01:40:00 In questa sezione, l'istruttore verifica il proprio metodo di riconoscimento ottico dei caratteri (OCR) passando un'immagine attraverso la propria funzione "ocr_it" con soglie di rilevamento e regione specificate. Il metodo è in grado di estrarre con precisione la targa e la sua regione nell'immagine. Quindi dimostrano l'applicazione del metodo OCR in tempo reale per rilevare le targhe utilizzando un blocco try-except e un nuovo codice che chiama la funzione OCR per ogni rilevamento valido. L'istruttore verifica il rilevamento in tempo reale sul proprio telefono e mostra che rileva ed estrae accuratamente il testo della targa, sebbene i risultati non siano perfetti e potrebbero richiedere alcune modifiche.
  
  
• 01:45:00 In questa sezione del video, l'istruttore spiega come salvare i risultati di output del sistema OCR che ha sviluppato. Creano una nuova funzione chiamata "save_results" che prende il testo, la regione, il nome del file e la cartella come parametri di input. Quindi usano la libreria uuid per generare un nome file univoco e la libreria csv per salvare i risultati di output in un file csv. Usano anche la libreria cv2 per scrivere l'immagine nella cartella selezionata. Infine, completano il codice e lo testano.
  
  
• 01:50:00 In questa sezione del video, l'istruttore mostra come impostare un file CSV e un percorso di cartella per scrivere tutti i risultati delle immagini o le regioni. Creano una nuova cartella chiamata detection_images, dove verranno scritti tutti i risultati delle immagini. L'istruttore mostra come passare attraverso il nome del file CSV e il percorso della cartella, quindi testare il codice per salvare i risultati. Hanno impostato un metodo di salvataggio dei risultati per scrivere i risultati nella cartella creata, che include il nome dell'immagine e la targa. L'istruttore mostra quindi come eseguire il codice in tempo reale per salvare i risultati mentre si verificano i rilevamenti. Infine, testano il codice, il che si traduce in un output accurato delle immagini salvando i risultati in tempo reale.
  
  
• 01:55:00 In questa sezione, il relatore informa gli spettatori che la funzione OCR costruita e l'algoritmo di filtraggio applicato in tempo reale è a loro disposizione. Incoraggia gli spettatori a chiedere aiuto in caso di difficoltà e afferma che il codice sarà disponibile su GitHub per essere utilizzato. Infine, ringrazia gli spettatori per essersi sintonizzati, chiede loro di mettere mi piace, iscriversi e commentare e chiude.

[MetaQuotes]

Apprendimento per rinforzo in 3 ore | Corso completo usando Python

Codice: https://github.com/nicknochnack/ReinforcementLearningCourse

Apprendimento per rinforzo in 3 ore | Corso completo usando Python

00:00:00 - 01:00:00 Il video corso "Reinforcement Learning in 3 Hours" copre una vasta gamma di argomenti nell'apprendimento per rinforzo, inclusa l'implementazione pratica e il superamento del divario tra teoria e pratica. Il corso copre tutto, dalla configurazione dell'ambiente RL alla creazione di ambienti personalizzati, con particolare attenzione alla formazione di agenti di apprendimento per rinforzo e alla loro valutazione utilizzando diversi algoritmi e architetture. Vengono discusse applicazioni RL popolari come la robotica e i giochi, nonché i limiti di RL come il presupposto che gli ambienti siano markoviani e il potenziale per un addestramento instabile. Il corso utilizza Stable Baselines, una libreria RL open source e OpenAI Gym per creare ambienti simulati. L'istruttore spiega i diversi tipi di spazi utilizzati per rappresentare azioni e valori che gli agenti possono assumere in un ambiente, nonché diversi algoritmi RL come A2C e PPO. Viene sottolineata l'importanza di comprendere l'ambiente prima di implementare gli algoritmi e gli utenti vengono guidati attraverso l'impostazione della piattaforma di calcolo per l'apprendimento per rinforzo, la scelta degli algoritmi RL appropriati e l'addestramento e il test del modello.

01:00:00 - 02:00:00 Questo video di YouTube fornisce un corso di tre ore sull'apprendimento per rinforzo utilizzando Python. L'istruttore spiega i componenti principali dell'apprendimento per rinforzo, inclusi l'agente, l'ambiente, l'azione e la ricompensa. La sezione illustra come definire un ambiente, addestrare un modello utilizzando l'apprendimento per rinforzo e visualizzare i registri di addestramento utilizzando TensorBoard per monitorare il processo di addestramento. Il docente copre anche altri argomenti, come il salvataggio e il ricaricamento di un modello addestrato, il test e il miglioramento delle prestazioni del modello, la definizione di un'architettura di rete per un attore personalizzato e una funzione di valore in una rete neurale e l'utilizzo dell'apprendimento per rinforzo per giocare al gioco Atari Breakout. Inoltre, il corso include tre progetti che gli studenti costruiranno utilizzando tecniche di apprendimento per rinforzo, tra cui il gioco Breakout in Atari, la costruzione di un'auto da corsa per la guida autonoma e la creazione di ambienti personalizzati utilizzando gli spazi della palestra OpenAI.

02:00:00 - 03:00:00 Questo video di YouTube intitolato "Reinforcement Learning in 3 Hours | Full Course using Python" copre vari argomenti relativi all'apprendimento per rinforzo. L'istruttore dimostra come addestrare un agente di apprendimento per rinforzo per i giochi Atari e la guida autonoma utilizzando l'ambiente delle auto da corsa. Introducono anche varie dipendenze della palestra OpenAI, aiutanti e linee di base stabili, nonché diversi tipi di spazi per l'apprendimento per rinforzo. Inoltre, il video spiega come creare un ambiente personalizzato per l'apprendimento per rinforzo, definire lo stato dell'ambiente, i suoi spazi di osservazione e azione, testare e addestrare il modello e salvare il modello addestrato dopo l'apprendimento. L'istruttore discute anche l'importanza di modelli di allenamento per periodi più lunghi per prestazioni migliori e incoraggia gli spettatori a contattare se incontrano difficoltà.

• 00:00:00 In questa sezione del video, il presentatore introduce il corso di apprendimento per rinforzo e delinea i diversi argomenti che saranno trattati durante il corso. Spiega che il corso è progettato per colmare il divario tra teoria e implementazione pratica e copre tutto, dall'impostazione dell'ambiente RL alla creazione di ambienti personalizzati. Il relatore offre una panoramica di alto livello dell'apprendimento per rinforzo, delle sue applicazioni e di alcuni dei suoi limiti. Il corso fornirà esperienza pratica nella formazione di agenti di apprendimento per rinforzo e test e valutazione utilizzando diversi algoritmi e architetture, oltre a coprire tre diversi progetti incentrati sull'ambiente di breakout, sull'ambiente di guida autonoma e sugli ambienti personalizzati.
  
  
• 00:05:00 In questa sezione del video "Reinforcement Learning in 3 Hours", l'istruttore spiega i concetti fondamentali dell'apprendimento per rinforzo. Un agente di apprendimento per rinforzo apprende in base alle ricompense che ottiene dall'ambiente intraprendendo azioni diverse. L'agente osserva l'ambiente per massimizzare le sue ricompense nel tempo prendendo determinate decisioni. L'istruttore discute anche alcune applicazioni pratiche dell'apprendimento per rinforzo, come la guida autonoma, il commercio di titoli e la ricerca dell'architettura della rete neurale.
  
  
• 00:10:00 In questa sezione, il video illustra alcune delle applicazioni più diffuse dell'apprendimento per rinforzo, inclusa la robotica, in cui è possibile utilizzare ambienti simulati per addestrare i robot a eseguire compiti specifici. Il video menziona anche i giochi come un'altra applicazione popolare in cui la funzione di ricompensa può variare ogni volta, rendendola un ambiente adatto per l'apprendimento per rinforzo. Vengono discussi anche i limiti dell'apprendimento per rinforzo, compreso il presupposto che l'ambiente sia markoviano e il fatto che l'addestramento può richiedere molto tempo e essere instabile. Viene discussa la configurazione per il modello di apprendimento per rinforzo, che include l'installazione della libreria delle linee di base stabili da OpenAI e l'utilizzo delle sue utili guide e documentazione.
  
  
• 00:15:00 In questa sezione, l'istruttore introduce il corso e delinea i 10 diversi passaggi che verranno trattati. Il primo passaggio consiste nell'importare e caricare le dipendenze necessarie, comprese le baseline stabili, una libreria open source per l'apprendimento per rinforzo. L'istruttore spiega i diversi algoritmi disponibili all'interno della libreria e i vantaggi dell'utilizzo di PPO (Proximal Policy Optimization). Le dipendenze includono anche OS, per la funzionalità del sistema operativo, e gym, per la creazione e l'utilizzo degli ambienti. Nel complesso, il processo è semplice e richiede solo poche righe di codice per iniziare con linee di base stabili.
  
  
• 00:20:00 In questa sezione, l'istruttore discute le dipendenze e gli ambienti richiesti per l'apprendimento per rinforzo. Introducono Stable Baselines, che consente un apprendimento automatico più rapido attraverso la vettorializzazione degli ambienti, e il wrapper Dummy Vec Env. Spiegano anche come OpenAI Gym può essere utilizzato per creare ambienti simulati, che possono ridurre i costi e consentire una produzione di modelli più rapida. Forniscono esempi di ambienti reali, come un robot, nonché ambienti simulati, come OpenAI Gym, che ha molta documentazione e supporto.
  
  
• 00:25:00 In questa sezione del video, l'istruttore discute lo standard per la creazione di ambienti di apprendimento per rinforzo, che è OpenAI Gym. Spiega che OpenAI Gym fornisce ambienti predefiniti, inclusi quelli basati su robot reali come Fetch Robot e Shadow Hand Robot. Spiega inoltre i diversi tipi di spazi supportati da OpenAI Gym, inclusi box, discrete, tuple, dict, multi-binary e multi-discrete. Nota che questi spazi sono usati per rappresentare i diversi tipi di valori o azioni che gli agenti possono intraprendere nell'ambiente. L'istruttore introduce quindi l'ambiente di controllo classico, in particolare il problema CartPole, come esempio che utilizzerà per addestrare un agente di apprendimento per rinforzo. L'obiettivo è bilanciare un raggio spostandolo a sinistra oa destra usando due azioni.
  
  
• 00:30:00 In questa sezione, l'istruttore spiega come caricare e testare un ambiente utilizzando OpenAI Gym. Iniziano creando un'istanza dell'ambiente CartPole-v0 utilizzando due righe di codice. Quindi, dimostrano come testare l'ambiente eseguendo il looping di più episodi e utilizzando env.reset() per ottenere il set iniziale di osservazioni. Queste osservazioni verranno successivamente passate a un agente di apprendimento per rinforzo per determinare l'azione migliore per massimizzare la ricompensa. L'istruttore rileva l'importanza di comprendere l'ambiente prima di implementare qualsiasi algoritmo.
  
  
• 00:35:00 In questa sezione, l'istruttore spiega il codice utilizzato per campionare un ambiente nell'apprendimento per rinforzo. Il codice imposta un numero massimo di passaggi per l'ambiente, imposta un contatore di punteggio e genera un'azione casuale basata sullo spazio azione definito dall'ambiente. Le osservazioni restituite dall'ambiente dopo ogni azione sono accompagnate da una ricompensa e da un valore che indica se l'episodio è compiuto. I risultati vengono stampati e l'ambiente viene chiuso dopo il test. L'istruttore spiega anche il concetto di uno spazio di osservazione e dimostra come può essere campionato.
  
  
• 00:40:00 In questa sezione, l'istruttore spiega le due parti dell'ambiente, lo spazio di azione e lo spazio di osservazione, e come sono rappresentate nella documentazione di OpenAI Gym. Lo spazio di osservazione consiste di quattro valori che rappresentano la posizione del carrello, la velocità, l'angolo dei poli e le velocità angolari dei poli. D'altra parte, lo spazio azione ha due possibili azioni, zero o uno, dove zero spinge il carrello a sinistra e uno spinge il carrello a destra. La sezione evidenzia anche i diversi tipi di algoritmi nell'apprendimento per rinforzo, basati su modelli e senza modelli, e in che modo differiscono. L'istruttore si concentra sull'apprendimento per rinforzo senza modello e approfondisce gli algoritmi A2C e PPO, che verranno utilizzati nella fase di addestramento.
  
  
• 00:45:00 n questa sezione del video, l'istruttore spiega come scegliere l'algoritmo di apprendimento per rinforzo appropriato in base allo spazio di azione dell'ambiente utilizzato. Continua spiegando i diversi tipi di algoritmi disponibili in Stable Baselines, come A2C, DDPG, DQN, HER, PPO, SAC e TD3, e con quali spazi di azione funzionano meglio. L'istruttore discute anche le metriche di allenamento che dovrebbero essere considerate durante l'allenamento, come metriche di valutazione, metriche di tempo, metriche di perdita e altre metriche. Ricorda agli utenti che Stable Baselines può essere installato con o senza accelerazione GPU e fornisce istruzioni per l'installazione di PyTorch se si desidera l'accelerazione GPU.
  
  
• 00:50:00 In questa sezione, l'istruttore discute come impostare la piattaforma di calcolo per l'apprendimento per rinforzo, che è fondamentale per coloro che vogliono sfruttare l'accelerazione della GPU. CUDA e cuDNN sono supportati solo su GPU NVIDIA, quindi gli utenti devono assicurarsi di disporre di una GPU NVIDIA per utilizzare CUDA per sfruttare l'accelerazione GPU. D'altra parte, le GPU AMD sono supportate da RockM, un pacchetto beta disponibile solo su Linux. L'istruttore sottolinea inoltre che il deep learning tradizionale può vedere un miglioramento delle prestazioni maggiore dall'utilizzo di una GPU rispetto all'apprendimento per rinforzo. Infine, l'istruttore definisce il percorso del registro e istanzia l'algoritmo e l'agente.
  
  
• 00:55:00 In questa sezione, l'istruttore dimostra come eseguire il wrapping di un ambiente non vettorializzato all'interno di un ambiente vettorializzato fittizio utilizzando una funzione lambda. Quindi, definiscono il modello, che è l'agente che verrà addestrato, come PPO e passano attraverso il percorso di registro della policy, dell'ambiente, dettagliato e tensorboard come argomenti. L'istruttore prosegue spiegando i vari iperparametri che possono essere trasmessi all'algoritmo PPO. Infine, dimostrano come addestrare il modello utilizzando la funzione model.learn e passando attraverso il numero di fasi temporali per cui addestrarlo, che in questo esempio è impostato su 20.000. Dopo che il modello è stato addestrato, l'istruttore lo testa e controlla le metriche di addestramento.

Parte 2

• 01:00:00 In questa sezione del video, l'istruttore mostra come salvare e ricaricare un modello addestrato. Il modello viene salvato utilizzando la funzione `model.save()` e viene definito un percorso per individuare il modello salvato. L'istruttore mostra quindi come eliminare il modello salvato e ricaricarlo utilizzando la funzione `ppo.load()`. Il passaggio successivo consiste nel testare il modello addestrato per verificarne le prestazioni. L'istruttore spiega che le metriche di rollout dipendono dall'algoritmo utilizzato per l'addestramento e mostra che l'algoritmo "A2C" fornisce queste metriche durante l'addestramento, mentre l'algoritmo "PPO" richiede un comando esplicito per generare queste metriche.
  
  
• 01:05:00 In questa sezione, il video spiega come utilizzare il metodovalua_policy per testare le prestazioni del modello e determinare se il modello PPO è considerato "risolto" in questo caso particolare. Il metodovalua_policy è un modo per testare le prestazioni di un modello e il modello viene considerato risolto se ottiene una media di 200 o più. Il metodo viene passato attraverso il modello, l'ambiente, quanti episodi testare e se il rendering è richiesto o meno. La ricompensa media e la deviazione standard in quella ricompensa sono i valori che ottieni da assess_policy e la chiusura dell'ambiente viene eseguita utilizzando emv.close. Infine, il video evidenzia come distribuire il modello in una funzione incapsulata.
  
  
• 01:10:00 In questa sezione, l'istruttore dimostra come utilizzare le osservazioni dall'ambiente per prevedere l'azione migliore utilizzando l'agente, al fine di massimizzare i premi. Il blocco di codice mostra come apportare modifiche chiave per utilizzare model.predict invece di env.actionspace.sample per eseguire azioni utilizzando il modello. L'istruttore mostra che l'agente si comporta meglio dei passi casuali e bilancia il palo. Il codice mostra anche le osservazioni passate alla funzione model.predict, con due valori restituiti, l'azione del modello e lo stato successivo. Il primo valore viene utilizzato qui per determinare l'azione migliore per l'agente.
  
  
• 01:15:00 In questa sezione, l'istruttore spiega i componenti fondamentali dell'apprendimento per rinforzo: l'agente, l'ambiente, l'azione e la ricompensa. Dimostra come definire un ambiente e addestrare un modello utilizzando l'apprendimento per rinforzo per accumulare un valore di uno ogni volta mantenendo il palo in posizione verticale e non cadendo. L'istruttore mostra anche come visualizzare i registri di formazione utilizzando TensorBoard per monitorare il processo di formazione.
  
  
• 01:20:00 In questa sezione del video, l'istruttore spiega come utilizzare TensorBoard in un notebook Jupiter per visualizzare le metriche di addestramento di un modello di apprendimento per rinforzo. Dimostra come eseguire il comando TensorBoard utilizzando un comando magico e mostra come specificare il percorso del registro di addestramento. L'istruttore mostra anche come visualizzare le metriche di addestramento, come fotogrammi al secondo, perdita di entropia, tasso di apprendimento e perdita di gradiente di policy, in TensorBoard. Sottolinea che la ricompensa media è la metrica più importante da monitorare durante l'ottimizzazione delle prestazioni del modello. Conclude invitando feedback e commenti da parte degli spettatori.
  
  
• 01:25:00 In questa sezione, il video discute due metriche chiave per determinare le prestazioni di un modello di apprendimento per rinforzo: le metriche di ricompensa e la durata media dell'episodio. Il video fornisce anche tre strategie per migliorare le prestazioni del modello se non funziona bene, tra cui l'addestramento per un periodo più lungo, l'ottimizzazione degli iperparametri e l'esplorazione di diversi algoritmi. La sezione approfondisce quindi callback, algoritmi alternativi e architetture, discutendo in particolare come impostare un callback per interrompere l'addestramento una volta raggiunta una soglia di ricompensa ed esplorare diverse architetture e algoritmi di reti neurali. Il video evidenzia anche l'importanza di utilizzare i callback per i modelli di grandi dimensioni che richiedono un tempo di addestramento più lungo.
  
  
• 01:30:00 In questa sezione, l'istruttore spiega come utilizzare i callback nell'apprendimento per rinforzo per una formazione più flessibile ed efficiente. Nell'esempio vengono utilizzate due callback: la stop callback e la eval callback. Il callback stop specifica la ricompensa media dopo la quale l'addestramento dovrebbe interrompersi, mentre il callback eval valuta il miglior nuovo modello e controlla se ha superato la soglia del premio. L'istruttore dimostra anche come modificare la politica specificando una nuova architettura di rete neurale. Nel complesso, i callback forniscono un maggiore controllo sui modelli di apprendimento per rinforzo, consentendo un addestramento più personalizzato ed efficace.
  
  
• 01:35:00 In questa sezione, il relatore discute il processo di specificare un'architettura di rete per un attore personalizzato e una funzione di valore in una rete neurale. Questo può essere fatto semplicemente cambiando il numero di unità e livelli e passandolo al modello. Il relatore sottolinea inoltre che gli estrattori di funzionalità personalizzate possono essere definiti e mostra come utilizzare un algoritmo alternativo come DQN invece di PPO e mette in evidenza altri algoritmi disponibili in Stable Baselines. Il relatore conclude mostrando il modello DQN addestrato.
  
  
• 01:40:00 In questa sezione, l'istruttore discute i progetti che gli studenti costruiranno utilizzando tecniche di apprendimento per rinforzo. Inizieranno con Project One, che è il gioco Breakout in Atari. Quindi, affronteranno anche il Progetto Due, dove utilizzeranno l'apprendimento per rinforzo per costruire un'auto da corsa per simulare la guida autonoma. Infine, lavoreranno su Project Three, che prevede la creazione di ambienti personalizzati utilizzando gli spazi OpenAI Gym. L'istruttore spiega anche come l'importazione delle librerie e delle dipendenze necessarie per i progetti sia simile a quella del corso principale e dovranno solo utilizzare algoritmi diversi a seconda del progetto.
  
  
• 01:45:00 In questa sezione, l'istruttore video spiega come configurare l'ambiente Atari per l'apprendimento per rinforzo in Python. A causa delle recenti modifiche, gli utenti devono scaricare i file raw da atarimania.com ed estrarli in una cartella per poter utilizzare l'ambiente. Dopo aver installato i pacchetti e le dipendenze necessari, gli utenti possono testare l'ambiente utilizzando le funzioni "emv.reset" e "emv.action_space". Lo spazio di osservazione è una scatola che rappresenta un'immagine con le dimensioni 210x160x3. L'istruttore dimostra anche come testare un modello all'interno dell'ambiente.
  
  
• 01:50:00 In questa sezione, l'istruttore mostra il codice per giocare a Breakout utilizzando azioni casuali e sottolinea che l'addestramento del modello può richiedere molto tempo. Per velocizzare la formazione, l'istruttore vettorializza l'ambiente e allena quattro diversi ambienti contemporaneamente. L'ambiente utilizzato è l'ambiente basato su immagini, al contrario della versione RAM di Breakout, poiché verrà utilizzata la politica CNN. Viene visualizzato il codice per l'impostazione del modello, inclusa la specifica del percorso di registro e l'algoritmo A2C con la policy CNN.
  
  
• 01:55:00 In questa sezione, l'istruttore video utilizza l'apprendimento per rinforzo per addestrare un modello a giocare al gioco Atari "Breakout". Il modello utilizza una policy di rete neurale convoluzionale (CNN), che è più veloce da addestrare rispetto a una policy perceptron multistrato. L'ambiente viene definito utilizzando la funzione make_atari di OpenAI Gym e la vettorizzazione viene utilizzata per accelerare il processo di allenamento. Il modello viene addestrato per 100.000 passaggi e, dopo averlo salvato e ricaricato, viene valutato utilizzando il metodo della politica di valutazione. Il modello finale raggiunge una ricompensa media per episodio di 6,1 con una deviazione standard di 1,9, un miglioramento significativo rispetto a un agente casuale. L'istruttore fornisce anche informazioni su un modello pre-addestrato che è stato addestrato per 300.000 passi e su come caricarlo e testarlo.

Parte 3

• 02:00:00 In questa sezione, l'istruttore discute su come gestire i problemi di congelamento quando si lavora con l'ambiente, in particolare Atari. Se l'ambiente si blocca, il notebook deve essere riavviato e il kernel deve essere riavviato dopo aver salvato il modello. L'istruttore mostra quindi come addestrare un agente di apprendimento per rinforzo per il breakout, esaminando il processo di importazione delle dipendenze, installando le ROM Atari, vettorializzando l'ambiente per l'addestramento su quattro ambienti Atari contemporaneamente, addestrando l'agente e infine valutando e salvando il modello. L'istruttore mostra anche l'impatto dell'addestramento del modello più a lungo e rende i modelli addestrati disponibili nel repository Github affinché gli studenti possano provarli da soli.
  
  
• 02:05:00 In questa sezione del video sull'apprendimento per rinforzo in tre ore, l'istruttore inizia mostrando i risultati del Progetto 1, che prevedeva l'addestramento di un modello per giocare utilizzando l'apprendimento per rinforzo. Il modello ha ottenuto risultati significativamente migliori rispetto ai modelli precedenti, con una ricompensa media su 50 episodi di 22,22 e una deviazione standard di 9,1. L'istruttore introduce quindi il Progetto 2, che prevede l'utilizzo dell'apprendimento per rinforzo per la guida autonoma utilizzando l'ambiente delle auto da corsa. Per configurare l'ambiente, l'istruttore spiega che swig deve essere installato e devono essere installate due nuove dipendenze, box 2d e piglet. L'istruttore passa quindi attraverso il processo di test dell'ambiente e di importazione delle dipendenze necessarie.
  
  
• 02:10:00 In questa sezione, il video discute lo spazio di osservazione e azione dell'ambiente delle corse automobilistiche per l'apprendimento per rinforzo. Lo spazio di osservazione è un'immagine 96 x 96 x 3 con valori compresi tra 0 e 255, mentre lo spazio di azione è compreso tra meno uno e uno per tre diversi valori. La funzione di ricompensa è negativa 0,1 per ogni fotogramma e più 1000 diviso n per ogni traccia visitata. Il gioco è considerato risolto quando l'agente può ottenere costantemente 900 o più punti, il che può richiedere del tempo per essere raggiunto con l'addestramento. Il video passa quindi all'addestramento di un modello utilizzando l'algoritmo PPO e mostra come testare l'ambiente di gara utilizzando il modello addestrato.
  
  
• 02:15:00 In questa sezione, l'istruttore imposta l'ambiente per l'auto a guida autonoma utilizzando OpenAI Gym e lo avvolge all'interno di un Vectorize Environment Wrapper fittizio. Quindi, l'agente e il modello vengono specificati utilizzando l'algoritmo PPO e il modello viene addestrato per 100.000 passaggi. Il modello salvato viene caricato e valutato nell'ambiente e, nonostante la mancanza di trazione dell'auto ad alta potenza, non avanza ma va in testacoda e fa ciambelle. Infine, l'ambiente è chiuso e l'istruttore carica un modello addestrato per 438.000 passaggi da testare.
  
  
• 02:20:00 In questa sezione, l'istruttore carica un modello di auto a guida autonoma addestrato per 438.000 passi e lo testa in pista. Sebbene sia più lento, segue la traccia e ottiene un punteggio molto più alto rispetto al modello precedente addestrato per 100.000 passi. L'istruttore spiega che l'addestramento di agenti di apprendimento per rinforzo per un periodo di tempo più lungo può produrre modelli molto migliori e, idealmente, questo modello avrebbe dovuto essere addestrato per 1-2 milioni di passaggi per funzionare in modo ottimale. Dimostra come testare il modello utilizzando uno snippet di codice dal tutorial principale, che mostra che, anche se addestrato solo sulle immagini, il modello può navigare con successo lungo la pista. Alla fine, l'istruttore ha addestrato questo modello per due milioni di passaggi aggiuntivi, migliorandone le prestazioni e raggiungendo una stima di ricompensa di circa 700.
  
  
• 02:25:00 In questa sezione, l'istruttore carica ed esegue un modello che ha prestazioni significativamente migliori rispetto ai modelli precedenti che ha addestrato, nonostante occasionalmente giri in curva. Mostra il punteggio di valutazione del modello, che ha raggiunto gli 800 punti, un miglioramento significativo rispetto ai modelli precedenti. Osserva che questo modello è stato addestrato per una durata maggiore e presentava un'elevata deviazione standard. L'istruttore introduce quindi l'ultimo progetto, che prevede l'utilizzo di linee di base stabili per l'apprendimento per rinforzo in ambienti personalizzati. Importa le dipendenze necessarie e incoraggia gli spettatori a contattare se incontrano difficoltà.
  
  
• 02:30:00 In questa sezione del video, l'istruttore esamina le varie dipendenze dalla palestra o le dipendenze dalla palestra OpenAI, gli aiutanti e il materiale di base stabile che verrà utilizzato nel corso di apprendimento per rinforzo. Importano gym, che è l'importazione standard, la classe dell'ambiente gym da env e i diversi tipi di spazi come discrete, box, dict, tuple, multi-binary, multi-discrete. L'istruttore illustra come utilizzare ciascuno di questi spazi e come possono essere utilizzati per scopi diversi. L'istruttore passa anche attraverso i diversi helper che sono stati importati, come numpy, random e os, e le cose di base stabili, tra cui ppo, common.vec_env, dummy_vec_nv e la funzione assess_policy.
  
  
• 02:35:00 In questa sezione del video, il relatore discute i diversi tipi di spazi disponibili in OpenAI Gym per l'apprendimento per rinforzo. Questi spazi includono discrete, box, tuple, dict, multi-binary e multi-discrete. Il presentatore fornisce esempi e spiegazioni per ciascuno di questi spazi. Il video prosegue poi discutendo la costruzione di un ambiente simulato per addestrare un agente a regolare la temperatura di una doccia. L'obiettivo finale è raggiungere una temperatura compresa tra 37 e 39 gradi, ma l'agente non lo sa a priori e deve imparare per tentativi ed errori.
  
  
• 02:40:00 In questa sezione, l'istruttore costruisce un guscio per un ambiente doccia implementando le quattro funzioni chiave. Queste funzioni sono init, step, render e reset. La funzione init inizializza l'ambiente definendo lo spazio di azione, lo spazio di osservazione e lo stato iniziale. La funzione step esegue un'azione e la applica all'ambiente. La funzione render visualizza l'ambiente. La funzione di ripristino riporta l'ambiente allo stato iniziale. L'istruttore imposta anche una durata dell'episodio di 60 secondi per l'ambiente.
  
  
• 02:45:00 In questa sezione, l'istruttore definisce la funzione passo per l'ambiente doccia, che contiene sei blocchi di codice. Il primo blocco applica l'impatto dell'azione sullo stato, con zero, uno e due come tre azioni possibili. Zero diminuisce la temperatura di un grado, uno lascia la stessa temperatura e due aumenta la temperatura di un grado. Il secondo blocco diminuisce di un secondo il tempo della doccia. Il terzo blocco definisce la ricompensa, con una ricompensa di uno se la temperatura è compresa tra 37 e 39 gradi e -1 se è al di fuori di tale intervallo. Il quarto blocco verifica se la doccia è terminata e imposta done su vero se il tempo della doccia è minore o uguale a zero. Il quinto blocco crea un dizionario di informazioni vuoto e il blocco finale restituisce lo stato, la ricompensa, se la doccia è terminata e il dizionario. La funzione di ripristino ripristina la temperatura iniziale al valore predefinito e ripristina il tempo della doccia a 60 secondi.
  
  
• 02:50:00 In questa sezione, l'istruttore spiega come creare un ambiente personalizzato per l'apprendimento per rinforzo utilizzando Python. Dimostra come definire lo stato dell'ambiente e i suoi spazi di osservazione e azione. L'istruttore mostra anche come testare e addestrare il modello utilizzando l'ambiente definito e come salvare il modello addestrato dopo l'apprendimento. Afferma che gli ambienti di gioco richiederanno più tempo per l'addestramento rispetto agli ambienti semplici e incoraggia a tenerlo presente per pianificare i progetti e impegnarsi con i clienti.
  
  
• 02:55:00 In questa sezione, l'istruttore dimostra come testare e salvare il modello addestrato. Utilizzano il metodo 'evaluate policy' per testare le prestazioni del modello, quindi salvano il modello utilizzando il metodo 'model.save'. Inoltre, forniscono un breve riepilogo del corso, che copre una vasta gamma di argomenti, dalla configurazione dell'ambiente utilizzando linee di base stabili all'addestramento di modelli con diversi algoritmi, tra cui PPO, A2C e DQN. Discutono anche della creazione di ambienti personalizzati e di progetti di costruzione, come addestrare un modello per giocare a Breakout o correre con un'auto su una pista.
  
  
• 03:00:00 In questa sezione, l'istruttore consiglia risorse aggiuntive per un ulteriore apprendimento, tra cui il corso Reinforcement Learning di David Silva, un libro intitolato Reinforcement Learning: An Introduction di Richard Sutton e Andrew Bartos, nonché l'esplorazione dell'ottimizzazione degli iperparametri e la creazione di ambienti personalizzati e l'implementazione di soluzioni end-to-end come la costruzione di un robot con asta del carrello e l'addestramento in un ambiente simulato prima di implementarlo in un ambiente reale utilizzando un Raspberry Pi. L'istruttore incoraggia il feedback e le domande degli spettatori e li ringrazia per essersi sintonizzati.

[MetaQuotes]

Rilevamento della lingua dei segni tramite RICONOSCIMENTO AZIONE con Python | Modello di apprendimento profondo LSTM

Codice: https://github.com/nicknochnack/ActionDetectionforSignLanguage

Rilevamento della lingua dei segni tramite RICONOSCIMENTO AZIONE con Python | Modello di apprendimento profondo LSTM

In questo video di YouTube intitolato "Sign Language Detection using ACTION RECOGNITION with Python | LSTM Deep Learning Model", il relatore spiega come creare un flusso di rilevamento della lingua dei segni in tempo reale utilizzando il rilevamento delle azioni e modelli chiave. Il presentatore utilizza OpenCV e MediaPipe Holistic per estrarre i punti chiave da mani, viso e corpo, quindi TensorFlow e Keras per costruire un modello LSTM che prevede l'azione dimostrata in una sequenza di fotogrammi. Il presentatore esegue il processo di accesso ed estrazione dei punti chiave dalla webcam, imposta un loop per accedere alla webcam e semplifica il rilevamento del linguaggio dei segni applicando i punti di riferimento all'ultimo fotogramma acquisito dalla webcam. Dimostrano anche come modificare il codice per gestire i punti chiave mancanti e aggiungere la gestione degli errori al modello di posa e al rilevamento dei punti di riferimento del volto. Infine, il presentatore spiega la funzione di estrazione dei punti chiave per il rilevamento della lingua dei segni utilizzando il riconoscimento delle azioni con Python.

Il video fornisce una spiegazione dettagliata di come creare un modello di rilevamento della lingua dei segni utilizzando il riconoscimento delle azioni con Python. Per raccogliere i dati, il presentatore crea cartelle per ogni azione e sequenza e modifica il ciclo MediaPipe per raccogliere 30 valori di punti chiave per video per ogni azione. I dati vengono pre-elaborati creando etichette e funzionalità per il modello di deep learning LSTM e il modello viene addestrato utilizzando TensorFlow e Keras. Il modello addestrato viene valutato utilizzando una matrice di confusione multi-etichetta e una funzione di punteggio di accuratezza. Infine, il rilevamento in tempo reale viene stabilito creando nuove variabili per il rilevamento, concatenando i frame e applicando la logica di previsione, con una variabile di soglia implementata per rendere i risultati al di sopra di una certa metrica di confidenza.

Il video tutorial mostra come utilizzare Python e un modello di deep learning LSTM per il rilevamento della lingua dei segni utilizzando il riconoscimento delle azioni. L'oratore ha esaminato la logica di previsione e ha spiegato il codice, rendendolo facile da capire. Hanno anche mostrato agli spettatori come regolare il codice utilizzando il metodo append, aumentando la soglia di rilevamento e aggiungendo la visualizzazione della probabilità per rendere il rilevamento visivamente convincente. Il relatore ha anche spiegato come verificare se il risultato è al di sopra della soglia, come manipolare le probabilità e come estendere e modificare il progetto aggiungendo ulteriori azioni o visualizzazioni. Infine, il relatore ha presentato la logica aggiuntiva del modello, che riduce al minimo i falsi rilevamenti e migliora l'accuratezza del modello, insieme a un invito a supportare il video e il canale.

• 00:00:00 In questa sezione del video, il creatore spiega il proprio obiettivo di produrre un flusso di rilevamento della lingua dei segni in tempo reale utilizzando il rilevamento delle azioni e modelli chiave. Utilizzeranno MediaPipe Holistic per estrarre i punti chiave da mani, viso e corpo, quindi utilizzeranno TensorFlow e Keras per costruire un modello LSTM che prevede l'azione dimostrata in una sequenza di fotogrammi. Il processo include la raccolta di dati sui punti chiave, l'addestramento di una rete neurale, la valutazione dell'accuratezza e il test del modello in tempo reale utilizzando OpenCV e una webcam. Il creatore delinea 11 passaggi per raggiungere questo processo e inizia installando e importando le dipendenze.
  
  
• 00:05:00 In questa sezione, il relatore discute le diverse dipendenze che verranno utilizzate nel progetto, tra cui OpenCV, MediaPipe, scikit-learn, NumPy, Matplotlib e TensorFlow. Dopo aver importato queste dipendenze, il relatore passa attraverso il processo di accesso ed estrazione dei punti chiave dalla webcam utilizzando OpenCV e MediaPipe Holistic. Il relatore imposta quindi un loop per accedere alla webcam ed eseguire il rendering di più fotogrammi sullo schermo, consentendo il test in tempo reale del progetto. Questo ciclo verrà utilizzato più volte durante il progetto, anche durante l'estrazione dei frame e il test del progetto. Tutto il codice utilizzato nel progetto sarà reso disponibile su Github, inclusi i pesi finali addestrati.
  
  
• 00:10:00 In questa sezione del video, il presentatore spiega come accedere alla webcam utilizzando OpenCV e iniziare a scorrere tutti i frame. Il presentatore utilizza la funzione di "acquisizione video" per leggere il feed dalla webcam e avvia un ciclo che leggerà, visualizzerà e attenderà che la pressione di un tasto esca dal ciclo. Il presentatore spiega anche come interrompere il loop con garbo e come risolvere i problemi relativi al numero del dispositivo se la webcam non viene visualizzata. Infine, il presentatore introduce MediaPipe Holistic e MediaPipe Drawing Utilities, due moduli Python utilizzati per scaricare e sfruttare il modello olistico per il rilevamento della posa e disegnare i punti di riferimento della posa su un'immagine.
  
  
• 00:15:00 In questa sezione della trascrizione, l'oratore imposta una funzione per facilitare il rilevamento della lingua dei segni. La funzione accetta un'immagine e un modello olistico di media pipe e passa attraverso una serie di passaggi, tra cui la conversione del colore da BGR a RGB, il rilevamento e la riconversione dell'immagine in BGR, prima di restituire l'immagine e i risultati al ciclo per rendering. I passaggi vengono eseguiti in modo simmetrico per garantire che l'immagine sia impostata su non scrivibile prima del rilevamento e di nuovo su scrivibile in seguito. L'oratore spiega anche la funzione cvtColor utilizzata per convertire il colore dell'immagine e mostra come chiamare la funzione di rilevamento del tubo multimediale nel ciclo.
  
  
• 00:20:00 In questa sezione, il presentatore spiega come accedere al modello MediaPipe utilizzando un'istruzione "with" e imposta la confidenza iniziale e di tracciamento. Mostrano anche come accedere e visualizzare i diversi tipi di punti di riferimento: viso, mano sinistra e destra e punti di riferimento di posa. Il presentatore mostra quindi come utilizzare MediaPipe Holistic per rilevare i punti di riferimento e visualizza i risultati sul frame. Infine, mostrano come rendere i punti di riferimento sullo schermo scrivendo una funzione.
  
  
• 00:25:00 In questa sezione, lo YouTuber imposta una nuova funzione chiamata "draw_landmarks" che renderà i dati dei punti di riferimento su un'immagine per consentire la visualizzazione dei diversi punti di riferimento rilevati dai modelli di tubi multimediali utilizzati nel progetto. La funzione utilizza la funzione helper "mp.drawing" fornita da media pipe per disegnare i punti di riferimento e richiede anche l'immagine e i dati dei punti di riferimento come input. La funzione consente inoltre di specificare le mappe di connessione e le opzioni di formattazione. Lo YouTuber procede quindi a dimostrare come utilizzare la funzione "plot.imshow" da matplotlib per visualizzare l'ultimo fotogramma acquisito dalla webcam.
  
  
• 00:30:00 In questa sezione, il relatore corregge il colore dell'immagine e applica i punti di riferimento all'immagine passandoli attraverso la funzione "disegna punti di riferimento". Si accede ai risultati del modello di rilevamento della pipe multimediale come ultimo frame e risultati dell'esecuzione del ciclo. I metodi "mp_drawing.draw_landmarks" si applicano al fotogramma corrente per eseguire il rendering di tutte le connessioni di mani, pose e volti. L'oratore applica quindi la funzione "disegna punti di riferimento" al ciclo in tempo reale e prima del rendering applica la formattazione utilizzando la "specifica del disegno del punto di riferimento" e la "specifica del disegno della connessione" per disegnare rispettivamente i punti e le connessioni. Infine, l'oratore crea una nuova funzione chiamata "disegna punti di riferimento stile" per personalizzare la funzione "disegna punti di riferimento" se lo si desidera.
  
  
• 00:35:00 In questa sezione, il relatore aggiorna la formattazione per la funzione di disegno dei punti di riferimento, aggiungendo due parametri aggiuntivi per la funzione mp_drawing.drawing_spec: colore e raggio del cerchio. Dimostrano le modifiche per il punto di riferimento della faccia e spiegano che il primo parametro colora il punto di riferimento e il secondo parametro colora la connessione. L'oratore quindi copia le modifiche alla funzione per ciascuno dei modelli di posa e mano, dando a ciascun modello colori unici. Le modifiche sono puramente estetiche e non influiranno sulle prestazioni, ma dimostrano i diversi modelli in azione.
  
  
• 00:40:00 In questa sezione, il video tutorial spiega come estrarre i valori dei punti chiave dalla variabile dei risultati del modello Olistico MediaPipe in modo resiliente concatenandoli in un array numpy e gestendo gli errori. Il tutorial spiega come estrarre i valori per un punto di riferimento e aggiornarlo per tutti i punti di riferimento utilizzando un ciclo e una comprensione dell'elenco. L'array finale con tutti i punti di riferimento viene quindi appiattito per avere tutti i valori in un unico array anziché in più set di punti di riferimento.
  
  
• 00:45:00 In questa sezione, il presentatore spiega come modificare il codice da gestire quando non ci sono punti chiave a causa della mano fuori dall'inquadratura. Iniziano mostrando che i punti di riferimento a sinistra hanno tre valori ciascuno e ci sono 21 punti di riferimento per un totale di 63 valori necessari. Quindi applicano un'istruzione if che sostituisce i valori mancanti con un array numpy vuoto. Questa stessa modifica viene poi applicata ai punti di riferimento di destra, che hanno anch'essi 63 valori. Il codice estrae i diversi punti chiave concatenando i valori x, yez insieme in un unico grande array e quindi appiattendolo nel formato appropriato per l'utilizzo nel modello LSTM.
  
  
• 00:50:00 In questa sezione, il relatore spiega come aggiungere la gestione degli errori al modello di posa e al rilevamento dei punti di riferimento del viso e crea una funzione chiamata "extract_key_points" per estrarre i punti chiave necessari per il rilevamento dei punti di riferimento e il rilevamento delle azioni. La funzione utilizza array numpy e scorre i risultati per estrarre i valori x, yez per ogni punto di riferimento e quindi li appiattisce in un array. Il relatore menziona inoltre che il codice sarà disponibile nella descrizione del video e invita gli spettatori a porre domande nei commenti.
  
  
• 00:55:00 In questa sezione del video, il relatore spiega la funzione di estrazione dei punti chiave per il rilevamento della lingua dei segni utilizzando il riconoscimento dell'azione con Python. La funzione estrae i punti chiave per posa, faccia, mano sinistra e mano destra e li concatena in un array numpy appiattito. Questi punti chiave formano i valori del frame utilizzati per il rilevamento della lingua dei segni utilizzando il rilevamento dell'azione umana. L'oratore imposta anche le variabili per il percorso dei dati esportati e le azioni da rilevare - ciao, grazie e ti amo - utilizzando 30 frame di dati per ogni azione.

• 01:00:00 In questa sezione del video, il presentatore spiega il processo di raccolta dei dati per rilevare il linguaggio dei segni utilizzando il riconoscimento delle azioni con Python. Spiegano che per ciascuna delle tre azioni che vogliono rilevare, raccoglieranno 30 video di dati, con ogni video lungo 30 fotogrammi. Ciò equivale a un bel po 'di dati, ma il presentatore rassicura gli spettatori che lo seguiranno passo dopo passo. Continuano a creare cartelle per ogni azione e sequenza di azioni, in cui i 30 punti chiave di ogni fotogramma di ogni sequenza verranno archiviati come un array numpy. Il presentatore menziona anche che nel passaggio 11 mostreranno agli spettatori come concatenare le parole insieme per formare frasi.
  
  
• 01:05:00 In questa sezione, l'istruttore mostra come raccogliere i dati per il modello di riconoscimento della lingua dei segni. Inizia creando cartelle per le tre diverse classi di segni - ciao, grazie e ti amo - e le corrispondenti cartelle di sequenza individuali. Quindi, modifica il ciclo del tubo multimediale per eseguire il ciclo di ogni azione, video e fotogramma per la raccolta dei dati. Per garantire che i fotogrammi non vengano raccolti troppo rapidamente, aggiunge un'interruzione tra ogni video utilizzando un'istruzione logica. In questo modo, il modello raccoglierà 30 valori di punti chiave per video, costruendo in modo efficace un insieme impilato di tre azioni, ciascuna con 30 video per azione e 30 fotogrammi per video.
  
  
• 01:10:00 In questa sezione, il creatore del video fornisce una spiegazione della logica di raccolta in uno script Python che utilizza OpenCV e modelli di deep learning per rilevare i gesti della lingua dei segni dal video. La logica prevede l'emissione di testo sullo schermo e una pausa ogni secondo fotogramma. Il creatore del video dimostra anche l'uso di np.save per salvare i fotogrammi come array numpy, che sono archiviati in una cartella mp_data. Forniscono quindi il blocco di codice finale per l'estrazione dei punti chiave e il salvataggio dei frame nelle cartelle corrette.
  
  
• 01:15:00 In questa sezione della trascrizione, il relatore spiega la logica applicata per scorrere le loro azioni e sequenze (video), applicare il rilevamento del tubo multimediale, disegnare punti di riferimento stilizzati ed estrarre diversi punti chiave da salvare in cartelle specifiche. Useranno tre azioni (ciao, grazie e ti amo) e raccoglieranno 30 fotogrammi per azione per 30 sequenze. Prima di eseguire questo codice, ricontrollano la presenza di errori e regolano la larghezza della linea per garantire che il carattere non sia oscurato. Una volta eseguito il codice, il pop-up dice "Starting Collection", hanno due secondi per mettersi in posizione per eseguire l'azione e hanno 30 frame per farlo. Il codice dovrebbe essere in grado di eseguire cicli e raccogliere dati all'infinito.
  
  
• 01:20:00 In questa sezione del video, il presentatore mostra come raccogliere dati sulla lingua dei segni utilizzando le librerie MediaPipe e OpenCV in Python. Il presentatore suggerisce di catturare vari angoli dei segni della mano per migliorare le prestazioni del modello e menziona anche che avere 30 sequenze di 30 fotogrammi ciascuna tende a funzionare bene. I punti chiave raccolti da MediaPipe vengono utilizzati al posto dell'immagine per rendere il modello più resiliente in vari scenari. Il presentatore spiega anche che i dati raccolti vengono archiviati come array numpy per un utilizzo futuro.
  
  
• 01:25:00 In questa sezione, il video si concentra sulla pre-elaborazione dei dati e sulla creazione di etichette e funzionalità per il modello di deep learning LSTM. Il video inizia importando le dipendenze e quindi creando una mappa di etichette, che è fondamentalmente un dizionario che rappresenta ciascuna delle diverse azioni. Successivamente, i dati vengono letti e riuniti per strutturarli in un unico grande array con 90 array, ciascuno contenente 30 frame con 1662 valori che rappresentano i punti chiave. Vengono creati due array vuoti, sequenze ed etichette, in cui le sequenze rappresentano i dati della caratteristica e le etichette rappresentano i dati dell'etichetta. Il codice quindi scorre ciascuna delle azioni e delle sequenze, creando un array vuoto per le finestre per rappresentare tutti i diversi fotogrammi per quella particolare sequenza. Infine, numpy.load viene utilizzato per caricare ogni fotogramma.
  
  
• 01:30:00 In questa sezione, l'oratore esegue il processo di pre-elaborazione dei dati memorizzandoli in un array numpy e convertendo le etichette in una rappresentazione codificata a caldo utilizzando la funzione "to_categorical". Quindi utilizzano la funzione "train_test_split" per suddividere i dati in set di addestramento e test. Il set di addestramento è composto da 85 sequenze e il set di test ha cinque sequenze. Il relatore importa anche le dipendenze necessarie, tra cui il modello sequenziale, il livello LSTM e il livello denso, mentre si preparano ad addestrare una rete neurale LSTM utilizzando TensorFlow e Keras.
  
  
• 01:35:00 In questa sezione, il relatore discute le dipendenze necessarie per costruire una rete neurale, tra cui sequenziale, lstm, dense e tensorboard. Spiegano che sequenziale semplifica l'aggiunta di livelli al modello e lstm viene utilizzato per l'analisi temporale e il rilevamento delle azioni. Il relatore mostra anche come impostare i callback di tensorboard per monitorare i progressi dell'addestramento. Procedono quindi a costruire l'architettura della rete neurale, che include l'aggiunta di tre serie di livelli lstm e la specifica delle funzioni di attivazione e della forma di input. Infine, menzionano l'importanza di non riportare le sequenze allo strato denso e raccomandano ulteriori risorse di apprendimento.
  
  
• 01:40:00 In questa sezione del video, il presentatore esamina i diversi tipi di layer aggiunti al modello LSTM, specificando che i tre layer successivi sono tutti layer densi. Ogni strato denso utilizza 64 e 32 unità dense o neuroni completamente connessi con valori di attivazione di ReLU. Il livello finale è il livello delle azioni, che estrae i valori restituiti come tre unità di rete neurale utilizzando il valore di attivazione di softmax. Il modello prevede un'azione come "Ciao" e questo output viene passato attraverso 30 fotogrammi più 1.662 punti chiave e preelaborato per estrarre le azioni. Il presentatore spiega come sono arrivati a utilizzare MediaPipe e il livello LSTM discutendo la ricerca e lo sviluppo che hanno condotto. Infine, il modello viene compilato utilizzando l'entropia incrociata categoriale come funzione di perdita, ed è adattato e addestrato con x train e y train per il numero specificato di epoche.
  
  
• 01:45:00 In questa sezione, il video mostra il processo di addestramento di un modello di deep learning LSTM per il rilevamento della lingua dei segni utilizzando il riconoscimento delle azioni con Python. Il modello utilizza il modello di MediaPipe Holistic, che non richiede un generatore di dati poiché i dati possono essere inseriti nella memoria. Il video mostra come impostare il processo di addestramento con TensorBoard e come monitorare l'accuratezza e la perdita del modello durante l'addestramento in TensorBoard. Il video include anche come interrompere il processo di addestramento una volta raggiunto un ragionevole livello di accuratezza e come ispezionare la struttura del modello utilizzando la funzione model.summary.
  
  
• 01:50:00 In questa sezione, il relatore addestra un modello e fa previsioni utilizzando il modello salvato. Il modello utilizza la tecnica di deep learning LSTM per identificare le azioni dal linguaggio dei segni. Il modello prevede la più alta probabilità di azione rilevata con una funzione softmax. Il valore previsto viene confrontato con il valore effettivo per valutare le prestazioni del modello. L'oratore salva il modello addestrato come action.h5 e lo ricarica con una funzione di compilazione e caricamento. Importando le metriche da sklearn, il relatore valuta le prestazioni della matrice di confusione multietichetta del modello.
  
  
• 01:55:00 In questa sezione del video, il relatore spiega come valutare le prestazioni del modello addestrato utilizzando una matrice di confusione multietichetta e una funzione di punteggio di accuratezza. La matrice di confusione rappresenta i veri positivi e i veri negativi e maggiore è il numero di questi valori nell'angolo in alto a sinistra e in basso a destra, migliori sono le prestazioni del modello. La funzione del punteggio di accuratezza fornisce la percentuale di previsioni corrette del modello. Il modello addestrato viene quindi valutato utilizzando i dati di test e il ciclo viene ristabilito per il rilevamento in tempo reale, che comporta la creazione di nuove variabili per il rilevamento, la concatenazione dei frame e l'applicazione della logica di previsione. Viene inoltre implementata una variabile di soglia per visualizzare i risultati al di sopra di una determinata metrica di confidenza.
  
  
• 02:00:00 In questa sezione, il relatore spiega la loro logica di previsione per il rilevamento della lingua dei segni utilizzando il riconoscimento dell'azione con Python e il modello di deep learning LSTM. Iniziano estraendo i punti chiave e aggiungendoli a una sequenza di 30 fotogrammi. Se la lunghezza della sequenza è uguale a 30, eseguono la previsione chiamando model.predict con le dimensioni espanse della sequenza. Quindi stampano la classe prevista utilizzando np.argmax e le azioni definite in precedenza. L'oratore inserisce anche punti chiave all'inizio della sequenza per riordinare la logica e procede ad aggiungere la logica di visualizzazione al codice.
  
  
• 02:05:00 In questa sezione, l'oratore scompone il codice spiegando come il programma controlla se il risultato è al di sopra della soglia estraendo il risultato del punteggio più alto usando "mp.argmax" e passando attraverso "res". La logica del programma è verificare che l'ultima parola corrisponda alla previsione corrente. In caso affermativo, il programma non aggiungerà la lunghezza della frase. Se non corrisponde, il programma aggiungerà l'azione attualmente rilevata al nostro array di frasi. La lunghezza della frase dovrebbe includere solo fino a cinque parole in modo che il programma non tenti di eseguire il rendering di un array gigante. Infine, il programma inserirà il testo e un rettangolo sull'immagine per visualizzare la frase.
  
  
• 02:10:00 In questa sezione, il video mostra come utilizzare Python e un modello LSTM Deep Learning per rilevare la lingua dei segni utilizzando il riconoscimento dell'azione. L'esercitazione illustra la regolazione del codice per l'uso del metodo di accodamento e l'aumento della soglia di rilevamento per una maggiore precisione. Il video mostra anche come eseguire il rendering delle probabilità con una funzione rapida per creare una visualizzazione delle probabilità, rendendo visivamente accattivante l'output del rilevamento. Nel complesso, il tutorial fornisce un eccellente esempio di utilizzo di modelli di deep learning per rilevare il linguaggio dei segni con Python, rendendolo un'ottima risorsa per chiunque desideri realizzare progetti simili.
  
  
• 02:15:00 In questa sezione del video, il presentatore mostra una funzione di visualizzazione delle probabilità che ci consente di visualizzare le diverse azioni e come vengono calcolate le loro probabilità in tempo reale. La funzione utilizza cv2.rectangle per posizionare un rettangolo dinamico sul frame di output, quindi lo posiziona e lo riempie in base all'azione su cui stiamo attualmente lavorando, che quindi utilizza il metodo di testo cv2.put per emettere i valori di testo. Il presentatore mostra come questa funzione può essere inserita nel ciclo per visualizzarla in tempo reale e possiamo vedere che sta rilevando e riconoscendo diverse azioni come ciao, grazie e ti amo in base ai valori di probabilità. Il presentatore evidenzia che esistono molte applicazioni per questa funzione e dimostra come il codice può essere utilizzato per rilevare e riconoscere diverse azioni in vari scenari.
  
  
• 02:20:00 In questa sezione del video, il presentatore riassume il processo del loro progetto di rilevamento della lingua dei segni. Hanno creato cartelle per la raccolta, raccolto punti chiave, pre-elaborato i dati, costruito una rete neurale LSTM, fatto previsioni e testato in tempo reale. Sono stati in grado di eseguire efficacemente i rilevamenti in tempo reale, inclusa la visualizzazione delle probabilità. Forniscono una dimostrazione di come hanno corretto il codice per catturare i fotogrammi giusti e aggiungerli alla sequenza spostando i due punti e aggiungendo un negativo. Hanno anche aggiunto una riga per aggiungere le loro previsioni a un nuovo array di previsioni per garantire maggiore stabilità durante la previsione delle azioni. Infine, offrono agli utenti la possibilità di estendere e modificare il progetto aggiungendo ulteriori azioni, colori e/o visualizzazioni a loro piacimento.
  
  
• 02:25:00 In questa sezione, il relatore dimostra come il modello di rilevamento dell'azione sia diventato più stabile e resiliente implementando una logica aggiuntiva. Il modello è ora in grado di ridurre al minimo i falsi rilevamenti e mantenere il rilevamento per periodi più lunghi, migliorandone la precisione. Il relatore menziona anche che i pesi addestrati per il modello saranno disponibili nel repository GitHub affinché gli utenti possano sfruttarli. Il video si conclude con un invito a mettere un pollice in su e ad iscriversi al canale.