Carga y preprocesamiento de modelos

Buenas, muy interesante el curso, la duda que se me presenta es cómo se realiza con imágenes con la parte de writefile

Hola Giovanny, no entiendo muy bien la pregunta, a que te refieres con la parte de writefile?

El preprocesamiento y la carga de modelos en Google Cloud Platform (GCP) son pasos fundamentales en el ciclo de MLOps. GCP proporciona herramientas para administrar estos pasos, entre ellas **Vertex AI**, **Cloud Storage**, y **BigQuery**. A continuación, describo los pasos para realizar el preprocesamiento de datos y cargar modelos entrenados en GCP usando Python, GCS, y Vertex AI.

### 1. **Configurar Google Cloud SDK e Instalar Librerías Necesarias**

Primero, asegúrate de tener el SDK de Google Cloud instalado y autenticado.

\# Autenticación en Google Cloud

gcloud auth login



\# Configuración del proyecto en Google Cloud

gcloud config set project \[PROJECT\_ID]

Luego, instala las bibliotecas necesarias si estás trabajando en un entorno local.

pip install google-cloud-storage google-cloud-bigquery google-cloud-aiplatform pandas scikit-learn

### 2. **Carga y Preprocesamiento de Datos en Google Cloud**

La preparación de datos es clave para obtener un rendimiento óptimo del modelo. Este proceso suele incluir tareas como limpieza de datos, transformación y almacenamiento en un formato eficiente para el entrenamiento.

#### a. **Cargar Datos desde Cloud Storage**

Para almacenar y cargar datos, sube tus archivos a un bucket en **Google Cloud Storage (GCS)** y utiliza la biblioteca google-cloud-storage para acceder a ellos.

from google.cloud import storage

import pandas as pd



def load\_data\_from\_gcs(bucket\_name, file\_name):

    client = storage.Client()

    bucket = client.get\_bucket(bucket\_name)

    blob = bucket.blob(file\_name)

    data = blob.download\_as\_string()

    \# Leer el archivo en un DataFrame

    df = pd.read\_csv(pd.io.common.StringIO(data.decode('utf-8')))

    return df



\# Ejemplo de uso

bucket\_name = "my-bucket"

file\_name = "data/dataset.csv"

df = load\_data\_from\_gcs(bucket\_name, file\_name)

#### b. **Preprocesar los Datos**

Con el dataset cargado en un DataFrame de Pandas, puedes realizar transformaciones de preprocesamiento, como normalización, codificación de variables categóricas, y dividir los datos en conjuntos de entrenamiento y prueba.

from sklearn.model\_selection import train\_test\_split

from sklearn.preprocessing import StandardScaler



def preprocess\_data(df):

    \# Ejemplo: eliminar valores nulos

    df = df.dropna()

    

    \# Dividir características y variable objetivo

    X = df.drop(columns=\['target'])

    y = df\['target']

    

    \# Escalado de características

    scaler = StandardScaler()

    X\_scaled = scaler.fit\_transform(X)

    

    \# Dividir en conjuntos 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)

    

    return X\_train, X\_test, y\_train, y\_test



X\_train, X\_test, y\_train, y\_test = preprocess\_data(df)

### 3. **Entrenamiento del Modelo en Vertex AI**

Para entrenar el modelo en GCP, puedes usar **Vertex AI**, que permite entrenar modelos en la nube con tus propios scripts de Python o imágenes de Docker personalizadas.

#### a. **Subir el Script de Entrenamiento a GCS**

Guarda tu script de entrenamiento (train.py) y súbelo a un bucket de GCS.

gsutil cp src/train.py gs://\[BUCKET\_NAME]/scripts/train.py

#### b. **Configurar el Entrenamiento en Vertex AI**

1. Desde la consola de Google Cloud, dirígete a **Vertex AI > Entrenamiento**.

2. Elige **Entrenamiento personalizado** y selecciona tu script o contenedor personalizado.

3. Configura los parámetros del entrenamiento, como el tamaño de la máquina, los hiperaparámetros y el bucket de salida donde se almacenará el modelo entrenado.

#### c. **Entrenamiento del Modelo en Vertex AI con Python**

También puedes ejecutar el entrenamiento programáticamente utilizando la biblioteca google-cloud-aiplatform:

