Evaluación del curso

# Requerimiento

Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la obtención de datos tipo RAW.

- crear la rama a partir de un issue: <https://docs.github.com/es/issues/tracking-your-work-with-issues/using-issues/creating-a-branch-for-an-issue>

- Realizar los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/1-data/>

Descargar los datos y entender el problema a realizar, contestar en el notebook

- ¿Cual es el objetivo del problema?
- ¿Cómo se usará su solución?
- ¿Cuáles son las soluciones actuales (si las hay)?
- ¿Cómo se debe enmarcar este problema (supervisado / no supervisado, en línea / fuera de línea, etc.)
- ¿Cómo se debe medir el desempeño o el rendimiento de la solución, una primera intuicion?
- ¿La medida de desempeño está alineada con el objetivo del problema?
- ¿Cuál sería el desempeño o rendimiento mínimo necesario para alcanzar el objetivo del problema?
- ¿Cuáles son los problemas parecidos? ¿Se puede reutilizar experiencias o herramientas ya creadas?
- ¿Hay experiencia del problema disponible?
- (Importante) ¿Cómo se puede resolver el problema manualmente?
- Hacer un listado de los supuestos que hay hasta este momento.
- Cual es la fuente de los datos?
- Como se actualizan los datos?
- Cada cuanto tiempo se actualizan los datos

# Entregables

Notebook para obtención de los datos.

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD

# Requerimiento

Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la exploración inicial de los datos

- Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/2-exploration/>

el objetivo es realizar una exploración general de datos para verificar los tipos de datos  con el fin de comprender de las características y el esquema de datos  y si es posible solucionar problemas básicos relacionados. realizar

- Descripción general de los datos
- Unificar la forma como se representan los valores Nulos
- Convertir los datos en su tipo correcto (numéricos, categóricos, booleanos, fechas, etc) y corrección de los datos si es necesario, para eu cada columna tenga un tipo de dato uniforme.
- Almacenar el dataset final en un formato adecuado como `.parquet`

# Entregables

Notebook con la exploración general de los datos y los pasos descritos anteriormente

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD

Realizar un buen análisis de datos exploratorio (EDA) para caracterizar los datos disponibles para el proyecto. Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/3-analysis/>

Si su proyecto tiene muchos datos puede dividir el análisis en 3 notebooks diferentes:
- Análisis univariable
- Análisis bivariable
- Análisis multivariable

En este proceso, se incluye :

- Compresión detallada de las características y el esquema de datos.
- Identificación de la preparación de datos y la ingeniería de atributos que se necesitan si se fuera a implementar un modelo de machine learning

- Estudiar cada atributo y sus características (Análisis Univariable):
    - Nombre
    - Tipo de dato (categórico ordinal, nominal, numérico int / float, acotado / no acotado, texto, estructurado, fechas, etc.)
    - porcentaje (%) de valores nulos.
    - valores exactamente duplicados (filas y columnas)
    - Ruido y tipo de ruido (estocástico, valores atípicos, errores de redondeo, etc.)
    - ¿Son posiblemente útiles para el proyecto?
    - Descripción estadística (dependiendo del tipo de dato): por ejemplo para los numéricos
        - Tendencia Central (media, mediana, moda, max, min, etc)
        - Medidas de dispersión (Rango, IQR, cuartiles, varianza, desviación estándar, skewness y kurtosis)
        - Tipo de distribución (gaussiana, uniforme, logarítmica, etc.)
    - Analice los datos para crear las reglas de validación de los datos que serán usadas en otra etapa del proyecto.
- Para los proyectos de aprendizaje supervisado, identifique los atributos objetivo (target).
- Visualización de los datos.
- Estudiar las relaciones entre atributos (Análisis Bivariable)
- Estudiar las relaciones entre varios atributos (Análisis Multivariable)
- Estudiar cómo resolver el problema manualmente. (modelo simple Viable o heurísticas)
- Identificar las transformaciones que tal vez se puedan aplicar.
- Identificar datos adicionales que pueden ser útiles.

