Il detective della malattia del monaco Guida alla salute delle piante potenziata dall’IA

Il detective delle malattie delle piante Guida alla salute arricchita dall'Intelligenza Artificiale

Introduzione

L’agricoltura è la linfa vitale della nostra civiltà, fornendo sostentamento e nutrimento a miliardi di persone in tutto il mondo. Tuttavia, questa industria vitale si trova di fronte a un nemico implacabile: le malattie delle piante. Queste minacce microscopiche possono causare danni alle colture, portando a significative perdite economiche e carenze alimentari. La chiave per salvaguardare il nostro patrimonio agricolo risiede nella rilevazione precoce e nell’intervento tempestivo, in cui entra in gioco la tecnologia all’avanguardia. Questa guida completa intraprenderà un viaggio nella classificazione delle malattie delle piante utilizzando Monk, una potente libreria di apprendimento automatico. Alla fine di questo articolo, sarai fornito delle conoscenze necessarie per sfruttare appieno il potenziale dell’intelligenza artificiale nell’individuazione e nel contrasto efficace delle malattie delle piante.

Quindi, allacciate le cinture, perché esploreremo come Monk ci permette di creare, addestrare e ottimizzare modelli di deep learning per la classificazione delle malattie delle piante. Ma prima di immergerci negli aspetti tecnici, prepareremo il terreno comprendendo l’importanza di questo sforzo e il motivo per cui Monk svolge un ruolo fondamentale.

Obiettivi di apprendimento

Comprendere i fondamenti del software/libreria Monk.
Imparare come installare e configurare Monk sulla tua macchina locale o ambiente di sviluppo preferito.
Esplorare l’importanza dei dati di alta qualità nell’apprendimento automatico.
Imparare come acquisire, preprocessare e organizzare set di dati di immagini di malattie delle piante per compiti di classificazione usando Monk.
Ottenere una panoramica nella selezione di architetture di modelli di deep learning appropriate per la classificazione delle malattie delle piante.
Comprendere come configurare e ottimizzare modelli all’interno di Monk, inclusi modelli pre-addestrati per il transfer learning.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Guida pratica: Creare il tuo primo classificatore di malattie con Monk

In questa sezione ti guideremo passo dopo passo nel processo di costruzione del tuo modello Monk per la classificazione delle malattie delle piante. Che tu sia nuovo all’apprendimento automatico o un data scientist esperto, segui queste istruzioni per iniziare il tuo viaggio nella classificazione delle malattie delle piante.

Passo 1: Raccolta dati

In questo primo passaggio, raccoglieremo i dati necessari per il nostro progetto di classificazione delle malattie delle piante. Segui questi passaggi per raccogliere i dati:

Il fantastico team di Plant Village ha raccolto il dataset

1. Carica il token API di Kaggle:

Usa il codice seguente per caricare il tuo token API di Kaggle. Questo token è necessario per scaricare dataset da Kaggle.

dai google.colab import filesfiles.upload()

2. Installa il pacchetto Python di Kaggle:

Devi installare il pacchetto Python di Kaggle per interagire con Kaggle dal tuo ambiente Colab. Esegui il seguente comando:

!pip install kaggle

3. Imposta la directory di configurazione Kaggle:

Imposta la directory di configurazione Kaggle su “/content” utilizzando il seguente codice:

import osos.environ['KAGGLE_CONFIG_DIR'] = '/content'

4. Imposta le autorizzazioni appropriate:

Assicurati che il file del token API di Kaggle abbia le autorizzazioni corrette eseguendo:

!chmod 600 /content/kaggle.json

5. Scarica il dataset:

Utilizza l’API di Kaggle per scaricare il dataset delle malattie delle piante eseguendo questo comando:

!kaggle datasets download -d "prashantmalge/plant-disease"

6. Scompatta il dataset:

Infine, scompatta il dataset scaricato utilizzando il seguente comando:

!unzip plant-disease.zip

In questo modo il dataset sarà disponibile nel tuo ambiente Colab per ulteriori elaborazioni e addestramento. Modifica il nome e i percorsi del dataset, se necessario, per il tuo progetto specifico.

Passo 2: Configurazione di Monk

Prima di tutto, devi configurare Monk sulla tua macchina locale o nell’ambiente cloud. Segui questi passaggi per far funzionare Monk:

1. Clona il repository di Monk:

# Clona il repository di Monk!git clone https://github.com/Tessellate-Imaging/monk_v1.git# Aggiungi il repository di Monk al percorso Pythonimport syssys.path.append("./monk_v1/monk")# Installa eventuali pacchetti o dipendenze necessarie se richiesto# Rimuovi il cancelletto e aggiungi il tuo comando di installazione qui# !pip install -r /kaggle/working/monk_v1/installation/requirements_kaggle.txt

