Previsione del rendimento delle colture utilizzando Machine Learning e distribuzione di Flask.

Prediction of crop yield using Machine Learning and Flask deployment.

Introduzione

La previsione del rendimento delle colture è una tecnica essenziale di analisi predittiva nell’industria agricola. È una pratica agricola che può aiutare gli agricoltori e le aziende agricole a prevedere il rendimento delle colture in una determinata stagione, quando piantare una coltura e quando raccogliere per ottenere un migliore rendimento delle colture. L’analisi predittiva è uno strumento potente che può aiutare a migliorare la presa di decisioni nell’industria agricola. Può essere utilizzato per la previsione del rendimento delle colture, la mitigazione del rischio, la riduzione del costo dei fertilizzanti, ecc. La previsione del rendimento delle colture utilizzando l’apprendimento automatico (ML) e il deployment con flask troverà analisi sulle condizioni meteorologiche, la qualità del suolo, la fruttificazione, la massa della frutta, ecc.

Obiettivi di apprendimento

Esamineremo brevemente il progetto end-to-end per prevedere il rendimento delle colture utilizzando la modellizzazione della simulazione dell’impollinazione.
Seguiremo ogni fase del ciclo di vita del progetto di scienza dei dati, compresa l’esplorazione dei dati, la pre-elaborazione, la modellizzazione, la valutazione e il deployment.
Infine, distribuiremo il modello utilizzando Flask API su una piattaforma di servizio cloud chiamata render.

Quindi, iniziamo con questo entusiasmante problema del mondo reale.

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

Descrizione del progetto

Il dataset utilizzato per questo progetto è stato generato utilizzando un modello di calcolo di simulazione spaziale esplicito per analizzare e studiare vari fattori che influenzano la previsione delle bacche selvatiche, tra cui:

Disposizione spaziale delle piante
Impollinazione incrociata e auto-impollinazione
Composizioni delle specie di api
Le condizioni meteorologiche (in isolamento e in combinazione) influenzano l’efficienza dell’impollinazione e il rendimento della mirtilla selvatica nell’ecosistema agricolo.

Il modello di simulazione è stato convalidato dall’osservazione sul campo e dai dati sperimentali raccolti nel Maine, USA, e nelle Maritimes canadesi durante gli ultimi 30 anni ed è ora uno strumento utile per i test di ipotesi e la stima della previsione del rendimento della mirtilla selvatica. Questi dati simulati forniscono ai ricercatori dati effettivi raccolti dal campo per vari esperimenti sulla previsione del rendimento delle colture e forniscono anche dati per sviluppatori e scienziati dei dati per costruire modelli di apprendimento automatico del mondo reale per la previsione del rendimento delle colture.

Che cos’è il modello di simulazione dell’impollinazione?

La modellizzazione della simulazione dell’impollinazione è il processo di utilizzo di modelli informatici per simulare il processo di impollinazione. Ci sono vari casi d’uso della simulazione dell’impollinazione come:

Studio degli effetti di diversi fattori sull’impollinazione, come il cambiamento climatico, la perdita di habitat e i pesticidi
Progettazione di paesaggi favorevoli all’impollinazione
Previsione dell’impatto dell’impollinazione sul rendimento delle colture

I modelli di simulazione dell’impollinazione possono essere utilizzati per studiare il movimento dei granuli di polline tra i fiori, il timing degli eventi di impollinazione e l’efficacia di diverse strategie di impollinazione. Queste informazioni possono essere utilizzate per migliorare i tassi di impollinazione e il rendimento delle colture, il che può aiutare ulteriormente gli agricoltori a produrre colture in modo efficace con un rendimento ottimale.

I modelli di simulazione dell’impollinazione sono ancora in fase di sviluppo, ma hanno il potenziale per svolgere un ruolo importante nel futuro dell’agricoltura. Comprendendo come funziona l’impollinazione, possiamo proteggere e gestire meglio questo processo essenziale.

Nel nostro progetto, utilizzeremo un dataset con varie caratteristiche come ‘clonesize’, ‘honeybee’, ‘RainingDays’, ‘AverageRainingDays’, ecc., che sono stati creati utilizzando un processo di simulazione dell’impollinazione per stimare il rendimento delle colture.

Problem Statement

In questo progetto, il nostro compito è classificare la variabile di rendimento (target feature) in base alle altre 17 caratteristiche passo dopo passo seguendo ogni compito giornaliero. Le metriche di valutazione saranno valutate tramite la RMSE. Distribuiremo il modello utilizzando il framework Flask di Python su una piattaforma basata su cloud.