> Puede utilizar las librerías o herramientas que considere para resolver la tarea y contestar las preguntas.
> Utilice sistemas automáticos como [Data science Agent](https://developers.googleblog.com/en/data-science-agent-in-colab-with-gemini/) pueden ver un tutorial en este [Link](https://www.youtube.com/watch?v=1WAjTyYEIos)

# Entregables

Notebook con los resultados del análisis exploratorio de los datos, conclusiones e información de los datos
¿Sugerir si se puede realizar un modelo Heurístico que sea viable?

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Realizar el proceso de Feature Engineering para limpieza, transformación y modificación de los datos para que puedan ser usados para entrenar un modelo para resolver un problema. Hacerlo en un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la creación de los pipelines de scikit-learn

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/4-feat_eng/>

En este proceso para cada tipo de datos se incluye :

1. **Limpieza de datos**:
  - Eliminar registros datos duplicados (disminuir el numero de datos)
  - Corregir o eliminar valores atípicos (opcional).
  - Los valores atípicos pueden separarse del dataset dependiendo del problema del proyecto (por ejemplo, detección de anomalías).
  - Completar los valores faltantes (por ejemplo, con cero, media, mediana …) o eliminar las filas (o columnas).
2. Selección de atributos (**Feature Selection**) (opcional):
  - Descartar los atributos que no proporcionan información útil para el proyecto.
  - Eliminar registros duplicados (al eliminar atributos pueden quedar registros iguales)
3. Ingeniería de atributos (**Feature Engineering**), cuando sea apropiado:
  - Discretizar las atributos continuas.
  - (opcional) Descomponer en partes los atributos (p. Ej., Categóricas, fecha / hora, etc.).
  - (opcional) Agregar transformaciones prometedoras de las atributos, por ejemplo:
    - log(x)
    - sqrt(x)
    - x^2
    - etc
  - Aplicar funciones a los datos para agregar nuevos atributos.
4. Escalado de atributos (**Feature Scaling**):
  - estandarizar
  - normalizar
  - etc
5. Encoding
  - Encode variables categóricas, texto y las que sean necesarias para poder ser usadas para el modelamiento

Crear todas estas transformaciones usando transformadores y pipelines de scikit-learn
-  https://scikit-learn.org/stable/modules/preprocessing.html
-  https://scikit-learn.org/stable/modules/compose.html#

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con la descripción y creación de los pipelines de scikit-learn.

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Crear un modelo base para tenerlo como referencia para luego comparar al entrenar modelos de machine learning, el modelo base puede ser un modelo de heurísticas o un [modelo dummy](https://scikit-learn.org/stable/api/sklearn.dummy.html). Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/5-baseline_model/>

En este proceso se incluye :

- Usar pipeline de procesamiento de datos creado en la tarea anterior
- Dividir los datos en Train / Test
- Evaluar con diferentes métricas según el problema que se esta solucionando
- Usar validación cruzada (Cross validation) y obtener la media y la desviación estándar de la medida de las evoluciones realizadas.
- Seleccionar la variable mas importante y justificar por que se selecciona.
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Interpretar los resultados
- realizar análisis de los resultados
- realizar conclusiones
- definir recomendaciones para crear un modelo en base a los resultados del modelo base
- Propuestas y ideas en base a os resultados obtenidos

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con la descripción y creación de los pipelines de scikit-learn, además de los resultados del modelo base.
Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Realizar el proceso de selección del mejor modelo de machine learning para resolver el problema de machine Learning, este modelo debe ser mejor que el modelo baseline. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

Se puede solucionar:

- Manual
- Automatizada

Seleccione la opción que considere mejor. (Es un buen momento para conocer las herramientas de AutoML)

## Manual

> Si lo va hacer manual Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/6-model_selection/>

De ser Manual este proceso se incluye :

- Usar pipeline de procesamiento de datos creado en la tarea anterior
- Dividir los datos en Train / Test
- seleccionar multiples modelos de machine learning según el problema (mínimo 4 tipos diferentes)
- Evaluar con diferentes métricas según el problema que se esta solucionando (En la tarea anterior se definió cual seria la métrica mas importante)
- Eliminar los modelos que funciones por debajo del promedio de los modelos
- Evaluar los modelos restantes usando validación cruzada (Cross validation) y obtener la media y la desviación estándar de la medida de las evoluciones realizadas. (recuerde usar pipelines de la union del pipeline de transformación y el modelo)
- los dos o tres mejores modelos realizar el proceso de optimización de hiperparametros, recuerde usar cross validation y los pipelines
- Comparar los resultados y seleccionar el mejor modelo (recuerde usar pruebas estadísticas en la comparación para seleccionar el mejor modelo)
- Entrenar con todo el dataset de train el modelo seleccionado con sus hiperparametros, luego hacer la predicción con el dataset de test y realizar la evaluación de desempeño.
- si los resultados de la evaluación de test, se presenta, underfitting, overfitting repetir el proceso nuevamente con otros modelos y otras configuraciones, si no se logra un buen desempeño es necesario repetir el proceso de feature engineering.
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Almacenar el pipeline de preprocesamiento + modelo
- Interpretar los resultados
- realizar análisis de los resultados
- definir recomendaciones

## Automatizada

Utilizar herramientas de AutoML para la selección del mejor modelo, por ejemplo:

- **AutoGlueon** <https://auto.gluon.ai/>
- **Pycaret** <https://pycaret.org/>
- **TabPFN** <https://github.com/PriorLabs/TabPFN>
- **MLJar** <https://mljar.com/automl/>
- **FLAML** <https://microsoft.github.io/FLAML/>

- Realizar el análisis de Learning curve de ser posible
- Analizar Overfitting y Underfitting
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Almacenar el pipeline de preprocesamiento + modelo
- Interpretar los resultados
- realizar análisis de los resultados
- definir recomendaciones

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con los pasos descritos anteriormente y el modelo entrenado en formato  `.joblib`

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento
Analizar las características del modelo obtenido, con el fin de tener un listado de pruebas y experimentos que se van a realizar en la siguiente iteración. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/7-model_interpretation/>

En este proceso se incluye :

- Interpretar el modelo seleccionado
- Identificar los atributos más importantes
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- ¿Cuáles son las consecuencias de las malas predicciones?
- ¿Qué tipo de errores comete el modelo?
- ¿A qué se deben los errores?
    - outliers?
    - Clase desbalanceada?
    - ¿Errores en el ingreso de datos?
    - Encoders?
    - etc

> Puede utilizar las librerías o herramientas que considere para resolver la tarea


# Entregables
Notebook con los pasos descritos anteriormente y el modelo entrenado en formato  `.joblib`

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento
Crear una demo funcional del modelo entrenado, para esto se debe crear un formulario online donde el usuario ingrese los datos y el modelo realice la predicción. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/))