2. Installa Monk utilizzando pip:

!pip install -U monk-colab

Passaggio 3: Crea un’esperimento

Ora, creiamo un esperimento Monk. Un esperimento è un ambiente strutturato in cui si definiscono i parametri e le configurazioni per addestrare il classificatore di malattie. Ecco un frammento di codice per iniziare:

from pytorch_prototype import prototype# Crea un esperimentoptf = prototype(verbose=1)ptf.Prototype("malattie_piante", "exp1")

In questo codice, abbiamo chiamato il nostro esperimento “malattie_piante” con il tag “exp1”. Puoi adattare i nomi in base al tuo progetto.

Passaggio 4: Caricamento dei dati e Preprocessing

Carica il tuo dataset e applica trasformazioni ai dati per il preprocessing. Monk fornisce funzioni convenienti per caricare i dati e utilizzare le trasformazioni. Ecco un esempio:

# Carica il dataset e definisci le trasformazioniptf.Default(dataset_path=["./dataset/train", "./dataset/val"],             model_name="resnet18", freeze_base_network=True, num_epochs=5)

In questo frammento, specificiamo il percorso del dataset e l’architettura del modello (ResNet-18) e congeliamo i pesi della rete di base.

Passaggio 5: Trova rapidamente il modello

Scegli un’architettura di modello adatta alle tue esigenze e avvia il processo di addestramento. Monk supporta vari modelli preaddestrati e puoi ottimizzarli come necessario. Ecco come puoi farlo:

# Analisi - 1# Nome del progetto di analisianalysis_name = "Cercatore_Modello";# Modelli da analizzare# Primo elemento nella lista - Nome del modello# Secondo elemento nella lista - Valore booleano per congelare la base della rete o no# Terzo elemento nella lista - Valore booleano per utilizzare il modello preaddestrato come punto di partenza o nomodels = [["resnet34", True, True], ["resnet50", False, True],           ["densenet121", False, True], ["densenet169", True, True], ["densenet201", True, True]];  # Numero di epoche per ogni esperimento da eseguireepoche = 5;# Percentuale del dataset originale da utilizzare per sperimentazionepercent_data = 10;# "keep_all" - Conserva tutti i sottoesperimenti creati# "keep_non" - Elimina tutti i sottoesperimenti creatiptf.Analyse_Models(analysis_name, models, percent_data, num_epochs=epoche, state="keep_none");

Nome del Progetto di Analisi: analysis_name è una variabile che memorizza il nome del progetto di analisi. In questo caso, è impostato su “Cercatore_Modello”.
Modelli da Analizzare: La lista dei modelli specifica i modelli da analizzare. Ogni modello è rappresentato come una lista con tre elementi:
Numero di Epoche: il numero di epoche per cui desideri eseguire ciascun esperimento. In questo caso, è impostato su 5.
Percentuale del Dataset Originale: percent_data specifica la percentuale del dataset originale da utilizzare per la sperimentazione. È impostato al 10%, il che significa che verrà utilizzato solo il 10% del dataset.
Stato: Il parametro di stato determina se conservare o eliminare i sottoesperimenti. Quando impostato su “keep_none”, i sottoesperimenti non verranno conservati e saranno conservati solo i risultati finali.
Analyse_Models: Infine, viene chiamata la funzione ptf.Analyse_Models() con i parametri specificati per eseguire l’analisi del modello. Verranno eseguiti esperimenti per ciascun modello e verranno registrati i risultati.

Questo codice è utile per testare rapidamente più modelli con diverse configurazioni per trovare il modello dal miglior rendimento per il tuo compito. La selezione di un’architettura di modello appropriata è un passo standard nei progetti di apprendimento automatico e di apprendimento profondo.

Output:

Passaggio 6: Aggiorna il Modello

## Aggiorna l'architettura del Modelloptf.update_model_name("densenet121");ptf.update_freeze_base_network(True);ptf.update_use_pretrained(True);ptf.Reload();

Aggiorna il Nome del Modello: ptf.update_model_name(“densenet121”) aggiorna l’architettura del modello a “densenet121”. Ciò significa che stai passando dal modello precedentemente utilizzato a DenseNet-121.
Aggiorna il Congelamento della Base della Rete: ptf.update_freeze_base_network(True) imposta il flag per congelare la base della rete su “True”. Congelare la base della rete significa che i livelli preaddestrati del modello non verranno aggiornati durante l’addestramento. Rimarranno fissi e verranno addestrati solo i livelli aggiuntivi (se presenti). Ciò può essere utile quando si utilizzano modelli preaddestrati per il trasferimento di apprendimento.
Aggiorna l’Utilizzo del Peso Preaddestrato: ptf.update_use_pretrained(True) imposta il flag per utilizzare i pesi preaddestrati su “True”. Ciò indica che desideri inizializzare il modello con i pesi preaddestrati. Utilizzare i pesi preaddestrati come punto di partenza per il trasferimento di apprendimento è comune, specialmente quando si passa a una nuova architettura di modello come DenseNet-121.
Ricarica: ptf.Reload() ricarica il modello con le configurazioni aggiornate. Dopo aver modificato l’architettura del modello e le sue impostazioni, è essenziale ricaricare il modello per applicare tali modifiche.

