Predicción de rendimiento de cultivos utilizando Aprendizaje Automático e implementación de Flask.

Crop performance prediction using Machine Learning and Flask implementation.

Introducción

La predicción del rendimiento de los cultivos es una técnica esencial de análisis predictivo en la industria agrícola. Es una práctica agrícola que puede ayudar a los agricultores y a las empresas agrícolas a predecir el rendimiento de los cultivos en una temporada determinada, cuándo plantar un cultivo y cuándo cosecharlo para obtener un mejor rendimiento de los cultivos. El análisis predictivo es una herramienta poderosa que puede ayudar a mejorar la toma de decisiones en la industria agrícola. Puede ser utilizado para la predicción del rendimiento de los cultivos, la mitigación de riesgos, la reducción del costo de los fertilizantes, etc. La predicción del rendimiento de los cultivos utilizando ML y la implementación de Flask analizará las condiciones meteorológicas, la calidad del suelo, el conjunto de frutas, la masa de frutas, etc.

Objetivos de aprendizaje

• Repasaremos brevemente el proyecto de principio a fin para predecir el rendimiento de los cultivos utilizando la modelización de simulación de polinización.
• Seguiremos cada paso del ciclo de vida del proyecto de ciencia de datos, incluyendo la exploración de datos, el preprocesamiento, la modelización, la evaluación y la implementación.
• Finalmente, implementaremos el modelo utilizando Flask API en una plataforma de servicio en la nube llamada render.

Así que comencemos con este emocionante problema del mundo real.

Este artículo fue publicado como parte del Data Science Blogathon.

Descripción del proyecto

El conjunto de datos utilizado para este proyecto se generó utilizando un modelo de cálculo de simulación espacial explícito para analizar y estudiar varios factores que afectan la predicción del arándano silvestre, incluyendo:

• Cómo funciona GPT una explicación metafórica de Clave, Valor, Consulta en Atención, utilizando un cuento de pociones.
• JPL Crea Archivo PDF para Ayudar en la Investigación de Malware.
• Cuidado con los datos poco confiables en la evaluación de modelos un estudio de caso de selección de LLM Prompt con Flan-T5.

• Arreglo espacial de las plantas
• Cruzamiento y autopolinización
• Composiciones de especies de abejas
• Las condiciones climáticas (de forma aislada y en combinación) afectan la eficiencia de la polinización y el rendimiento del arándano silvestre en el ecosistema agrícola.

El modelo de simulación ha sido validado por la observación en campo y los datos experimentales recopilados en Maine, EE.UU., y en las Marítimas Canadienses durante los últimos 30 años y ahora es una herramienta útil para la prueba de hipótesis y la estimación de la predicción del rendimiento del arándano silvestre. Estos datos simulados proporcionan a los investigadores datos reales recopilados en el campo para varios experimentos sobre la predicción del rendimiento de los cultivos, así como datos para que los desarrolladores y científicos de datos construyan modelos de aprendizaje automático del mundo real para la predicción del rendimiento de los cultivos.

¿Qué es el modelo de simulación de polinización?

La modelización de simulación de polinización es el proceso de utilizar modelos informáticos para simular el proceso de polinización. Existen varios casos de uso de la simulación de polinización, como:

• Estudiar los efectos de diferentes factores en la polinización, como el cambio climático, la pérdida de hábitat y los pesticidas.
• Diseñar paisajes favorables a la polinización.
• Predicción del impacto de la polinización en los rendimientos de los cultivos.

Los modelos de simulación de polinización pueden ser utilizados para estudiar el movimiento de los granos de polen entre las flores, el momento de los eventos de polinización y la eficacia de diferentes estrategias de polinización. Esta información puede ser utilizada para mejorar las tasas de polinización y los rendimientos de los cultivos, lo que puede ayudar aún más a los agricultores a producir cultivos de manera efectiva con un rendimiento óptimo.

Los modelos de simulación de polinización todavía están en desarrollo, pero tienen el potencial de desempeñar un papel importante en el futuro de la agricultura. Al entender cómo funciona la polinización, podemos proteger y gestionar mejor este proceso esencial.

En nuestro proyecto, utilizaremos un conjunto de datos con varias características como “clonesize”, “honeybee”, “RainingDays”, “AverageRainingDays”, etc., que fueron creadas utilizando un proceso de simulación de polinización para estimar el rendimiento de los cultivos.

Declaración del problema