> Cada Proyecto es diferente pero se puede Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/8-deploy/>.

Puede usar la herramienta que desee por ejemplo:

- https://taipy.io/
- https://streamlit.io/
- https://www.gradio.app/

# Entregables

Screenshot o links del demo y el código con las instrucciones para ejecutarlo.
Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la obtención de datos tipo RAW.

- crear la rama a partir de un issue: <https://docs.github.com/es/issues/tracking-your-work-with-issues/using-issues/creating-a-branch-for-an-issue>

- Realizar los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/1-data/>

Descargar los datos y entender el problema a realizar, contestar en el notebook

- ¿Cual es el objetivo del problema?
- ¿Cómo se usará su solución?
- ¿Cuáles son las soluciones actuales (si las hay)?
- ¿Cómo se debe enmarcar este problema (supervisado / no supervisado, en línea / fuera de línea, etc.)
- ¿Cómo se debe medir el desempeño o el rendimiento de la solución, una primera intuicion?
- ¿La medida de desempeño está alineada con el objetivo del problema?
- ¿Cuál sería el desempeño o rendimiento mínimo necesario para alcanzar el objetivo del problema?
- ¿Cuáles son los problemas parecidos? ¿Se puede reutilizar experiencias o herramientas ya creadas?
- ¿Hay experiencia del problema disponible?
- (Importante) ¿Cómo se puede resolver el problema manualmente?
- Hacer un listado de los supuestos que hay hasta este momento.
- Cual es la fuente de los datos?
- Como se actualizan los datos?
- Cada cuanto tiempo se actualizan los datos

# Entregables

Notebook para obtención de los datos.

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD

# Requerimiento

Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la exploración inicial de los datos

- Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/2-exploration/>

el objetivo es realizar una exploración general de datos para verificar los tipos de datos  con el fin de comprender de las características y el esquema de datos  y si es posible solucionar problemas básicos relacionados. realizar

- Descripción general de los datos
- Unificar la forma como se representan los valores Nulos
- Convertir los datos en su tipo correcto (numéricos, categóricos, booleanos, fechas, etc) y corrección de los datos si es necesario, para eu cada columna tenga un tipo de dato uniforme.
- Almacenar el dataset final en un formato adecuado como `.parquet`

# Entregables

Notebook con la exploración general de los datos y los pasos descritos anteriormente

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD

Realizar un buen análisis de datos exploratorio (EDA) para caracterizar los datos disponibles para el proyecto. Crear una nueva rama de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/3-analysis/>

Si su proyecto tiene muchos datos puede dividir el análisis en 3 notebooks diferentes:
- Análisis univariable
- Análisis bivariable
- Análisis multivariable

En este proceso, se incluye :

- Compresión detallada de las características y el esquema de datos.
- Identificación de la preparación de datos y la ingeniería de atributos que se necesitan si se fuera a implementar un modelo de machine learning

- Estudiar cada atributo y sus características (Análisis Univariable):
    - Nombre
    - Tipo de dato (categórico ordinal, nominal, numérico int / float, acotado / no acotado, texto, estructurado, fechas, etc.)
    - porcentaje (%) de valores nulos.
    - valores exactamente duplicados (filas y columnas)
    - Ruido y tipo de ruido (estocástico, valores atípicos, errores de redondeo, etc.)
    - ¿Son posiblemente útiles para el proyecto?
    - Descripción estadística (dependiendo del tipo de dato): por ejemplo para los numéricos
        - Tendencia Central (media, mediana, moda, max, min, etc)
        - Medidas de dispersión (Rango, IQR, cuartiles, varianza, desviación estándar, skewness y kurtosis)
        - Tipo de distribución (gaussiana, uniforme, logarítmica, etc.)
    - Analice los datos para crear las reglas de validación de los datos que serán usadas en otra etapa del proyecto.
- Para los proyectos de aprendizaje supervisado, identifique los atributos objetivo (target).
- Visualización de los datos.
- Estudiar las relaciones entre atributos (Análisis Bivariable)
- Estudiar las relaciones entre varios atributos (Análisis Multivariable)
- Estudiar cómo resolver el problema manualmente. (modelo simple Viable o heurísticas)
- Identificar las transformaciones que tal vez se puedan aplicar.
- Identificar datos adicionales que pueden ser útiles.