In sintesi, questo codice cambia l’architettura del modello in DenseNet-121, congela la rete di base e utilizza pesi pre-addestrati. Queste modifiche vengono quindi applicate al modello ricaricandolo.
Output:

Passaggio 7: Trovare la Dimensione Batch Corretta

#Analisi - 2# Nome del Progetto di Analisi analysis_name = "Batch_Size_Finder";# Dimensioni Batch da esplorarebatch_sizes = [4, 8, 16, 32];# Numero di epoche per ogni esperimento    epochs = 10;# Percentuale del dataset originale da utilizzare per l'esperimentopercent_data = 10;# "keep_all" - Mantieni tutti i sub-esperimenti creati# "keep_non" - Elimina tutti i sub-esperimenti creati   ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data,                         num_epochs=epochs, state="keep_none");

Nome dell’Analisi: analysis_name = “Batch_Size_Finder” definisce il nome dell’analisi, che in questo caso è “Batch_Size_Finder”. Questo nome ti aiuta a identificare lo scopo di questa analisi.
Dimensioni Batch da Esplorare: batch_sizes = [4, 8, 16, 32] elenca diverse dimensioni di batch che vuoi esplorare durante l’analisi. In questo esempio, consideri dimensioni batch di 4, 8, 16 e 32.
Numero di Epoche: epochs = 10 specifica il numero di epoche di addestramento per ogni esperimento durante l’analisi. Ogni esperimento verrà eseguito per dieci epoche per valutare le prestazioni del modello con diverse dimensioni batch.
Percentuale del Dataset Originale: percent_data = 10 definisce la percentuale del dataset originale che desideri utilizzare per l’esperimento. In questo caso, stai utilizzando il 10% del dataset.
Stato: state = “keep_none” specifica lo stato dei sub-esperimenti creati durante l’analisi. In questo caso, “keep_none” significa che non desideri mantenere alcun sub-esperimento creato durante questa analisi. Saranno eliminati dopo il completamento dello studio.
Analisi Dimensioni Batch: ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data, num_epochs=epochs, state=”keep_none”) avvia l’analisi delle dimensioni batch. Questa funzione eseguirà esperimenti con diverse dimensioni batch (4, 8, 16 e 32) per valutarne l’impatto sulle prestazioni del modello.

Questa analisi mira a determinare la dimensione del batch che produce le migliori prestazioni di addestramento e validazione per il tuo modello di deep learning. Diverse dimensioni batch possono influenzare la velocità di addestramento e la convergenza; questa analisi ti aiuta a trovare un valore ottimale.
Output:

Passaggio 8: Aggiornare la Dimensione Batch

## Aggiorna la Dimensione Batch ptf.update_batch_size(8);ptf.Reload();

Aggiorna la Dimensione Batch: ptf.update_batch_size(8) aggiorna la dimensione del batch del tuo modello a 8. Questo significa che il tuo modello elaborerà i dati in batch di dimensione otto campioni durante l’addestramento. La dimensione del batch è un iperparametro che può influenzare la velocità di addestramento del tuo modello, l’uso di memoria e la convergenza.
Ricarica: ptf.Reload() ricarica il modello con la nuova dimensione del batch. Questo è necessario perché il cambio della dimensione del batch può influenzare i requisiti di memoria del tuo modello e il ricaricamento assicura che il modello sia configurato correttamente con la nuova dimensione del batch.

Impostando la dimensione del batch a 8 significa che il tuo modello dovrebbe elaborare i dati in 8 campioni per batch durante l’addestramento. Questo valore è stato determinato dall’analisi della dimensione del batch (come mostrato nel frammento di codice precedente) per trovare una dimensione del batch ottimale per il tuo specifico compito di deep learning.
Output:

Passaggio 9: Trovare la Dimensione di Input Corretta

#Analisi - 3# Nome del Progetto di Analisi analysis_name = "Input_Size_Finder";# Dimensioni di Input da esplorare input_sizes = [224, 256, 512];# Numero di epoche per ogni esperimento    epochs=5;# Percentuale del dataset originale da utilizzare per l'esperimentopercent_data=10;# "keep_all" - Mantieni tutti i sub-esperimenti creati# "keep_non" - Elimina tutti i sub-esperimenti creati ptf.Analyse_Input_Sizes(analysis_name, input_sizes, percent_data, num_epochs=epochs, state="keep_none");