En este proyecto, nuestra tarea es clasificar la variable de rendimiento (característica objetivo) en función de las otras 17 características paso a paso, pasando por cada tarea del día. Las métricas de evaluación serán puntuadas por RMSE. Implementaremos el modelo utilizando el marco de trabajo Flask de Python en una plataforma basada en la nube.

Pre-requisitos

Este proyecto es adecuado para estudiantes intermedios de ciencia de datos y aprendizaje automático para construir sus proyectos de cartera. Los principiantes en el campo pueden tomar este proyecto si están familiarizados con las siguientes habilidades:

• Conocimiento del lenguaje de programación Python y algoritmos de aprendizaje automático utilizando la biblioteca scikit-learn
• Comprensión básica del desarrollo de sitios web utilizando el marco de trabajo Flask de Python
• Comprender las métricas de evaluación de regresión

Descripción de los datos

En esta sección, se analizará cada variable del conjunto de datos para nuestro proyecto.

• Clonesize — m2 — Tamaño promedio del clon de arándanos azules en el campo
• Honeybee — abejas/m2/min — Densidad de abejas melíferas en el campo
• Bumbles — abejas/m2/min — Densidad de abejorros en el campo
• Andrena — abejas/m2/min — Densidad de abejas Andrena en el campo
• Osmia — abejas/m2/min — Densidad de abejas Osmia en el campo
• MaxOfUpperTRange — ℃ — El registro más alto de la temperatura diaria en la banda superior durante la temporada de floración
• MinOfUpperTRange — ℃ — El registro más bajo de la temperatura diaria en la banda superior
• AverageOfUpperTRange — ℃ — El promedio de la temperatura diaria en la banda superior
• MaxOfLowerTRange — ℃ — El registro más alto de la temperatura diaria en la banda inferior
• MinOfLowerTRange — ℃ — El registro más bajo de la temperatura diaria en la banda inferior
• AverageOfLowerTRange — ℃ — El promedio de la temperatura diaria en la banda inferior
• RainingDays — Día — El número total de días durante la temporada de floración, donde la precipitación es mayor que cero
• AverageRainingDays — Día — El promedio de días lluviosos en toda la temporada de floración
• Fruitset — Tiempo de transición del conjunto de frutas
• Fruitmass — Masa del conjunto de frutas
• Seeds — Número de semillas en el conjunto de frutas
• Yield — Rendimiento del cultivo (una variable objetivo)

¿Cuál es el valor de estos datos para el caso de uso de predicción de cultivos?

• Este conjunto de datos proporciona información práctica sobre las características espaciales de las plantas de arándanos azules silvestres, especies de abejas y situaciones climáticas. Por lo tanto, permite a los investigadores y desarrolladores construir modelos de aprendizaje automático para la predicción temprana del rendimiento de los arándanos.
• Este conjunto de datos puede ser esencial para otros investigadores que tienen datos de observación de campo, pero quieren probar y evaluar el rendimiento de diferentes algoritmos de aprendizaje automático comparando el uso de datos reales con datos generados por simulación por computadora como entrada en la predicción del rendimiento del cultivo.
• Los educadores de diferentes niveles pueden utilizar el conjunto de datos para entrenar problemas de clasificación o regresión de aprendizaje automático en la industria agrícola.

Carga del conjunto de datos

En esta sección, cargaremos el conjunto de datos en el entorno en el que esté trabajando. Cargue el conjunto de datos en el entorno de Kaggle. Utilice el conjunto de datos de Kaggle o descárguelo a su máquina local y ejecútelo en el entorno local.

Origen del conjunto de datos: Haga clic aquí

Veamos el código para cargar el conjunto de datos y cargar las bibliotecas para el proyecto.

import numpy as np # álgebra lineal
import pandas as pd # procesamiento de datos, I/O de archivo CSV (por ejemplo, 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

# configurando el entorno os en Kaggle 
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# leer el archivo CSV y cargar las primeras 5 filas en la plataforma 
df = pd.read_csv("/kaggle/input/wildblueberrydatasetpollinationsimulation/
WildBlueberryPollinationSimulationData.csv", 
                 index_col='Row#')
df.head()

# imprimir los metadatos del conjunto de datos
df.info()

# descripción de los datos
df.describe()

Códigos como ‘df.info()’ proporcionan un resumen del marco de datos con el número de filas, número de valores nulos, tipos de datos de cada variable, etc. mientras que ‘df.describe()’ proporciona estadísticas descriptivas del conjunto de datos como la media, mediana, conteo y percentiles de cada variable en el conjunto de datos.

Análisis exploratorio de datos