from google.cloud import aiplatform



aiplatform.init(project="my-project", location="us-central1")



\# Configurar job de entrenamiento

job = aiplatform.CustomPythonPackageTrainingJob(

    display\_name="my\_training\_job",

    python\_package\_gcs\_uri="gs://\[BUCKET\_NAME]/scripts/train.py",

    python\_module\_name="train",

    container\_uri="gcr.io/cloud-aiplatform/training/tf-cpu.2-3:latest",

)



\# Ejecutar el entrenamiento

job.run(

    replica\_count=1,

    model\_display\_name="my\_trained\_model",

    args=\["--param1", "value1", "--param2", "value2"],

    base\_output\_dir="gs://\[BUCKET\_NAME]/models/"

)

### 4. **Almacenamiento y Carga de Modelos en Google Cloud**

Una vez que el modelo esté entrenado, guárdalo en un bucket de GCS para poder cargarlo y hacer inferencias.

#### a. **Guardar el Modelo en Cloud Storage**

Si estás usando joblib o pickle para serializar el modelo, puedes guardarlo directamente en un bucket de GCS.

import joblib

from google.cloud import storage



def save\_model\_to\_gcs(model, bucket\_name, model\_path):

    \# Guardar el modelo en un archivo temporal

    joblib.dump(model, "model.joblib")

    

    \# Subir a GCS

    client = storage.Client()

    bucket = client.bucket(bucket\_name)

    blob = bucket.blob(model\_path)

    blob.upload\_from\_filename("model.joblib")

    print("Modelo guardado en GCS")



\# Ejemplo de uso

save\_model\_to\_gcs(model, bucket\_name="my-bucket", model\_path="models/model.joblib")

#### b. **Cargar el Modelo desde Cloud Storage**

Para cargar el modelo guardado en GCS:

def load\_model\_from\_gcs(bucket\_name, model\_path):

    client = storage.Client()

    bucket = client.bucket(bucket\_name)

    blob = bucket.blob(model\_path)

    blob.download\_to\_filename("model.joblib")

    model = joblib.load("model.joblib")

    return model



\# Ejemplo de uso

model = load\_model\_from\_gcs("my-bucket", "models/model.joblib")

### 5. **Implementación y Predicción en Tiempo Real con Vertex AI**

Puedes desplegar el modelo en un endpoint de **Vertex AI** para realizar predicciones en tiempo real.

1. En la consola de Google Cloud, dirígete a **Vertex AI > Modelos**.

2. Selecciona **Implementar en un endpoint** para crear un nuevo endpoint o seleccionar uno existente.

3. Configura el endpoint, el tamaño de la máquina y la cantidad de réplicas.

También puedes hacer esto desde Python:

\# Configuración de Vertex AI para el proyecto

aiplatform.init(project="my-project", location="us-central1")



\# Desplegar el modelo en un endpoint

endpoint = aiplatform.Endpoint.create(display\_name="my\_model\_endpoint")

endpoint.deploy(

    model=model,

    deployed\_model\_display\_name="my\_deployed\_model",

    machine\_type="n1-standard-4",

)

### 6. **Hacer Inferencias con el Endpoint de Vertex AI**

Después de desplegar el modelo, puedes hacer predicciones en tiempo real:

\# Datos de ejemplo para la predicción

instance = {"data": \[1, 2, 3, 4]}  # Cambia los valores según tu modelo



\# Realizar la predicción

prediction = endpoint.predict(instances=\[instance])

print("Predicción:", prediction)

### Resumen

1. **Carga de Datos y Preprocesamiento**: Usa Google Cloud Storage para almacenar y cargar datos, y preprocesa el dataset antes de entrenar.

2. **Entrenamiento en Vertex AI**: Configura Vertex AI para entrenar el modelo usando scripts personalizados o contenedores.

3. **Almacenamiento y Carga de Modelos**: Guarda el modelo entrenado en GCS y cárgalo cuando sea necesario.

4. **Despliegue en Vertex AI**: Implementa el modelo en un endpoint para servir predicciones en tiempo real.

Este flujo básico proporciona un entorno robusto para desarrollar y desplegar modelos en Google Cloud.