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.
### 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\_testX\_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.
#### 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.