En esta sección, se examinará el análisis exploratorio de datos del conjunto de datos de cultivos y se obtendrán ideas del conjunto de datos.

Mapa de calor del conjunto de datos

# crear conjunto de características y variable objetivo del conjunto de datos
features_df = df.drop('yield', axis=1)
tar = df['yield']

# trazar el mapa de calor del conjunto de datos
plt.figure(figsize=(15,15))
sns.heatmap(df.corr(), annot=True, vmin=-1, vmax=1)
plt.show()

El gráfico anterior muestra una visualización de los coeficientes de correlación del conjunto de datos. Usando una biblioteca de Python llamada seaborn, podemos visualizarlo en solo 3 líneas de código.

Distribución de la variable objetivo

# trazar el diagrama de caja usando la biblioteca seaborn de la variable objetivo 'yield'
plt.figure(figsize=(5,5))
sns.boxplot(x='yield', data=df)
plt.show()

El código anterior muestra la distribución de la variable objetivo usando un diagrama de caja. Podemos ver que la mediana de la distribución está alrededor de 6000 con un par de valores atípicos con el rendimiento más bajo.

Distribución por las características categóricas del conjunto de datos

# Técnica de subplot de matplotlib para trazar la distribución por características categóricas
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()

Distribución de los tipos de abejas en nuestro conjunto de datos

# técnica de subplot de matplotlib para trazar la distribución de abejas en nuestro conjunto de datos
plt.figure(figsize=(15,10))
plt.subplot(2,3,1)
plt.hist(df['bumbles'])
plt.title("Histograma de la columna bumbles")
plt.subplot(2,3,2)
plt.hist(df['andrena'])
plt.title("Histograma de la columna andrena")
plt.subplot(2,3,3)
plt.hist(df['osmia'])
plt.title("Histograma de la columna osmia")
plt.subplot(2,3,4)
plt.hist(df['clonesize'])
plt.title("Histograma de la columna clonesize")
plt.subplot(2,3,5)
plt.hist(df['honeybee'])
plt.title("Histograma de la columna honeybee")
plt.show()

Tomemos nota de algunas observaciones sobre el análisis:

• Las columnas de rango T superior e inferior se correlacionan entre sí
• Los días lluviosos y los días lluviosos promedio se correlacionan entre sí
• La ‘ masafruta ‘, ‘ conjuntodefruta ‘ y ‘ semillas ‘ están correlacionados
• La columna ‘ borrachos ‘ está altamente desequilibrada mientras que las columnas ‘ andrena ‘ y ‘ osmia ‘ no lo están
• ‘Abeja melífera’ también es una columna desequilibrada en comparación con ‘ tamañodeclon ‘

Preprocesamiento de datos y preparación de datos

En esta sección, preprocesaremos el conjunto de datos para modelar. Realizaremos una ‘regresión de información mutua’ para seleccionar las mejores características del conjunto de datos, realizaremos agrupaciones en los tipos de abejas de nuestro conjunto de datos y normalizaremos el conjunto de datos para un modelado eficiente de machine learning.

Regresión de Información Mutua

# ejecutar los puntajes de MI del conjunto de datos
puntuacion_mi = mutual_info_regression(features_df, tar, n_neighbors=3,random_state=42)
puntuacion_mi_df = pd.DataFrame({'columnas':features_df.columns, 'puntuación_MI':puntuacion_mi})
puntuacion_mi_df.sort_values(by='puntuación_MI', ascending=False)

El código anterior calcula la regresión mutua utilizando el coeficiente de Pearson para encontrar las características más correlacionadas con la variable objetivo. podemos ver las características más correlacionadas en orden descendente y cuáles están más correlacionadas con la variable objetivo. ahora agruparemos los tipos de abejas para crear una nueva característica.

Agrupación Usando K-means

# agrupación usando el algoritmo kmeans
X_clus = features_df[['abejamelifera','osmia','borrachos','andrena']]

# normalizar el conjunto de datos usando el escalador estándar
escalador = StandardScaler()
escalador.fit(X_clus)
X_new_clus = escalador.transform(X_clus)

# agrupación de K means
agrupacion = KMeans(n_clusters=3, random_state=42)
agrupacion.fit(X_new_clus)
n_cluster = agrupacion.labels_

# agregar nueva característica a feature_Df 
features_df['n_cluster'] = n_cluster
df['n_cluster'] = n_cluster
features_df['n_cluster'].value_counts()

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

El código anterior normaliza el conjunto de datos y luego aplica el algoritmo de agrupación para agrupar las filas en 3 grupos diferentes.

Normalización de datos usando el escalador Min-Max