> Puede utilizar las librerías o herramientas que considere para resolver la tarea y contestar las preguntas.
> Utilice sistemas automáticos como [Data science Agent](https://developers.googleblog.com/en/data-science-agent-in-colab-with-gemini/) pueden ver un tutorial en este [Link](https://www.youtube.com/watch?v=1WAjTyYEIos)

# Entregables

Notebook con los resultados del análisis exploratorio de los datos, conclusiones e información de los datos
¿Sugerir si se puede realizar un modelo Heurístico que sea viable?

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Realizar el proceso de Feature Engineering para limpieza, transformación y modificación de los datos para que puedan ser usados para entrenar un modelo para resolver un problema. Hacerlo en un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)) y Crear un notebook  para la creación de los pipelines de scikit-learn

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/4-feat_eng/>

En este proceso para cada tipo de datos se incluye :

1. **Limpieza de datos**:
  - Eliminar registros datos duplicados (disminuir el numero de datos)
  - Corregir o eliminar valores atípicos (opcional).
  - Los valores atípicos pueden separarse del dataset dependiendo del problema del proyecto (por ejemplo, detección de anomalías).
  - Completar los valores faltantes (por ejemplo, con cero, media, mediana …) o eliminar las filas (o columnas).
2. Selección de atributos (**Feature Selection**) (opcional):
  - Descartar los atributos que no proporcionan información útil para el proyecto.
  - Eliminar registros duplicados (al eliminar atributos pueden quedar registros iguales)
3. Ingeniería de atributos (**Feature Engineering**), cuando sea apropiado:
  - Discretizar las atributos continuas.
  - (opcional) Descomponer en partes los atributos (p. Ej., Categóricas, fecha / hora, etc.).
  - (opcional) Agregar transformaciones prometedoras de las atributos, por ejemplo:
    - log(x)
    - sqrt(x)
    - x^2
    - etc
  - Aplicar funciones a los datos para agregar nuevos atributos.
4. Escalado de atributos (**Feature Scaling**):
  - estandarizar
  - normalizar
  - etc
5. Encoding
  - Encode variables categóricas, texto y las que sean necesarias para poder ser usadas para el modelamiento

Crear todas estas transformaciones usando transformadores y pipelines de scikit-learn
-  https://scikit-learn.org/stable/modules/preprocessing.html
-  https://scikit-learn.org/stable/modules/compose.html#

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con la descripción y creación de los pipelines de scikit-learn.

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Crear un modelo base para tenerlo como referencia para luego comparar al entrenar modelos de machine learning, el modelo base puede ser un modelo de heurísticas o un [modelo dummy](https://scikit-learn.org/stable/api/sklearn.dummy.html). Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/5-baseline_model/>

En este proceso se incluye :

- Usar pipeline de procesamiento de datos creado en la tarea anterior
- Dividir los datos en Train / Test
- Evaluar con diferentes métricas según el problema que se esta solucionando
- Usar validación cruzada (Cross validation) y obtener la media y la desviación estándar de la medida de las evoluciones realizadas.
- Seleccionar la variable mas importante y justificar por que se selecciona.
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Interpretar los resultados
- realizar análisis de los resultados
- realizar conclusiones
- definir recomendaciones para crear un modelo en base a los resultados del modelo base
- Propuestas y ideas en base a os resultados obtenidos

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con la descripción y creación de los pipelines de scikit-learn, además de los resultados del modelo base.
Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Realizar el proceso de selección del mejor modelo de machine learning para resolver el problema de machine Learning, este modelo debe ser mejor que el modelo baseline. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

Se puede solucionar:

- Manual
- Automatizada

Seleccione la opción que considere mejor. (Es un buen momento para conocer las herramientas de AutoML)

## Manual

> Si lo va hacer manual Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/6-model_selection/>

De ser Manual este proceso se incluye :

- Usar pipeline de procesamiento de datos creado en la tarea anterior
- Dividir los datos en Train / Test
- seleccionar multiples modelos de machine learning según el problema (mínimo 4 tipos diferentes)
- Evaluar con diferentes métricas según el problema que se esta solucionando (En la tarea anterior se definió cual seria la métrica mas importante)
- Eliminar los modelos que funciones por debajo del promedio de los modelos
- Evaluar los modelos restantes usando validación cruzada (Cross validation) y obtener la media y la desviación estándar de la medida de las evoluciones realizadas. (recuerde usar pipelines de la union del pipeline de transformación y el modelo)
- los dos o tres mejores modelos realizar el proceso de optimización de hiperparametros, recuerde usar cross validation y los pipelines
- Comparar los resultados y seleccionar el mejor modelo (recuerde usar pruebas estadísticas en la comparación para seleccionar el mejor modelo)
- Entrenar con todo el dataset de train el modelo seleccionado con sus hiperparametros, luego hacer la predicción con el dataset de test y realizar la evaluación de desempeño.
- si los resultados de la evaluación de test, se presenta, underfitting, overfitting repetir el proceso nuevamente con otros modelos y otras configuraciones, si no se logra un buen desempeño es necesario repetir el proceso de feature engineering.
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Almacenar el pipeline de preprocesamiento + modelo
- Interpretar los resultados
- realizar análisis de los resultados
- definir recomendaciones

## Automatizada

Utilizar herramientas de AutoML para la selección del mejor modelo, por ejemplo:

- **AutoGlueon** <https://auto.gluon.ai/>
- **Pycaret** <https://pycaret.org/>
- **TabPFN** <https://github.com/PriorLabs/TabPFN>
- **MLJar** <https://mljar.com/automl/>
- **FLAML** <https://microsoft.github.io/FLAML/>

- Realizar el análisis de Learning curve de ser posible
- Analizar Overfitting y Underfitting
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- Almacenar el pipeline de preprocesamiento + modelo
- Interpretar los resultados
- realizar análisis de los resultados
- definir recomendaciones

> Puede utilizar las librerías o herramientas que considere para resolver la tarea

# Entregables

Notebook con los pasos descritos anteriormente y el modelo entrenado en formato  `.joblib`

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento
Analizar las características del modelo obtenido, con el fin de tener un listado de pruebas y experimentos que se van a realizar en la siguiente iteración. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/)).

> Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/7-model_interpretation/>

En este proceso se incluye :

- Interpretar el modelo seleccionado
- Identificar los atributos más importantes
- Realizar el análisis de Learning curve
- obtener las gráficas de escalabilidad con tiempo de entrenamiento y score
- ¿Cuáles son las consecuencias de las malas predicciones?
- ¿Qué tipo de errores comete el modelo?
- ¿A qué se deben los errores?
    - outliers?
    - Clase desbalanceada?
    - ¿Errores en el ingreso de datos?
    - Encoders?
    - etc

> Puede utilizar las librerías o herramientas que considere para resolver la tarea


# Entregables
Notebook con los pasos descritos anteriormente y el modelo entrenado en formato  `.joblib`

Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento
Crear una demo funcional del modelo entrenado, para esto se debe crear un formulario online donde el usuario ingrese los datos y el modelo realice la predicción. Crear un nuevo branch de git (Usar [Gitflow](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/control-versiones/branching-model/))

> Cada Proyecto es diferente pero se puede Tomar como ejemplo los pasos de: <https://joserzapata.github.io/post/ciencia-datos-proyecto-python/8-deploy/>.

Puede usar la herramienta que desee por ejemplo:

- https://taipy.io/
- https://streamlit.io/
- https://www.gradio.app/

# Entregables

Screenshot o links del demo y el código con las instrucciones para ejecutarlo.
Se debe realizar un Pull request para ingresar el notebook a la rama`main` para esto debe tener mínimo 1 revisiones de otras personas del Curso y que pase los check del CI/CD.

# Requerimiento