Nome del Progetto di Analisi: analysis_name = “Input_Size_Finder” definisce un nome per questo progetto di analisi utilizzato per organizzare ed etichettare gli esperimenti relativi alla dimensione dell’input.
Dimensioni dell’Input da Esplorare: input_sizes = [224, 256, 512] specifica una lista di dimensioni dell’input (dimensioni dell’immagine) che si desidera esplorare. Si stanno testando tre diverse dimensioni di input: 224 × 224, 256 × 256 e 512 × 512 pixel.
Numero di Epoche: epochs = five imposta il numero di epoche di addestramento per ogni esperimento. In questo caso, si addestra il modello per cinque epoche per ogni dimensione dell’input.
Percentuale del Dataset Originale: percent_data = 10 specifica la percentuale del dataset originale da utilizzare per sperimentazione. Utilizzare una porzione più piccola del dataset può aiutare ad accelerare l’analisi fornendo al contempo informazioni su come diverse dimensioni dell’input influiscono sulle prestazioni del modello.
Stato: state=”keep_none” indica che si desidera mantenere solo l’esperimento con le migliori prestazioni e scartare gli altri. Questo è utile per identificare in modo efficiente la dimensione dell’input ottimale senza appesantire il proprio spazio di lavoro con molteplici esperimenti.

Questa analisi consente di determinare quale dimensione dell’input funziona meglio per il proprio specifico compito di apprendimento profondo. Diverse dimensioni dell’input possono influire sulle prestazioni del modello e sulla velocità di addestramento, quindi trovare il giusto equilibrio per il proprio progetto è essenziale.

Output:

Passaggio 10: Aggiornare la Dimensione dell’Input

## Aggiorna la Dimensione dell'Inputptf.update_input_size(224);ptf.Reload();

Aggiorna la Dimensione dell’Input: ptf.update_input_size(224) imposta la dimensione dell’input del proprio modello su 224 × 224 pixel. Ciò significa che il modello si aspetterà che le immagini di input abbiano dimensioni di 224 pixel in larghezza e 224 pixel in altezza. Cambiare la dimensione dell’input può influire significativamente sulle prestazioni del modello e sul tempo di addestramento.
Ricarica: ptf.Reload() ricarica il modello con la dimensione dell’input aggiornata. Questo passaggio è necessario perché il cambio della dimensione dell’input richiede modifiche all’architettura del modello. La ricarica assicura che il modello sia configurato correttamente con la nuova dimensione dell’input.

Impostando la dimensione dell’input su 224 × 224 pixel, si è effettivamente preparato il modello per accettare immagini di questa dimensione durante l’addestramento e l’inferenza. La scelta della dimensione dell’input dovrebbe essere in linea con il dataset e le esigenze del proprio compito, ed è spesso un iperparametro critico da ottimizzare per ottenere risultati ottimali.

Output:

Passaggio 11: Trova la Corretta Learning Rate di Partenza

#Analisi - 4# Nome del Progetto di Analisianalysis_name = "Learning_Rate_Finder"# Learning rate da esplorarelrs = [0.01, 0.005, 0.001, 0.0001];# Numero di epoche per ogni esperimento da eseguireepochs=5# Percentuale del dataset originale da utilizzare per la sperimentazionepercent_data=10# "keep_all" - Conserva tutti i sotto-esperimenti creati# "keep_non" - Elimina tutti i sotto-esperimenti creatiptf.Analizza_Learning_Rates(analysis_name, lrs, percent_data, num_epochs=epochs, state="keep_none");

Nome del Progetto di Analisi: analysis_name = “Learning_Rate_Finder” imposta il nome del progetto di analisi sulle learning rate. Questo nome verrà utilizzato per organizzare i risultati degli esperimenti.
Learning Rates da Esplorare: lrs = [0.01, 0.005, 0.001, 0.0001] specifica una lista di learning rate da esplorare durante l’analisi. La learning rate è un iperparametro fondamentale nell’addestramento di reti neurali profonde, e trovare la corretta learning rate può influire significativamente sul successo dell’addestramento.
Numero di Epoche: epochs = 5 determina il numero di epoche (iterazioni di addestramento) da eseguire per ogni esperimento di learning rate. Questo aiuta a valutare quanto velocemente il modello converge con diverse learning rate.
Percentuale del Dataset Originale: percent_data = 10 definisce la percentuale del dataset originale da utilizzare per la sperimentazione. Utilizzare un sottoinsieme più piccolo dei dati può velocizzare il processo di analisi fornendo comunque informazioni utili.
“keep_all” o “keep_none”: state=”keep_none” specifica se conservare o eliminare tutti i sotto-esperimenti creati durante l’analisi della learning rate. In questo caso, “keep_none” significa che i sotto-esperimenti non verranno salvati, probabilmente perché l’obiettivo principale è identificare la migliore learning rate anziché conservare i risultati intermedi.