features_set = ['díaslluviosospromedio','tamañodeclon','promediodeinferiorT',
               'promediodesuperiorT','abejamelifera','osmia','borrachos','andrena','n_cluster']

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

# conjunto de entrenamiento y prueba para construir un modelo de línea base utilizando GBT y RFs escalando el conjunto de datos
mx_escalador = MinMaxScaler()
X_escalado = pd.DataFrame(mx_escalador.fit_transform(X))
X_escalado.columns = X.columns

El código anterior representa el conjunto de características normalizado ‘ X_escalado ‘ y la variable objetivo ‘ y ‘ que se utilizará para el modelado.

Modelado y Evaluación

En esta sección, echaremos un vistazo al modelado de machine learning utilizando el modelado de aumento de gradiente y la sintonización de hiperparámetros para obtener la precisión y el rendimiento deseados del modelo. Además, ver el modelado de regresión de mínimos cuadrados ordinarios utilizando la biblioteca statsmodels y el explicador de modelos de forma para visualizar qué características son más importantes para nuestra predicción de rendimiento de cultivos objetivo.

Modelado de Machine Learning Línea Base

# ajustemos los datos a los modelos como adaboost, gradientboost y random forest
model_dict = {"abr": AdaBoostRegressor(), 
              "gbr": GradientBoostingRegressor(), 
              "rfr": RandomForestRegressor()
             }

# Puntuaciones de validación cruzada de los modelos
for key, val in model_dict.items():
    print(f"validación cruzada para {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)

-----------------------------------[Salida]------------------------------------
validación cruzada para abr
730.974385377955
validación cruzada para gbr
528.1673164806733
validación cruzada para rfr
608.0681265123212

En el modelo de aprendizaje automático anterior, hemos obtenido el error cuadrático medio más bajo en el regresor de aumento de gradiente, mientras que el error más alto en el regresor Adaboost. Ahora, entrenaremos el modelo de aumento de gradiente y evaluaremos el error utilizando el método de división de entrenamiento y prueba de scikit-learn.

# dividir los datos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# modelo de regresión de aumento de gradiente
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("Puntuación RMSE del modelo de aumento de gradiente:", rmse_score)      
print("Puntuación R2 para el modelo: ", r2_score)

-----------------------------[Salida]-------------------------------------------
Puntuación RMSE del modelo de aumento de gradiente: 363.18286194620714
Puntuación R2 para el modelo:  0.9321362721127562

Aquí, podemos ver que la puntuación RMSE del modelo de aumento de gradiente sin ajuste de hiperparámetros del modelo es de alrededor de 363. Mientras que R2 del modelo es alrededor del 93%, que es una precisión del modelo mejor que la precisión de línea de base. Además, ajustar los hiperparámetros para optimizar la precisión del modelo de aprendizaje automático.

Ajuste de hiperparámetros

# dividir el conjunto de datos
kf = KFold(n_splits = 5, shuffle=True, random_state=0)

# cuadrícula de parámetros para ajustar los hiperparámetros
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]
             }

# objeto estimador GBR 
estimator = GradientBoostingRegressor(random_state=42)

# objeto de búsqueda en cuadrícula CV
clf = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=kf, 
                   scoring='neg_mean_squared_error', n_jobs=-1)
clf.fit(X_scaled,y)

# imprimir el mejor estimador y parámetros
best_estim = clf.best_estimator_
best_score = clf.best_score_
best_param = clf.best_params_
print("Mejor Estimador:", best_estim)
print("Mejor puntuación:", np.sqrt(-best_score))

-----------------------------------[Salida]----------------------------------
Mejor Estimador: GradientBoostingRegressor(max_depth=7, min_samples_leaf=0.1, 
                                          n_estimators=500, random_state=42)
Mejor puntuación: 306.57274619213206

Podemos ver que el error del modelo de aumento de gradiente ajustado ha disminuido aún más que los anteriores y hemos optimizado los parámetros para nuestro modelo de aprendizaje automático.

Explicador del modelo Shap

La explicabilidad del aprendizaje automático es un aspecto muy importante de la modelización de aprendizaje automático en la actualidad. aunque los modelos de aprendizaje automático han dado resultados prometedores en muchos dominios, su complejidad inherente hace que sea difícil comprender cómo llegaron a ciertas predicciones o decisiones. La biblioteca Shap utiliza valores ‘shaply’ para medir qué características influyen en la predicción de los valores objetivo. ahora veamos los gráficos explicadores del modelo ‘shap’ para nuestro modelo de aumento de gradiente.