Crear un script o notebook que permita almacenar los **datos históricos** del proyecto en un **Feature Store**, por ejemplo usando [Hopsworks](https://www.hopsworks.ai/).
El objetivo es dejar registrada una versión histórica de los features, que pueda ser usada posteriormente para entrenamiento e inferencias del modelo.

## El proceso debe incluir:

- Lectura de los datos originales (en bruto o preprocesados, según se defina para el proyecto).
- Registro de los features creados con los datos históricos.

Puede utilizar este notebook como ejemplo: <https://github.com/JoseRZapata/air-quality-fti/blob/main/notebooks/1-data/1_air_quality_feature_backfill.ipynb>

Ejemplo de como configurar el Feature Store de Hopsworks y obtener la llave api para configurar github actions:

<https://id2223kth.github.io/assignments/2024/lab1/id2223-kth-lab1-2024.pdf>


# Entregables

- Script  o notebook con el proceso completo de carga de datos históricos en el feature store.
- Evidencia de que los datos se almacenaron correctamente en el Feature Store (logs, capturas de pantalla, validaciones automáticas, etc.).

# Validación

Se debe realizar un Pull Request con:

- El archivo del script o notebook.
- Comentarios que expliquen cada parte del proceso.
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD en caso de incluir scripts.

# Requerimiento

Crear un script en Python llamado `feature_pipeline.py` cuya responsabilidad sea:

- Leer los datos originales desde la fuente definida para el proyecto.
- Realizar el proceso de transformación de los datos en features adecuados para el modelo de machine learning. Este proceso debe incluir:

- Almacenar el resultado final (los features procesados) en un **Feature Store**, por ejemplo [Hopsworks](https://www.hopsworks.ai/).

El script debe poder ejecutarse de forma autónoma

Se puede tomar como ejemplo los siguentes archivos

- <https://github.com/JoseRZapata/air-quality-fti/blob/main/src/pipelines/feature_pipeline/feature-pipeline.py>

# Entregables

- Script `feature_pipeline.py` completamente funcional.
- Debe pasar todas las pruebas de `pre-commit` configuradas en el repositorio.
- Debe incluir **pruebas unitarias** con una cobertura mínima aceptable (idealmente usando `pytest`).
  - Las pruebas pueden ejecutarse sobre una muestra de datos sintéticos para verificar el correcto funcionamiento de cada etapa de la transformación y carga.

# Validación

Se debe realizar un Pull Request con:

- El script `feature_pipeline.py`.
- Los archivos de pruebas unitarias.
- Evidencia de ejecución correcta (log, resultados, o notebook de prueba si aplica).
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD.

Aquí tienes la tarea redactada en formato **Markdown** para agregar el proceso de **validación de datos** al `feature_pipeline.py`, tomando como base la guía proporcionada:

```markdown
# Requerimiento

Modificar el script `feature_pipeline.py` para incluir un paso de **validación de datos** antes de almacenar los datos en el Feature Store.
Este proceso debe garantizar que los datos transformados cumplan con las expectativas de calidad, consistencia y formato definidos para el proyecto.

> Tomar como referencia:
> [Validación de Datos en Proyectos de Ciencia de Datos - Curso Producción](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/data-validation/)

## El proceso debe incluir:

- Definir un conjunto de reglas de validación sobre los datos procesados, tales como:
  - Tipos de datos esperados por columna.
  - Rango de valores aceptables.
  - Porcentaje máximo de valores nulos permitido por columna.
  - Validaciones sobre categorías válidas, formatos de fechas, unicidad de campos clave, etc.

- Implementar las validaciones utilizando herramientas como:
  - [`Great Expectations`](https://greatexpectations.io/)
  - [`Pandera`](https://pandera.readthedocs.io/)
  - Validaciones manuales con `pandas`, si aplica.

- Si alguna validación **falla**, el script debe:
  - Lanzar un error explicativo o loggear claramente el fallo.
  - **No almacenar** los datos en el Feature Store si no pasan las validaciones.

- Documentar las validaciones implementadas dentro del código y/o en un archivo adicional si es necesario.

> Se recomienda realizar las validaciones después de aplicar las transformaciones, pero antes del almacenamiento.

## Ejemplo de recursos de referencia:

- [Validación con Pandera](https://pandera.readthedocs.io/en/stable/examples/column_checks.html)
- [Ejemplo real con Great Expectations](https://greatexpectations.io/blog/how-to-test-data-pipelines/)

# Entregables

- Script `feature_pipeline.py` actualizado con las validaciones incluidas.
- Regla(s) de validación definidas y documentadas.
- Evidencia de ejecución exitosa con datos válidos.
- Evidencia de fallo controlado ante datos inválidos (por ejemplo, en pruebas unitarias).

# Validación

Se debe realizar un Pull Request con:

- El script `feature_pipeline.py` actualizado.
- Los archivos de pruebas unitarias con datos válidos e inválidos.
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD.

# Requerimiento

Crear un script en Python llamado `train_pipeline.py` cuya responsabilidad sea:

- Leer los datos procesados (features) desde el **Feature Store**, por ejemplo [Hopsworks](https://www.hopsworks.ai/).
- Realizar el proceso completo de entrenamiento de un modelo de machine learning. Este proceso debe incluir:
  - División de los datos en conjuntos de entrenamiento y prueba (train/test).
  - Entrenamiento del modelo utilizando el pipeline de procesamiento si aplica.
  - Evaluación del modelo con las métricas apropiadas según el problema.
  - Almacenamiento del modelo entrenado en el sistema de archivos o almacenamiento del proyecto.
  - Almacenamiento de los resultados de evaluación y/o métricas.

El script debe poder ejecutarse de forma autónoma.

Se puede tomar como ejemplo los siguientes archivos:

- <https://github.com/JoseRZapata/air-quality-fti/blob/main/src/pipelines/training_pipeline/train-pipeline.py>

# Entregables

- Script `train_pipeline.py` completamente funcional.
- Debe pasar todas las pruebas de `pre-commit` configuradas en el repositorio.
- Debe incluir **pruebas unitarias** con una cobertura mínima aceptable (idealmente usando `pytest`).
  - Las pruebas pueden ejecutarse con un conjunto de datos sintético o reducido, validando:
    - Lectura de datos.
    - Entrenamiento correcto del modelo.
    - Generación de métricas.
    - Almacenamiento del modelo.

# Validación

Se debe realizar un Pull Request con:

- El script `train_pipeline.py`.
- Los archivos de pruebas unitarias.
- Evidencia de ejecución correcta (log, resultados, o notebook de prueba si aplica).
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD.

# Requerimiento

Modificar el script `train_pipeline.py` para incluir el proceso de **seguimiento de experimentos (experiment tracking)**.

Este proceso permitirá registrar automáticamente todos los detalles de cada entrenamiento de modelos, facilitando la comparación, auditoría y reproducibilidad de los experimentos realizados.

> Tomar como referencia:
> [Seguimiento de Experimentos - Ciencia de Datos en Producción](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/experiment-tracking/)

## El proceso debe incluir:

- Registro automático de los experimentos qu se van a realizar

- Se puede utilizar una de las siguientes herramientas (u otra acordada con el equipo):
  - [`MLflow`](https://mlflow.org/)
  - [`Weights & Biases`](https://wandb.ai/)
  - [`Comet ML`](https://www.comet.com/)


## Buenas prácticas sugeridas:

- Agrupar experimentos por nombre de proyecto o versión.
- Agregar una descripción clara de cada experimento.
- Asegurar que los experimentos sean reproducibles (guardar seeds, configuraciones, datasets, etc).
- Hacer logging de los pasos haciendo uso de herramientas como [loguru](https://codecut.ai/simplify-your-python-logging-with-loguru/).

# Entregables

- Script `train_pipeline.py` actualizado con el proceso de experiment tracking funcional.
- Registro de al menos un experimento de prueba.
- Configuración de acceso a la herramienta de tracking (si aplica).
- Evidencia de los resultados registrados (pantallazo, log o URL del experimento).

# Validación

Se debe realizar un Pull Request con:

- Script actualizado.
- Configuración adicional necesaria (por ejemplo, token de acceso, URL del servidor, archivo `.env`).
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD.

# Requerimiento

Modificar el script `train_pipeline.py` para incluir un paso de **verificación de la separación entre el conjunto de entrenamiento (train) y el de prueba (test)**.

Este paso busca asegurar que no exista **fuga de información** y que ambos conjuntos representen correctamente la distribución esperada del problema.

> Tomar como referencia:
> [Train/Test Split Checks - Validación de Datos](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/data-validation/train_test-checks/)

## El proceso debe incluir:

- Resultados de las validaciones

> Estos pasos se pueden implementar con herramientas como:
> - [`evidently`](https://docs.evidentlyai.com/)
> - [`DeepChecks`](https://docs.deepchecks.com/stable/)

## Recomendaciones:

- Si se detecta algún problema en la separación, el script debe emitir una advertencia clara o detener la ejecución con un error controlado.
- Estas validaciones pueden implementarse como una función independiente dentro del pipeline (`validate_train_test_split()`), para facilitar su testeo y reutilización.

# Entregables

- Script `train_pipeline.py` actualizado con los chequeos integrados.
- Evidencia de ejecución sobre un conjunto de datos válido.
- Registro de métricas en sistema de experiment tracking.

# Validación

Se debe realizar un Pull Request con:

- Script actualizado con el chequeo.
- Pruebas unitarias asociadas, incluyendo casos válidos e inválidos.
- Validación de al menos una persona del equipo.
- El pipeline debe pasar los checks del CI/CD.

# Requerimiento

Actualizar el script `train_pipeline.py` para incluir un proceso robusto de **validación del modelo**, con enfoque en la correcta separación de datos (`train/test split`) y la evaluación confiable del rendimiento del modelo.

> Basado en las buenas prácticas descritas en:
> [Validación del Modelo - Ciencia de Datos en Producción](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/model-validation/)

## El proceso debe incluir:

- Aplicar una estrategia de **evaluación cruzada (cross-validation)** sobre el conjunto de entrenamiento (`train`) para estimar el rendimiento del modelo.
  - Puede utilizarse:
    - K-Fold
    - StratifiedKFold
    - TimeSeriesSplit (para series temporales)

- Evaluar el modelo usando métricas relevantes:
  - Clasificación: precisión, recall, F1, AUC, matriz de confusión, etc.
  - Regresión: MAE, RMSE, R², etc.

- Comparar las métricas entre:
  - Validación cruzada (CV)
  - Evaluación en el conjunto de prueba (`test`)

- Analizar el posible **underfitting/overfitting** con base en la diferencia de rendimiento entre `train`, `CV` y `test`.

## Recomendaciones

- Las métricas y gráficos deben registrarse en el sistema de experiment tracking si está integrado (por ejemplo, MLflow).
- Si el modelo presenta problemas de generalización, documentar posibles soluciones (más datos, regularización, features, etc.)

# Entregables

- Script `train_pipeline.py` actualizado con:
- Visualizaciones o logs generados como evidencia.
- Registro de métricas en sistema de experiment tracking.

# Validación

Se debe realizar un Pull Request con:

- Script actualizado
- Ejecución reproducible de validación
- Validación de al menos una persona del equipo
- Todos los checks del CI/CD deben pasar correctamente

Aquí tienes la tarea redactada para la creación del script `inference_pipeline.py`, siguiendo el mismo formato que las anteriores:

```markdown
# Requerimiento

Crear un script en Python llamado `inference_pipeline.py` cuya responsabilidad sea:

- Cargar el modelo entrenado desde el almacenamiento del proyecto (por ejemplo, desde un archivo `.joblib`).
- Leer los datos desde el **Feature Store** o desde una fuente de datos nueva (por ejemplo, datos recientes o en tiempo real).
- Aplicar el mismo pipeline de transformación utilizado en el entrenamiento, si aplica.
- Generar predicciones utilizando el modelo cargado.
- Almacenar o registrar las predicciones generadas en el feature store o en un archivo de salida.

El script debe poder ejecutarse de forma autónoma (por ejemplo, desde un pipeline de producción ).

Se puede tomar como ejemplo los siguientes archivos:

- <https://github.com/JoseRZapata/air-quality-fti/blob/main/src/pipelines/inference_pipeline/inference-pipeline.py>

# Entregables

- Script `inference_pipeline.py` completamente funcional.
- Debe pasar todas las pruebas de `pre-commit` configuradas en el repositorio.
- Debe incluir **pruebas unitarias** con una cobertura mínima aceptable (idealmente usando `pytest`).
  - Las pruebas pueden ejecutarse con un modelo dummy y datos sintéticos para verificar:
    - Carga del modelo.
    - Transformación de los datos de entrada.
    - Generación correcta de predicciones.
    - Almacenamiento o visualización de los resultados.

# Validación

Se debe realizar un Pull Request con:

- El script `inference_pipeline.py`.
- Los archivos de pruebas unitarias.
- Evidencia de ejecución correcta (log, archivo de salida, notebook de prueba si aplica).
- Validación de al menos una persona del equipo.
- Debe pasar los checks del CI/CD.

Aquí tienes una tarea en **formato Markdown** para integrar procesos de **automatización con GitHub Actions** para los pipelines de `feature`, `training` e `inference`, siguiendo los ejemplos de los enlaces proporcionados.

---

```markdown
# Requerimiento

Automatizar la ejecución de los principales pipelines del proyecto (`feature pipeline`, `train pipeline`, `inference pipeline`) utilizando **GitHub Actions**.

> Referencias:
> - [air-quality-daily.yml](https://github.com/JoseRZapata/air-quality-fti/blob/main/.github/workflows/air-quality-daily.yml)
> - [air-quality-train.yml](https://github.com/JoseRZapata/air-quality-fti/blob/main/.github/workflows/air-quality-train.yml)

## Objetivo

- Crear y configurar flujos de trabajo (`workflows`) en el repositorio que ejecuten automáticamente los siguientes scripts:

  - `feature_pipeline.py` — ejecución diaria o al detectar nuevos datos.
  - `train_pipeline.py` — ejecución semanal, bajo demanda o tras actualizar el feature store.
  - `inference_pipeline.py` — ejecución diaria o continua en función del caso de uso.

## El flujo debe incluir:

- Uso de **GitHub Actions** para automatizar las ejecuciones desde la carpeta `.github/workflows/`.
- Cada archivo `.yml` debe contener:
  - Definición del **trigger** (cron, push, manual).
  - Instalación de dependencias del entorno (idealmente desde `requirements.txt`).
  - Configuración de variables de entorno necesarias (API keys, configuraciones del feature store, etc).
  - Ejecución del script correspondiente con logs visibles en la ejecución del workflow.

## Workflows sugeridos:

### 1. `feature-pipeline.yml`

- Frecuencia: diaria (`cron`)
- Tarea: Ejecutar `feature_pipeline.py`

### 2. `train-pipeline.yml`

- Frecuencia: semanal o manual (`workflow_dispatch`)
- Tarea: Ejecutar `train_pipeline.py` para reentrenar el modelo con nuevos datos

### 3. `inference-pipeline.yml`

- Frecuencia: diaria (`cron`) o disparado manualmente
- Tarea: Ejecutar `inference_pipeline.py` para generar predicciones

# Entregables

- Archivos `.yml` dentro de `.github/workflows/`:
- Logs de ejecución exitosos visibles en GitHub Actions.


# Validación

Se debe realizar un Pull Request con:

- Archivos `.yml` funcionando y validados
- Evidencia de ejecución automatizada exitosa
- Los checks del CI/CD deben pasar correctamente

# Requerimiento

Desplegar el proyecto en un entorno accesible a otros usuarios, utilizando **FastAPI** o **Streamlit**, dependiendo del tipo de proyecto:

- **FastAPI**: Para proyectos que requieren exponer modelos o funciones como APIs REST.
  > Referencia: [Despliegue de modelos con FastAPI](https://joserzapata.github.io/courses/ciencia-datos-en-produccion/despliegue-modelos-fastapi/)

- **Streamlit**: Para proyectos que requieren una demo interactiva de fácil uso.
  > Referencia: [Demo con Streamlit](https://joserzapata.github.io/post/ciencia-datos-proyecto-python/8-demo-streamlit/)

> Ejemplo completo de proyecto desplegado:
> - [Repositorio](https://github.com/JoseRZapata/air-quality-fti)
> - [Demo](https://joserzapata.github.io/air-quality-fti/)

## Objetivo

- Implementar una interfaz (API o GUI) que permita interactuar con los resultados del proyecto (modelo entrenado, visualizaciones, predicciones, etc).
- El despliegue debe ejecutarse localmente y accesible a través de un navegador web.

## Buenas prácticas a seguir

- El código debe estar limpio, modular y documentado.
- Uso adecuado de `pyproject.toml`.
- Si aplica, incluir instrucciones de despliegue en el README del proyecto.

# Entregables

- Código funcional del despliegue (FastAPI o Streamlit) en la carpeta del proyecto.
- Instrucciones de uso local incluidas en el README.
- URL para acceder al modelo

# Validación

Se debe realizar un Pull Request con:

- Código funcional de despliegue.
- Evidencia de funcionamiento local (captura de pantalla o log).
- Validación de al menos una persona del equipo.
- Todos los checks del CI/CD deben pasar.