- 1

Implementación de MLOps para Modelos de Machine Learning
02:10 - 2

Principios y Etapas del MLOps en Machine Learning
09:21 - 3

Componentes de Infraestructura en MLOps: Control, Integración y Monitorización
08:23 - 4

Tracking de Modelos de Machine Learning con MLflow Local
12:48 - 5

Seguimiento local de experimentos con MLflow usando folder personalizado
04:53 - 6

Tracking de Experimentos con MLflow y Bucket en SQLite
04:04 - 7

Tracking de Experimentos de Machine Learning con AWS y MLflow
09:11
Preprocesamiento y Predicción de Texto en Modelos de Machine Learning
Clase 25 de 35 • Curso de MLOPS: Despliegue de Modelos de Machine Learning
Contenido del curso
- 8

Clasificación de Tickets con Procesamiento de Lenguaje Natural
10:41 - 9

Tracking de Datos y Modelado con MNLflow y Scikit-learn
10:30 - 10

Tracking de Métricas e Hiperparámetros con Validación Cruzada
07:19 - 11

Tracking de Modelos y Métricas con MLflow y CycleLearn
08:53 - 12

Optimización de Hiperparámetros en Modelos de Machine Learning
12:17 - 13

Creación y gestión de experimentos con MLflow y Scikit-Learn
10:29 - 14

Promoción y Gestión de Modelos en Azure con MLflow
09:05 - 15

Validación de Modelos de Machine Learning con MLflow y SciPy
05:15 - 16

Tracking y Trazabilidad en MLOps con MLflow
07:41
- 17

Creación de tareas en Prefect para flujos de Machine Learning
08:49 - 18

Creación de Flujos de Trabajo con Prefect para Machine Learning
08:58 - 19

Pipeline de Machine Learning para Clasificación de Tickets
11:55 - 20

Pipeline de Procesamiento y Entrenamiento de Modelos de Datos
09:57 - 21

Ejecución de Flujos de Trabajo con Prefect: Conceptos y Prácticas
04:55 - 22

Orquestación de Flujos Flexibles con Prefect y Python
04:51
- 23

Despliegue de Aplicaciones con Docker y FAS API en AWS
08:01 - 24

Creación de Aplicación con PaaS API, Docker y Grafana
06:39 - 25

Preprocesamiento y Predicción de Texto en Modelos de Machine Learning
10:02 - 26

Configuración de Base de Datos en SQLModel y Docker Compose
05:28 - 27

Despliegue Local y en AWS de Aplicaciones con Docker y Postman
13:37 - 28

Implementación de Modelos en Entornos Productivos con AWS y Docker
12:53 - 29

Autoescalado y Entrega Continua de Modelos en Producción
02:31
- 30

Monitoreo de Modelos en Producción: Estrategias y Métricas Clave
11:48 - 31

Monitoreo de Modelos en Producción: Calidad de Datos y Data Drift
20:53 - 32

Modelo de Clasificación con Support Vector Classifier
13:23 - 33

Análisis de Drift y Valores Faltantes con Evidently
12:25 - 34

Creación de Dashboards y Visualizaciones en Grafana para Machine Learning
07:05 - 35

Mejora de Procesos MLOps e Infraestructura Escalable
02:48
¿Cómo procesamos y predecimos datos de texto en un modelo batch?
Para trabajar con procesamiento por lotes, o batch processing, es esencial estructurar los datos adecuadamente. En este contexto, usaremos la clase "Sentence" que hereda de "BaseModel" y acepta dos parámetros principales: "client name" y "text". Esta estructura nos permitirá iterar a través de los datos del request, que se espera como una lista de strings. A continuación, en un bucle for, recorreremos cada sentencia o string que compone esta lista.
¿Cómo pre-procesamos y vectorizamos las sentencias?
El primer paso en el procesamiento involucra la vectorización. Utilizamos una función de preprocesamiento llamada "preprocessing function" que toma como argumento el texto de cada sentencia: sentence.text. El objetivo es convertir este texto en una matriz dispersa utilizando un Convectorizer y transformaciones basadas en la frecuencia inversa (TF-IDF).
El resultado es una matriz con:
- Número de filas: Corresponde al número de documentos, textos o sentencias.
- Columnas: Representan las palabras únicas en el conjunto de datos.
Dado que las matrices dispersas suelen incluir muchos ceros, configuramos x_dense como dicha estructura y continuamos apilándola verticalmente para que el modelo interprete correctamente la representación de los datos.
process_data_vectorize = preprocessing_function(sentence.text)
x_dense = some_sparse_matrix_creation_method(process_data_vectorize)
¿Cómo se generan las predicciones del modelo?
Con nuestra representación de datos en su lugar, podemos proceder con las predicciones. El modelo, previamente cargado, utilizará el método .predict, que procesará la matriz dispersa x_dense. Los resultados se almacenarán en una lista de predicciones.
Luego, decodificamos estas predicciones mediante label_mapping, extrayendo el valor en la primera posición ya que se asume que habrá un único elemento en cada iteración del list.
preds = model.predict(x_dense)
decoded_pred = decode_predictions(label_mapping, preds[0])
¿Cómo almacenamos y devolvemos las predicciones?
Una vez obtenidas, las predicciones se encapsulan en un objeto denominado prediction_ticket, el cual contiene información del cliente y la predicción decodificada. Este objeto se imprime y luego todas las predicciones se almacenan en una lista llamada preds_list a través del método append.
Para finalizar, las predicciones se guardan en la base de datos utilizando una sesión previamente definida y el método session.commit para realizar la inserción masiva. Finalmente, se cierra la sesión, asegurando que los datos estén persistentes y listos para su consulta.
session.add(prediction_ticket)
session.commit()
session.close()
Antes de retornar las predicciones, se debe definir el formato de salida, que en la mayoría de los casos será un JSON. Este formato se regresa mediante un método return que estructura dicha lista de predicciones para su fácil consumo.
return {"predictions": preds_list}
En resumen, al inicializar la aplicación, se debe asegurar que la base de datos y estructuras necesarias estén configuradas correctamente. A través de eventos de inicio (startup), la creación de la base de datos y sus tablas se gestionará eficazmente, sentando las bases para operaciones futuras.