Pre-requisiti

Questo progetto è adatto per gli apprendisti intermedi di scienza dei dati e apprendimento automatico per costruire i propri progetti di portfolio. I principianti nel campo possono prendere in considerazione questo progetto se sono familiari con le seguenti competenze:

Conoscenza del linguaggio di programmazione Python e degli algoritmi di apprendimento automatico utilizzando la libreria scikit-learn
Comprensione di base dello sviluppo di siti web utilizzando il framework Flask di Python
Comprensione delle metriche di valutazione della regressione

Descrizione dei dati

In questa sezione, esamineremo ogni variabile del dataset per il nostro progetto.

Clonesize — m2 — La dimensione media del clone di mirtilli nel campo
Honeybee — api/m2/min — Densità di api nel campo
Bumbles — api/m2/min — Densità di bombi nel campo
Andrena — api/m2/min — Densità di api Andrena nel campo
Osmia — api/m2/min — Densità di api Osmia nel campo
MaxOfUpperTRange — ℃ —La temperatura massima registrata della banda superiore della temperatura dell’aria giornaliera durante la stagione di fioritura
MinOfUpperTRange — ℃ — La temperatura minima registrata della banda superiore della temperatura dell’aria giornaliera
AverageOfUpperTRange — ℃ — La temperatura media della banda superiore della temperatura dell’aria giornaliera
MaxOfLowerTRange — ℃ — La temperatura massima registrata della banda inferiore della temperatura dell’aria giornaliera
MinOfLowerTRange — ℃ — La temperatura minima registrata della banda inferiore della temperatura dell’aria giornaliera
AverageOfLowerTRange — ℃ — La temperatura media della banda inferiore della temperatura dell’aria giornaliera
RainingDays — Giorni — Il numero totale di giorni durante la stagione di fioritura, ognuno dei quali ha una precipitazione maggiore di zero
AverageRainingDays — Giorni — La media dei giorni di pioggia durante l’intera stagione di fioritura
Fruitset — Tempo di transizione del frutto
Fruitmass — Massa del frutto
Seeds — Numero di semi nella fruttificazione
Yield — Resa del raccolto (una variabile di destinazione)

Qual è il valore di questi dati per l’uso delle previsioni di raccolto?

Questo dataset fornisce informazioni pratiche sui tratti spaziali delle piante di mirtillo selvatico, sulle specie di api e sulle situazioni meteorologiche. Pertanto, consente ai ricercatori e agli sviluppatori di costruire modelli di apprendimento automatico per la previsione precoce della resa del mirtillo.
Questo dataset può essere essenziale per altri ricercatori che hanno dati di osservazione sul campo ma vogliono testare e valutare le prestazioni di diversi algoritmi di apprendimento automatico confrontando l’uso dei dati reali con i dati generati dalla simulazione al computer come input nella previsione della resa del raccolto.
Gli educatori a diversi livelli possono utilizzare il dataset per la formazione di problemi di classificazione o regressione di apprendimento automatico nell’industria agricola.

Caricamento del dataset

In questa sezione, caricheremo il dataset in qualsiasi ambiente tu stia lavorando. Carica il dataset nell’ambiente Kaggle. Usa il dataset Kaggle o scaricalo sul tuo computer locale e eseguilo sull’ambiente locale.

Fonte del dataset: Fai clic qui

Vediamo il codice per caricare il dataset e caricare le librerie per il progetto.

import numpy as np # algebra lineare
import pandas as pd # elaborazione dati, I/O file CSV (es. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_selection import mutual_info_regression, SelectKBest
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.model_selection import train_test_split, cross_val_score, KFold 
from sklearn.model_selection import GridSearchCV, RepeatedKFold
from sklearn.ensemble import AdaBoostRegressor, GradientBoostingRegressor 
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
import sklearn
from sklearn.pipeline import Pipeline
from sklearn.model_selection import GridSearchCV
import statsmodels.api as sm
from xgboost import XGBRegressor
import shap

# impostazione dell'ambiente os in kaggle 
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# leggi il file csv e carica le prime 5 righe nella piattaforma 
df = pd.read_csv("/kaggle/input/wildblueberrydatasetpollinationsimulation/
WildBlueberryPollinationSimulationData.csv", 
                 index_col='Row#')
df.head()

L'output del codice precedente — L’output del codice precedente