Dopo aver eseguito questo codice, l’analisi esplorerà i tassi di apprendimento specificati, addestrerà il modello per alcune epoche con ciascun tasso di apprendimento e raccoglierà le metriche di performance. Queste informazioni ti aiuteranno a scegliere il tasso di apprendimento più adatto al tuo modello e dataset.

Output:

Step 12: Aggiorna il tasso di apprendimento

## Aggiorna il tasso di apprendimento ptf.update_learning_rate(0.01); ptf.Reload();

Aggiorna il tasso di apprendimento: ptf.update_learning_rate(0.01) aggiorna il tasso di apprendimento a 0.01. Il tasso di apprendimento è un iperparametro che controlla la dimensione dello step durante l’ottimizzazione. Determina quanto vengono aggiornati i parametri del modello durante ogni iterazione di allenamento.
Ricarica: ptf.Reload() ricarica il modello con il tasso di apprendimento aggiornato. Ricaricando il modello si assicura che le modifiche al tasso di apprendimento abbiano effetto durante le sessioni di allenamento successive.

Impostare il tasso di apprendimento a 0.01 ti permette di specificare un nuovo tasso di apprendimento per il tuo modello. Regolare il tasso di apprendimento è comune nel fine-tuning dei modelli di deep learning per migliorare la stabilità e la convergenza dell’allenamento.

Output:

Step 13: Ricerca dell’ottimizzatore

# Analisi - 5# Nome del progetto di analisianalysis_name = "Optimiser_Finder";# Ottimizzatori da esplorareoptimizers = ["sgd", "adam", "adamax", "rmsprop"];   #Modello, tasso di apprendimento# Numero di epoche per ogni esperimento da eseguireepochs = 5;# Percentuale del dataset originale da utilizzare per l'esperimentopercent_data = 10;# "keep_all" - Mantieni tutti gli esperimenti secondari creati# "keep_non" - Elimina tutti gli esperimenti secondari creatiptf.Analyse_Optimizers(analysis_name, optimizers, percent_data, num_epochs=epochs, state="keep_none");

Nome del progetto di analisi: analysis_name = “Optimiser_Finder”; definisce il nome del progetto di analisi come “Optimiser_Finder”. Questo progetto si concentrerà nella ricerca dell’ottimizzatore ottimale per il tuo modello.
Ottimizzatori da esplorare: optimizers è una lista che contiene i nomi degli ottimizzatori da esplorare. Gli ottimizzatori includono “sgd”, “adam”, “adamax” e “rmsprop”. Ogni ottimizzatore ha il suo set di tecniche di ottimizzazione e iperparametri.
Numero di epoche: epochs = 5; specifica il numero di epoche per ogni esperimento durante l’analisi. Un’epoca è un passaggio completo attraverso l’intero dataset di allenamento.
Percentuale del dataset originale: percent_data = 10; determina la percentuale del dataset originale da utilizzare per l’esperimentazione. In questo caso, verrà utilizzato il 10% del dataset.
Analyse_Optimizers: ptf.Analyse_Optimizers(analysis_name, optimizers, percent_data, num_epochs=epochs, state=”keep_none”); inizia l’analisi di diversi ottimizzatori. Eseguirà esperimenti utilizzando ciascun ottimizzatore elencato nella lista degli ottimizzatori e registrerà i risultati.

Analizzando diversi ottimizzatori, puoi identificare quale funziona meglio per il tuo dataset e modello di deep learning. La scelta dell’ottimizzatore può influenzare significativamente l’allenamento e le prestazioni della tua rete neurale.

Output:

Step 14: Aggiorna l’ottimizzatore

## Aggiorna il nome dell'ottimizzatoreptf.optimizer_adamax(0.001); ptf.Reload();

Aggiorna il nome dell’ottimizzatore: ptf.optimizer_adamax(0.001); imposta l’ottimizzatore su “Adamax” con un tasso di apprendimento di 0.001.
Ricarica il modello: ptf.Reload(); ricarica il modello con la nuova configurazione dell’ottimizzatore.

Stai cambiando l’algoritmo di ottimizzazione utilizzato durante l’allenamento aggiornando l’ottimizzatore a “Adamax” con un tasso di apprendimento specifico. Diversi ottimizzatori possono avere convergenze a diverse velocità, portando a variazioni nel processo di allenamento e nelle prestazioni finali del modello. È comune sperimentare con altri ottimizzatori e tassi di apprendimento per trovare la migliore combinazione per il tuo specifico compito di deep learning.

Step 15: Imposta lo stato intermedio – Salvataggio a False

ptf.update_save_intermediate_models(False);