# explicador de árbol shaply
shap_tree = shap.TreeExplainer(bgt)
shap_values = shap_tree.shap_values(X_test)
shap.summary_plot(shap_values, X_test)

En el gráfico de salida anterior, es claro que AverageRainingDays es la variable más influyente para explicar los valores predichos de la variable objetivo. Mientras que la característica andrena afecta menos el resultado de la variable de predicción.

Implementación del modelo utilizando FlaskAPI

En esta sección, desplegaremos el modelo de aprendizaje automático utilizando FlaskAPI en una plataforma de servicio en la nube llamada render.com. Antes de la implementación, es necesario guardar el archivo del modelo con la extensión joblib para crear una API que pueda ser implementada en la nube.

Guardando el archivo del modelo

# eliminar la función 'n_cluster' del conjunto de datos
X_train_n = X_train.drop('n_cluster', axis=1)
X_test_n = X_test.drop('n_cluster', axis=1)

# entrenar un modelo para la creación de una API de 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))

# después del entrenamiento, guardar el modelo utilizando la biblioteca joblib
joblib.dump(xgb_model, 'wbb_xgb_model2.joblib')

Como se puede ver, hemos guardado el archivo del modelo en el código anterior y cómo escribiremos el archivo de la aplicación Flask y el archivo del modelo para subirlos al repositorio de GitHub.

Estructura del repositorio de la aplicación

La imagen anterior es una instantánea del repositorio de la aplicación que contiene los siguientes archivos y directorios.

• app.py — Archivo de aplicación Flask
• model.py — Archivo de predicción del modelo
• requirements.txt — Dependencias de la aplicación
• Directorio del modelo — Archivos del modelo guardados
• directorio de plantillas — Archivo de interfaz de usuario de front-end

Archivo 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)

# # PARA EL ANÁLISIS DE FORMULACIÓN
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')
    
    # convierte json a 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():
    
    # renderiza la plantilla index.html
    
    return render_template("index.html", **context_dict)

@app.route('/predict', methods=['POST'])
def predict():
    # flask.request.form.keys() mostrará todas las entradas del formulario
    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()

El código anterior es el archivo Python que recibe la entrada de los usuarios e imprime la predicción de rendimiento de cultivo en la interfaz.

Archivo Model.py

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

# carga el archivo modelo
curr_path = os.path.dirname(os.path.realpath(__file__))
xgb_model = joblib.load(curr_path + "/model/wbb_xgb_model2.joblib")

# función para predecir el rendimiento
def predict_yield(attributes: np.ndarray):
    """ Devuelve el valor de rendimiento de arándanos"""
    # print(attributes.shape) # (1,8)

    pred = xgb_model.predict(attributes)
    print("Rendimiento predicho")

    return pred[0]
    

El archivo Model.py carga el modelo durante la ejecución y proporciona la salida de la predicción.

Implementación en Render

Una vez que todos los archivos se han subido al repositorio de Github, simplemente puede crear una cuenta en render.com para enviar la rama del repositorio que contiene el archivo app.py junto con otros artefactos. Luego, simplemente envíe para implementar en segundos. Además, render también proporciona una opción de implementación automática, lo que garantiza que cualquier cambio que realice en sus archivos de implementación se reflejen automáticamente en el sitio web.

Puede encontrar más información sobre el proyecto y el código en este enlace del repositorio de Github.

Conclusión

En este artículo, aprendimos acerca de un proyecto de extremo a extremo para predecir el rendimiento de los arándanos salvajes utilizando algoritmos de aprendizaje automático y la implementación utilizando FlaskAPI. Comenzamos cargando el conjunto de datos, seguido de EDA, preprocesamiento de datos, modelado de aprendizaje automático e implementación en la plataforma de servicios en la nube.

Los resultados mostraron que el modelo pudo predecir el rendimiento de cultivo con hasta un 93% de R2. La API de Flask facilita el acceso al modelo y su uso para hacer predicciones. Lo hace accesible a una amplia gama de usuarios, incluidos agricultores, investigadores y responsables políticos. Ahora veamos algunas de las lecciones aprendidas de este artículo.

1. Aprendimos cómo definir declaraciones de problemas para el proyecto y realizar un pipeline de proyecto de ML de extremo a extremo.
2. Aprendimos acerca del análisis exploratorio de datos y el preprocesamiento del conjunto de datos para el modelado.
3. Finalmente, aplicamos algoritmos de aprendizaje automático a nuestro conjunto de características para implementar un modelo para predicciones.

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!