# stampa i metadati del dataset
df.info()

# descrizione dei dati
df.describe()

L'output del codice — L’output del codice

I codici precedenti come “df.info()” forniscono un riassunto del dataframe con il numero di righe, il numero di valori nulli, i tipi di dati di ogni variabile, ecc., mentre “df.describe()” fornisce le statistiche descrittive del dataset come media, mediana, conteggio e percentili di ogni variabile nel dataset.

Analisi dei Dati Esplorativa

In questa sezione, esamineremo l’analisi dei dati esplorativa del dataset delle colture e trarremo spunti dal dataset.

Heatmap del Dataset

# crea il set di funzionalità e la variabile target dal dataset
features_df = df.drop('yield', axis=1)
tar = df['yield']

# tracciare la heatmap dal dataset
plt.figure(figsize=(15,15))
sns.heatmap(df.corr(), annot=True, vmin=-1, vmax=1)
plt.show()

Il grafico sopra mostra una visualizzazione dei coefficienti di correlazione del dataset. Utilizzando una libreria seaborn di Python, possiamo visualizzarlo in soli 3 righe di codice.

Distribuzione della Variabile Target

# tracciare il boxplot utilizzando la libreria seaborn della variabile target "yield"
plt.figure(figsize=(5,5))
sns.boxplot(x='yield', data=df)
plt.show()

Il codice precedente visualizza la distribuzione della variabile target utilizzando un box plot. Possiamo vedere che la mediana della distribuzione si trova intorno a 6000 con un paio di valori anomali con il rendimento più basso.

Distribuzione delle Caratteristiche Categoriche del Dataset

# subplot matplotlib per la funzione categorica
nominal_df = df[['MaxOfUpperTRange','MinOfUpperTRange','AverageOfUpperTRange','MaxOfLowerTRange',
               'MinOfLowerTRange','AverageOfLowerTRange','RainingDays','AverageRainingDays']]

fig, ax = plt.subplots(2,4, figsize=(20,13))
for e, col in enumerate(nominal_df.columns):
    if e<=3:
        sns.boxplot(data=df, x=col, y='yield', ax=ax[0,e])
    else:
        sns.boxplot(data=df, x=col, y='yield', ax=ax[1,e-4])       
plt.show()

Distribuzione dei Tipi di Api nel Nostro Dataset

# tecnica subplot matplotlib per tracciare la distribuzione delle api nel nostro dataset
plt.figure(figsize=(15,10))
plt.subplot(2,3,1)
plt.hist(df['bumbles'])
plt.title("Istogramma della colonna bumbles")
plt.subplot(2,3,2)
plt.hist(df['andrena'])
plt.title("Istogramma della colonna andrena")
plt.subplot(2,3,3)
plt.hist(df['osmia'])
plt.title("Istogramma della colonna osmia")
plt.subplot(2,3,4)
plt.hist(df['clonesize'])
plt.title("Istogramma della colonna clonesize")
plt.subplot(2,3,5)
plt.hist(df['honeybee'])
plt.title("Istogramma della colonna honeybee")
plt.show()

Annotiamo alcune delle osservazioni riguardanti l’analisi:

Le colonne T-range superiore e inferiore sono correlate tra loro
I giorni di pioggia e i giorni di pioggia medi sono correlati tra loro
‘Fruitmass‘, ‘fruitset‘ e ‘seeds‘ sono correlati
La colonna ‘bumbles‘ è altamente sbilanciata mentre le colonne ‘andrena‘ e ‘osmia‘ non lo sono
‘Honeybee’ è anche una colonna sbilanciata rispetto a ‘clonesize‘

Pre-elaborazione dei dati e preparazione dei dati

In questa sezione, pre-elaboreremo il dataset per la modellizzazione. Effettueremo una regressione di informazione mutualistica per selezionare le migliori caratteristiche dal dataset, effettueremo il clustering sui tipi di api nel nostro dataset e standardizzeremo il dataset per una modellizzazione efficiente di machine learning.

Regressione di Informazione Mutualistica

# esegui i punteggi MI del dataset
mi_score = mutual_info_regression(features_df, tar, n_neighbors=3,random_state=42)
mi_score_df = pd.DataFrame({'columns':features_df.columns, 'MI_score':mi_score})
mi_score_df.sort_values(by='MI_score', ascending=False)