ptf: si riferisce all’oggetto Prototype di PyTorch che hai creato.
update_save_intermediate_models(False): questa funzione aggiorna l’impostazione per il salvataggio di modelli intermedi durante l’allenamento. Disabiliti l’opzione di salvataggio di modelli intermedi passando False come argomento.

I modelli intermedi sono snapshot dei parametri del tuo modello salvati a intervalli specifici durante l’allenamento. Possono aiutare a riprendere l’allenamento da un checkpoint specifico o ad analizzare le prestazioni del modello in varie fasi di allenamento.

Impostando questa opzione su False significa che il tuo codice non salverà modelli intermedi durante il processo di allenamento, il che può essere vantaggioso se desideri risparmiare spazio su disco o non hai bisogno di tenere traccia degli checkpoint intermedi.

Successivamente, creiamo un nuovo esperimento utilizzando ‘copy_experiment’ e riprendiamo l’allenamento per ottenere ulteriori miglioramenti.

ptf = prototype(verbose=1);ptf.Prototype("plant_disease", "exp2", copy_from=["plant_disease", "exp1"]);

ptf = prototype (verbose=1): Crei un nuovo oggetto Prototype chiamato ptf con la modalità verbose abilitata. Questo oggetto consente di definire e gestire esperimenti di apprendimento automatico.
ptf.Prototype(“plant_disease”, “exp2”, copy_from=[“plant_disease”, “exp1”]): Questa riga specifica i dettagli del nuovo esperimento:

Creando un nuovo esperimento con le stesse impostazioni di uno esistente, puoi iterare rapidamente sui tuoi esperimenti mantenendo la coerenza nelle configurazioni e monitorando i progressi.

Riepilogo della configurazione dell’esperimento:

ptf.Summary()

Output:

Passo 16: Confronto

Monk fornisce una funzione “Confronto” snellita che raccoglie statistiche, visualizza risultati e aiuta gli utenti a decidere quali architetture di modelli e iperparametri sono più efficaci. Questo passaggio aiuta nel processo iterativo di ottimizzazione dei modelli e nel miglioramento progressivo delle loro prestazioni, guidando selezione delle configurazioni di modelli con migliori performance per il deployment.

from compare_prototype import comparectf = compare(verbose=1);ctf.Comparison("plant_disease");ctf.Add_Experiment("plant_disease", "exp1");ctf.Add_Experiment("plant_disease", "exp2");

Questi frammenti di codice illustrano l’utilizzo della libreria “compare_prototype” di Monk. Innanzitutto importa la funzione “compare” necessaria. Quindi inizializza un oggetto di confronto “ctf” con la modalità di verbosità impostata su 1 per la segnalazione. Il confronto viene denominato “plant_disease” utilizzando ctf.Comparison.

In seguito, due esperimenti, “exp1” e “exp2”, condotti nel progetto “plant_disease”, vengono aggiunti al confronto utilizzando ctf.Add_Experiment. Ciò consente agli utenti di analizzare e confrontare i risultati, le metriche e le prestazioni di questi due esperimenti per prendere decisioni informate sulla selezione e l’ottimizzazione del modello.

Passo 17: Inferenza

L’inferenza in Monk utilizza un modello addestrato per prevedere dati nuovi e non visti in precedenza. Ti consente di utilizzare il tuo modello addestrato per applicazioni reali, come la classificazione di immagini, il riconoscimento di oggetti o la presa di decisioni basate sull’output del modello. L’inferenza di solito comporta il caricamento di un modello addestrato, la fornitura di dati di input e l’ottenimento di previsioni o classificazioni dal modello. Monk offre strumenti e funzioni per semplificare il processo di inferenza e semplificare il deployment dei modelli di machine learning per l’uso pratico.

import numpy as npimport PIL.Image as Imageimport requeststest_url = "https://gardenerspath.com/wp-content/uploads/2019/08/            Frogeye-spots-Botryosphaeria-obtusa-on-apple-leaf-FB.jpg"# L'URL dell'immagine da scaricare è definito come test_url r = requests.get(test_url) # crea un oggetto di risposta HTTP with open('test.jpg','wb') as f:     f.write(r.content) test = Image.open('./test.jpg')test

Output:

ptf.Prototype("plant_disease", "exp2", eval_infer=True);

ptf.Prototype(“plant_disease”, “exp2”, eval_infer=True): Questa riga crea un nuovo esperimento chiamato “exp2” all’interno del progetto “plant_disease” utilizzando la funzione Prototype di Monk. Abilita anche la modalità di valutazione e inferenza (eval_infer=True), indicando che questo esperimento verrà utilizzato per effettuare previsioni su nuovi dati.

Output:

Dettagli del modello: Dopo aver inizializzato l’esperimento, il codice carica un modello pre-allenato. In questo caso, viene caricato un modello dalla directory “workspace/plant_disease/exp2/output/models/final.” Questo modello verrà utilizzato per l’infierenza.
Dettagli dell’esperimento: Questa sezione fornisce informazioni sull’esperimento, inclusi il nome del progetto (“plant_disease”), il nome dell’esperimento (“exp2”) e la directory in cui viene archiviato l’esperimento.

Passo 18: Predizione

img_name = "test.jpg";predictions = ptf.Infer(img_name=img_name, return_raw=True);print(predictions)

img_name = “test.jpg”;: Questa riga specifica il nome del file immagine (“test.jpg”) su cui si desidera effettuare l’infierenza. È possibile sostituire “test.jpg” con il percorso dell’immagine che si desidera analizzare.
Predictions = ptf.Infer(img_name=img_name, return_raw=True);: Questa riga di codice chiama la funzione “Infer” fornita dall’esperimento di Monk (ptf) per effettuare previsioni sull’immagine specificata. Inserisce il nome del file immagine e richiede punteggi di previsione grezzi impostando “return_raw=True.” Ciò significa che restituirà i punteggi numerici grezzi per ogni classe.
print(predictions): Infine, il codice stampa le previsioni. Queste previsioni includono tipicamente informazioni come la classe prevista e i punteggi grezzi associati per ogni classe.

Questo codice consente di analizzare l’immagine specificata utilizzando il modello addestrato e ottenere previsioni per varie classi e i loro punteggi di confidenza. L’output stampato fornirà informazioni sulla previsione del modello per l’immagine data.

import csvdef read_labels():    mydict = {}    with open('./dataset/labels.csv', mode='r') as infile:        reader = csv.reader(infile)        with open('labels_new.csv', mode='w') as outfile:            writer = csv.writer(outfile)            mydict = {rows[0]:rows[1] for rows in reader}    return mydictdef predict_label(predictions):    pred_class = predictions['predicted_class']    label_dict = read_labels()    out_label = label_dict[pred_class]    return out_labelprint("La classe prevista per l'immagine di test è: {}".format(predict_label(predictions)))

Funzione read_labels(): Questa funzione legge le informazioni sulle etichette dal file “labels.csv”. Apre il file CSV, legge il suo contenuto e crea un dizionario (mydict) in cui le chiavi sono gli ID di classe e i valori sono le etichette corrispondenti. Successivamente, scrive queste informazioni sulle etichette in un nuovo file CSV chiamato “labels_new.csv”.
Funzione predict_label(predictions): Questa funzione prende in input le previsioni ottenute dalla precedente inferenza. Estrae l’ID di classe prevista dalle previsioni e utilizza il dizionario delle etichette creato in precedenza per trovare l’etichetta corrispondente. L’etichetta viene quindi restituita come out_label.
Stampa del risultato: Il codice chiama la funzione predict_label(predictions) per ottenere l’etichetta associata alla classe prevista e la stampa come “La classe prevista per l’immagine di test è”.

In sintesi, questo codice ti aiuta a tradurre l’ID di classe numerico previsto dal modello in un’etichetta leggibile dall’uomo, facilitando la comprensione dell’output del modello.

Output: La classe prevista per l’immagine di test è: Apple___Black_rot

Tecniche avanzate per la classificazione delle malattie delle piante

Esploriamo tecniche e strategie avanzate per portare il tuo progetto di classificazione delle malattie delle piante al livello successivo.

1. Transfer Learning con dati personalizzati

Mentre l’utilizzo di modelli pre-allenati rappresenta un ottimo punto di partenza, è possibile migliorare ulteriormente l’accuratezza del tuo classificatore con dati personalizzati. Raccogli ulteriori immagini specifiche delle tue specie vegetali e malattie bersaglio. Puoi adattare un modello pre-allenato ai tuoi dati effettuando una fine-tuning per riconoscere i pattern e i sintomi unici.

# Fine-tuning di un modello pre-allenato con dati personalizzatipft.update_model_name("resnet50")ptf.update_freeze_base_network(False)  # Scongela la base network per la fine-tuningptf.update_use_pretrained(True)ptf.Reload()ptf.Train()

2. Data Augmentation

Data augmentation è una potente tecnica per aumentare artificialmente la diversità del tuo set di dati di allenamento. Applicando trasformazioni casuali come rotazione, ritaglio e regolazione della luminosità alle tue immagini, puoi migliorare la capacità del tuo modello di generalizzare. Monk fornisce funzioni comode per l’aumento dei dati:

# Applica trasformazioni di data augmentation
ptf.apply_random_rotation(train=True, val=True)
ptf.apply_random_crop(scale=[0.8, 1.0], ratio=[0.8, 1.2], train=True)
ptf.apply_random_brightness(train=True)

3. Gestione dello sbilanciamento di classe

