Fundamentos de MLOps y tracking de modelos
驴Qu茅 es MLOps y para qu茅 sirve?
Tracking de modelos en localhost con MLflow
Tracking de modelos en localhost: directorio personalizado
Etapas del ciclo de MLOps
Componentes de MLOps
Tracking de modelos con MLflow y SQLite
Tracking de modelos con MLflow en la nube
Tracking del ciclo de vida de modelos de machine learning
Tracking de experimentos con MLflow: preprocesamiento de datos
Tracking de experimentos con MLflow: definici贸n de funciones
Tracking de experimentos con MLflow: tracking de m茅tricas e hiperpar谩metros
Tracking de experimentos con MLflow: reporte de clasificaci贸n
Entrenamiento de modelos baseline y an谩lisis en UI de MLflow
MLflow Model Registry: registro y uso de modelos
Registro de modelos con mlflow.client
Testing de modelo desde MLflow con datos de prueba
驴Para qu茅 sirve el tracking de modelos en MLOps?
Orquestaci贸n de pipelines de machine learning
Tasks con Prefect
Flows con Prefect
Flow de modelo de clasificaci贸n de tickets: procesamiento de datos y features
Flow de modelo de clasificaci贸n de tickets: integraci贸n de las tasks
Flow de modelo de clasificaci贸n de tickets: ejecuci贸n de tasks
驴C贸mo se integra la orquestaci贸n en MLOps?
Despliegue de modelo de machine learning
Despligue con Docker y FastAPI: configuraci贸n y requerimientos
Despligue con Docker y FastAPI: definici贸n de clases y entry point
Despligue con Docker y FastAPI: procesamiento de predicciones en main app
Despligue con Docker y FastAPI: configuraci贸n de la base de datos
Despliegue y pruebas de modelo de machine learning en localhost
Despliegue y pruebas de modelo de machine learning en la nube
驴Qu茅 hacer con el modelo desplegado?
Monitoreo de modelo de machine learning en producci贸n
驴C贸mo monitorear modelos de machine learning en producci贸n?
Entrenamiento de modelo baseline
Preparar datos para crear reporte con Evidently
An谩lisis de la calidad de los datos con Evidently
Creaci贸n de reportes con Grafana
驴C贸mo mejorar tus procesos de MLOps?
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Despligue con Docker y FastAPI: definici贸n de clases y entry point
24/35How to create an application with batch processing and predictions?
In the world of software development, one of the most valuable skills is the ability to build robust and efficient applications. Here, we will focus on creating an application that not only easily handles multiple inputs (thanks to batch processing), but also generates predictions using a pre-trained model. This type of solution is essential, especially when working with large volumes of data and a fast response system is required.
What libraries and tools do I need to import?
To begin with, it is necessary to import a series of libraries and tools that will allow the application to function optimally:
- PaaS API: Essential for deployment and management of entry points.
- Pydantic (BaseModel): Useful for structuring incoming data and defining schemas for the database.
- Joblib: For loading pre-trained models.
- Other libraries: Provide data processing and transformation functions.
How is the structure of the input data defined?
The application architecture is based on a robust input model that can handle multiple requests simultaneously. Here, we define classes to structure the data that will enter the system:
from pydantic import BaseModel
class Sentence(BaseModel): client_name: str text: str
class ProcessTextRequestModel(BaseModel): sentences: list[Sentence].- Class Sentence: Defines the basic properties of each entry, such as the client's name and the text associated to the ticket.
- ProcessTextRequestModel class: Specifies that each entry can contain multiple sentences, allowing simultaneous data processing.
How to implement the entry point and processing?
Encapsulation of the entry point is vital to execute the underlying business logic. Implementing an asynchronous method to handle predicates is crucial:
@app.post("/predict")async def read_root(data: ProcessTextRequestModel): # Main application logic with Session() as session: # Load pre-trained model model model = joblib.load('model.pql')
# Create empty list for predicates pred_list = []
# Input processing for sentence in data.sentences: # Process each text and store predictions processed_text = preprocess_text(sentence.text) prediction = model.predict(processed_text) pred_list.append(prediction)
# Store results in database store_results(pred_list, session)- Asynchronous function definition: Ensures that request processing does not block the application.
- Load model: With
joblib, a pre-trained model is loaded, ensuring efficient predictions. - Create and store predictions: Each text is processed and predicted, storing the results for later use.
How to handle and decode predictions?
The mapping of identifying labels is critical to transform numerical predictions into meaningful descriptions:
label_mapping = { 0: "Banking Service", 1: "Credit Report", 2: "Mortgage/Loan"}
# decoding exampledecoded_predictions = [label_mapping[pred] for pred in pred_list]- Label Mapping: A dictionary that translates numerical predictions into understandable terms, connecting directly to business sense.
This process not only improves the interpretation of results, but also integrates an additional layer of understanding for end users. Are you ready to take your skills to the next level and create applications that not only simplify processes, but also provide valuable insights? The road to excellence in software development awaits you!
Contributions 1
Questions 0
Want to see more contributions, questions and answers from the community?