Il codice precedente calcola la regressione reciproca utilizzando il coefficiente di Pearson per trovare le caratteristiche più correlate con la variabile target. Possiamo vedere le caratteristiche più correlate in ordine decrescente e quelle più correlate con la caratteristica target. Ora clusterizzeremo i tipi di api per creare una nuova caratteristica.

Clustering Utilizzando K-means

# clustering utilizzando l'algoritmo kmeans
X_clus = features_df[['honeybee','osmia','bumbles','andrena']]

# standardizza il dataset utilizzando lo standard scaler
scaler = StandardScaler()
scaler.fit(X_clus)
X_new_clus = scaler.transform(X_clus)

# clustering K means
clustering = KMeans(n_clusters=3, random_state=42)
clustering.fit(X_new_clus)
n_cluster = clustering.labels_

# aggiungi una nuova caratteristica a feature_Df
features_df['n_cluster'] = n_cluster
df['n_cluster'] = n_cluster
features_df['n_cluster'].value_counts()

---------------------------------[Output]----------------------------------
1    368
0    213
2    196
Name: n_cluster, dtype: int64

Il codice precedente standardizza il dataset e quindi applica l’algoritmo di clustering per raggruppare le righe in 3 gruppi diversi.

Normalizzazione dei dati utilizzando lo scalatore Min-Max

features_set = ['AverageRainingDays','clonesize','AverageOfLowerTRange',
               'AverageOfUpperTRange','honeybee','osmia','bumbles','andrena','n_cluster']

# dataframe finale
X = features_df[features_set]
y = tar.round(1)

# dati di addestramento e test per creare un modello di base utilizzando GBT e RFs scalando il dataset
mx_scaler = MinMaxScaler()
X_scaled = pd.DataFrame(mx_scaler.fit_transform(X))
X_scaled.columns = X.columns

Il codice precedente rappresenta il set di funzionalità normalizzato ‘X_scaled‘ e la variabile target ‘y‘ che verranno utilizzati per la modellizzazione.

Modellizzazione e valutazione

In questa sezione, daremo un’occhiata alla modellizzazione del machine learning utilizzando la modellizzazione del gradient boosting e l’ottimizzazione dei parametri per ottenere la precisione e le prestazioni desiderate del modello. Inoltre, guardiamo la modellizzazione della regressione dei minimi quadrati ordinari utilizzando la libreria statsmodels e lo spiegatore del modello per visualizzare quali funzionalità sono più importanti per la nostra previsione di resa del raccolto target.

Modellizzazione del Machine Learning Baseline

# adattiamo i dati ai modelli come adaboost, gradientboost e random forest
model_dict = {"abr": AdaBoostRegressor(), 
              "gbr": GradientBoostingRegressor(), 
              "rfr": RandomForestRegressor()
             }

# Punteggi di cross validation dei modelli
for key, val in model_dict.items():
    print(f"validazione incrociata per {key}")
    score = cross_val_score(val, X_scaled, y, cv=5, scoring='neg_mean_squared_error')
    mean_score = -np.sum(score)/5
    sqrt_score = np.sqrt(mean_score) 
    print(sqrt_score)

-----------------------------------[Output]------------------------------------
validazione incrociata per abr
730.974385377955
validazione incrociata per gbr
528.1673164806733
validazione incrociata per rfr
608.0681265123212

Nella modellizzazione di machine learning, abbiamo ottenuto l’errore quadratico medio più basso con il regressore gradient boosting e l’errore più alto con il regressore Adaboost. Adesso, addestreremo il modello gradient boosting ed esamineremo l’errore utilizzando il metodo di divisione dei dati di addestramento e test di scikit-learn.

# dividiamo i dati di addestramento e di test
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# modellizzazione del regressore gradient boosting 
bgt = GradientBoostingRegressor(random_state=42)
bgt.fit(X_train,y_train)
preds = bgt.predict(X_test)
score = bgt.score(X_train,y_train)
rmse_score = np.sqrt(mean_squared_error(y_test, preds))
r2_score = r2_score(y_test, preds)
print("Punteggio RMSE machine gradient boosting:", rmse_score)      
print("Punteggio R2 per il modello: ", r2_score)

-----------------------------[Output]-------------------------------------------
Punteggio RMSE machine gradient boosting: 363.18286194620714
Punteggio R2 per il modello:  0.9321362721127562

Qui possiamo vedere che il punteggio RMSE del modello gradient boosting senza l’ottimizzazione degli iperparametri è di circa 363. Mentre R2 del modello è intorno al 93% che è una maggiore precisione del modello rispetto alla precisione di base. Inoltre, ottimizziamo gli iperparametri per ottimizzare la precisione del modello di machine learning.