In scenari reali, potresti incontrare uno sbilanciamento di classe, dove alcune malattie delle piante sono più diffuse di altre. Per affrontare questo problema, considera tecniche come l’oversampling delle classi minoritarie o l’applicazione di pesi di classe durante il training. Monk offre funzioni di perdita pesate per gestire dataset sbilanciati.

# Usa una funzione di perdita pesata per classe
ptf.loss_weighted_softmax_crossentropy(class_weights)

4. Apprendimento di tipo ensemble

L’apprendimento di tipo ensemble consiste nel combinare previsioni da più modelli per migliorare accuratezza e robustezza. Puoi creare un ensemble di architetture diverse o variazioni dello stesso modello per ottenere risultati migliori. Monk supporta l’apprendimento di tipo ensemble, consentendoti di sperimentare con diverse combinazioni di modelli.

# Crea un ensemble di modelli
ensemble = ptf.create_ensemble(models)
ensemble.Train()

5. Ottimizzazione degli iperparametri

La messa a punto degli iperparametri è fondamentale per ottimizzare le prestazioni del tuo modello. Monk fornisce strumenti per l’ottimizzazione degli iperparametri, che ti permettono di esplorare diversi tassi di apprendimento, dimensioni dei batch e algoritmi di ottimizzazione.

# Ottimizzazione degli iperparametri: tasso di apprendimento, dimensione del batch, ottimizzatore
ptf.Analyse_Learning_Rates("LR_Finder", lrs, percent_data=10, num_epochs=5)
ptf.Analyse_Batch_Sizes("Batch_Size_Finder", batch_sizes, percent_data=10, num_epochs=5)
ptf.Analyse_Optimizers("Optimizer_Finder", optimizers, percent_data=10, num_epochs=5)

6. Interpretabilità del modello

Comprendere perché un modello fa specifiche previsioni è essenziale, specialmente in applicazioni critiche come la classificazione di malattie. Monk fornisce strumenti di interpretabilità come Grad-CAM (Gradient-weighted Class Activation Mapping) per visualizzare quali regioni di un’immagine sono più influenti per una previsione.

# Visualizza previsioni del modello con Grad-CAM
heatmap = ptf.Visualize_With_GradCAM(image_path, target_layer)

Conclusioni

In questa guida completa, abbiamo esplorato il fascinante mondo della classificazione delle malattie delle piante usando Monk. Abbiamo coperto tutto, dall’impostazione degli esperimenti alla messa a punto dei modelli e alla comprensione delle applicazioni reali. Alla conclusione, riepiloghiamo i concetti chiave e discutiamo delle future direzioni entusiasmanti di questa tecnologia.

Concetti chiave:

Monk semplifica il deep learning: Monk fornisce un’interfaccia utente amichevole e intuitiva per la costruzione, l’addestramento e l’implementazione di modelli di deep learning. Il suo approccio modulare consente anche ai principianti di addentrarsi facilmente nella computer vision.
Rilevazione precoce delle malattie: Le malattie delle piante possono devastare i raccolti e minacciare la sicurezza alimentare. I modelli alimentati da Monk consentono una rilevazione precoce delle malattie, aiutando gli agricoltori a proteggere in modo proattivo i loro raccolti.
Agricoltura di precisione: Monk contribuisce all’agricoltura di precisione ottimizzando l’uso delle risorse, riducendo l’utilizzo di prodotti chimici e aumentando i rendimenti delle colture. Gli agricoltori possono raggiungere una maggiore redditività e sostenibilità ambientale.
Impatto nel mondo reale: Le applicazioni di Monk vanno oltre l’agricoltura, includendo ricerca, conservazione e citizen science. Responsabilizza individui e organizzazioni per avere un impatto positivo sulla salute delle piante e sugli ecosistemi.

Risorse per ulteriori approfondimenti

Per approfondire la classificazione delle malattie delle piante con Monk, ecco alcune risorse preziose:

Documentazione ufficiale di Monk -> Docs
Dataset Plant Village -> Docs
Installazione di Monk -> Docs
Modalità rapida PyTorch -> Docs
Modalità rapida Keras -> Docs
Modalità rapida Gluon -> Docs
Model Finder -> Docs

Monk rimane in prima linea per le soluzioni di classificazione delle malattie delle piante. La sua interfaccia utente intuitiva e le sue potenti capacità consentono a individui e organizzazioni di contribuire al benessere degli ecosistemi del nostro pianeta e all’approvvigionamento alimentare globale.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.

agriculture with AI,AI in Agriculture,classification,classification using Monks

Esplorando il VR Sociale Oltrepassare le Basi della Realtà Virtuale

Ricercatori di UCSD e ByteDance presentano ActorsNeRF un nuovo modello NeRF animabile per attori umani che generalizza ad attori mai visti in un contesto a pochi colpi.