Ottimizzazione degli Iperparametri

# suddividiamo il dataset in K-fold
kf = KFold(n_splits = 5, shuffle=True, random_state=0)

# griglia di parametri per l'ottimizzazione degli iperparametri
param_grid = {'n_estimators': [100,200,400,500,800],
             'learning_rate': [0.1,0.05,0.3,0.7],
             'min_samples_split': [2,4],
             'min_samples_leaf': [0.1,0.4],
             'max_depth': [3,4,7]
             }

# oggetto GBR estimator 
estimator = GradientBoostingRegressor(random_state=42)

# oggetto Grid search CV 
clf = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=kf, 
                   scoring='neg_mean_squared_error', n_jobs=-1)
clf.fit(X_scaled,y)

# stampiamo il miglior estimator e i parametri
best_estim = clf.best_estimator_
best_score = clf.best_score_
best_param = clf.best_params_
print("Miglior Estimator:", best_estim)
print("Miglior punteggio:", np.sqrt(-best_score))

-----------------------------------[Output]----------------------------------
Miglior Estimator: GradientBoostingRegressor(max_depth=7, min_samples_leaf=0.1, 
                                          n_estimators=500, random_state=42)
Miglior punteggio: 306.57274619213206

Possiamo vedere che l’errore del modello di gradient boosting ottimizzato è ulteriormente diminuito rispetto ai precedenti e abbiamo ottimizzato i parametri del nostro modello di ML.

Spiegazione del Modello Shap

L’esplicabilità del machine learning è un aspetto molto importante della modellizzazione di ML nel tempo attuale. Sebbene i modelli di ML abbiano dato risultati promettenti in molti domini, la loro complessità intrinseca rende difficile capire come sono stati raggiunti determinati risultati o decisioni. La libreria Shap utilizza i valori “shaply” per misurare quali caratteristiche sono influenti nella previsione dei valori target. Adesso, guardiamo i plot dell’esplicatore del modello Shap per il nostro modello di gradient boosting.

# esplicatore albero shaply
shap_tree = shap.TreeExplainer(bgt)
shap_values = shap_tree.shap_values(X_test)
shap.summary_plot(shap_values, X_test)

Nel grafico di output sopra, è evidente che la variabile più influente per spiegare i valori previsti della variabile target è AverageRainingDays, mentre la funzione andrena influenza meno l’esito della variabile di previsione.

Implementazione del modello usando FlaskAPI

In questa sezione, implementeremo il modello di machine learning utilizzando FlaskAPI su una piattaforma di servizi cloud chiamata render.com. Prima dell’implementazione, è necessario salvare il file del modello con l’estensione joblib per creare un’API che possa essere implementata sul cloud.

Salvataggio del file del modello

# Rimuovere la funzione 'n_cluster' dal dataset
X_train_n = X_train.drop('n_cluster', axis=1)
X_test_n = X_test.drop('n_cluster', axis=1)

# Allenare un modello per la creazione di API Flask
xgb_model = XGBRegressor(max_depth=9, min_child_weight=7, subsample=1.0)
xgb_model.fit(X_train_n, y_train)
pr = xgb_model.predict(X_test_n)
err = mean_absolute_error(y_test, pr)
rmse_n = np.sqrt(mean_squared_error(y_test, pr))

# Dopo l'addestramento, salvare il modello utilizzando la libreria joblib
joblib.dump(xgb_model, 'wbb_xgb_model2.joblib')

Come puoi vedere abbiamo salvato il file del modello nel codice sopra e come scriveremo il file dell’applicazione Flask e il file del modello per caricarlo nel repository Github.

Struttura del repository dell’applicazione

Screenshot del repository dell'applicazione — Screenshot del repository dell’applicazione

L’immagine sopra è la snapshot del repository dell’applicazione che contiene i seguenti file e directory.

app.py — File dell’applicazione Flask
model.py — File di previsione del modello
requirements.txt — Dipendenze dell’applicazione
Directory del modello — File del modello salvati
Directory dei modelli — File dell’interfaccia utente

File app.py

from flask import Flask, render_template, Response
from flask_restful import reqparse, Api
import flask

import numpy as np
import pandas as pd
import ast

import os
import json

from model import predict_yield

curr_path = os.path.dirname(os.path.realpath(__file__))

feature_cols = ['AverageRainingDays', 'clonesize', 'AverageOfLowerTRange',
    'AverageOfUpperTRange', 'honeybee', 'osmia', 'bumbles', 'andrena']

context_dict = {
    'feats': feature_cols,
    'zip': zip,
    'range': range,
    'len': len,
    'list': list,
}

app = Flask(__name__)
api = Api(app)

# # PER IL PARSING DELLA FORMA
parser = reqparse.RequestParser()
parser.add_argument('list', type=list)

@app.route('/api/predict', methods=['GET','POST'])
def api_predict():
    data = flask.request.form.get('single input')
    
    # converte json in int 
    i = ast.literal_eval(data)
    
    y_pred = predict_yield(np.array(i).reshape(1,-1))
    
    return {'message':"success", "pred":json.dumps(int(y_pred))}

@app.route('/')
def index():
    
    # Renderizza il modello templetico index.html
    
    return render_template("index.html", **context_dict)

@app.route('/predict', methods=['POST'])
def predict():
    # flask.request.form.keys() stamperà tutti gli input dalla forma
    test_data = []
    for val in flask.request.form.values():
        test_data.append(float(val))
    test_data = np.array(test_data).reshape(1,-1)

    y_pred = predict_yield(test_data)
    context_dict['pred']= y_pred

    print(y_pred)

    return render_template('index.html', **context_dict)

if __name__ == "__main__":
    app.run()

Il codice sopra è il file Python che prende l’input dagli utenti e stampa la previsione del rendimento del raccolto sul front-end.

File model.py

import joblib 
import pandas as pd
import numpy as np
import os

# carica il file del modello
curr_path = os.path.dirname(os.path.realpath(__file__))
xgb_model = joblib.load(curr_path + "/model/wbb_xgb_model2.joblib")

# funzione per prevedere il rendimento
def predict_yield(attributes: np.ndarray):
    """Restituisce il valore del rendimento dei mirtilli"""
    # print(attributes.shape) # (1,8)

    pred = xgb_model.predict(attributes)
    print("Rendimento previsto")

    return pred[0]

Il file model.py carica il modello durante l’esecuzione e fornisce l’output della previsione.

Implementazione su Render

Una volta che tutti i file sono stati caricati nel repository di github, è possibile creare un account su render.com per caricare il ramo del repository che contiene il file app.py insieme ad altri artefatti. quindi basta semplicemente premere per implementare in pochi secondi. Inoltre, Render fornisce anche un’opzione di implementazione automatica, garantendo che eventuali modifiche apportate ai file di implementazione vengano automaticamente riflessi sul sito web.

Screenshot of the render cloud deployment process — Screenshot del processo di implementazione sul cloud di Render

Puoi trovare ulteriori informazioni sul progetto e sul codice a questo link del repository di github.

Conclusioni

In questo articolo, abbiamo appreso un progetto end-to-end per prevedere il rendimento dei mirtilli selvatici utilizzando algoritmi di machine learning e implementando tutto tramite FlaskAPI. Abbiamo iniziato caricando l’insieme di dati, seguito da EDA, pre-elaborazione dei dati, modellizzazione di machine learning e implementazione sulla piattaforma di servizio cloud.

I risultati hanno mostrato che il modello è in grado di prevedere il rendimento del raccolto con un R2 fino al 93%. Flask API rende facile accedere al modello e usarlo per fare previsioni, lo rende accessibile a una vasta gamma di utenti, inclusi agricoltori, ricercatori e policy maker. ora vediamo alcune delle lezioni apprese da questo articolo.

Abbiamo imparato come definire le dichiarazioni di problema per il progetto e svolgere un intero pipeline di progetto di machine learning.
Abbiamo appreso l’analisi esplorativa dei dati e la pre-elaborazione dell’insieme di dati per la modellizzazione
Infine, abbiamo applicato algoritmi di machine learning al nostro insieme di caratteristiche per implementare un modello per le previsioni

Domande frequenti

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

blogathon,crop yield,dataset,Machine Learning,modeling,Prediction,project,Variable

MetaVERTU rivoluziona il mercato degli smartphone con l’integrazione di ChatGPT, ridefinendo le capacità di conversazione e inaugurando il lusso guidato dall’AI.

Incontra TARDIS un framework di intelligenza artificiale che identifica le singolarità in spazi complessi e cattura le strutture singolari e la complessità geometrica locale nei dati delle immagini.