Image for post Google Vertex AI Python SDK: Tu Primera Aplicación de IA en la Nube con Modelos Fundacionales

Google Vertex AI Python SDK: Tu Primera Aplicación de IA en la Nube con Modelos Fundacionales

Escrito por Sergio Márquez

El mundo de la Inteligencia Artificial evoluciona rápidamente, y con él, la necesidad de los desarrolladores de explorar diversas plataformas en la nube. Si bien OpenAI ha sido un punto de partida popular, Google Cloud ofrece una suite robusta de herramientas de IA a través de Vertex AI, con sus propios y potentes modelos fundacionales. Este artículo te guiará paso a paso para construir tu primera aplicación de IA utilizando el SDK de Python de Vertex AI, aprovechando modelos como Gemini para generación de texto y embeddings.

Contexto del Problema: Más Allá de un Solo Proveedor

Muchos desarrolladores comienzan su viaje en la IA con APIs como la de OpenAI debido a su facilidad de uso. Sin embargo, en entornos de producción o proyectos más complejos, surge la necesidad de diversificar, buscar redundancia, aprovechar características específicas de la nube o cumplir con requisitos empresariales. Google Cloud Vertex AI se posiciona como una plataforma integral que permite entrenar, desplegar y gestionar modelos de Machine Learning a escala. Aprender a interactuar con sus modelos fundacionales a través del SDK de Python te abrirá un abanico de posibilidades para construir aplicaciones de IA robustas y escalables en el ecosistema de Google Cloud.

Conceptos Clave de Vertex AI

  • Vertex AI: Es la plataforma unificada de Machine Learning de Google Cloud. Ofrece un conjunto completo de herramientas y servicios para todo el ciclo de vida del ML, desde la preparación de datos hasta el despliegue y monitoreo de modelos. [16]
  • Modelos Fundacionales (Foundational Models): Son modelos pre-entrenados a gran escala (LLMs para texto, modelos multimodales, de embeddings, etc.) que Google pone a disposición a través de Vertex AI. Ejemplos incluyen Gemini y los modelos de embeddings. [20, 23]
  • Vertex AI SDK para Python (google-cloud-aiplatform): Una biblioteca de Python de alto nivel que simplifica la interacción programática con los servicios de Vertex AI. Permite automatizar la ingesta de datos, entrenar modelos y obtener predicciones. [18]
  • Autenticación y Autorización: Para interactuar con Vertex AI, tu aplicación necesita credenciales. Google Cloud utiliza Application Default Credentials (ADC), que pueden configurarse a través de la CLI de gcloud o mediante archivos de clave de cuenta de servicio. [1, 7, 12]
  • Generación de Texto (Gemini): La capacidad de los modelos de lenguaje grandes (LLMs) como Gemini para producir texto coherente y relevante a partir de un prompt. [3, 20]
  • Embeddings: Representaciones numéricas (vectores) de texto que capturan su significado semántico. Son fundamentales para tareas como la búsqueda semántica, la clasificación y los sistemas de Recuperación Aumentada por Generación (RAG). [2, 4, 8]

Implementación Paso a Paso con el SDK de Python

Paso 1: Configuración del Entorno y Autenticación

Antes de escribir código, necesitas configurar tu entorno de Google Cloud y autenticarte. Asegúrate de tener un proyecto de Google Cloud y la API de Vertex AI habilitada para ese proyecto. [9, 19]

1.1. Instalar el SDK de Vertex AI

El primer paso es instalar la biblioteca google-cloud-aiplatform:

pip install google-cloud-aiplatform

1.2. Autenticación

Para el desarrollo local, la forma más sencilla de autenticarse es usando las Application Default Credentials (ADC) a través de la CLI de Google Cloud (gcloud). [2, 7, 12]

gcloud auth application-default login

Esto abrirá una ventana del navegador para que inicies sesión con tu cuenta de Google. Una vez autenticado, tus aplicaciones Python podrán usar estas credenciales automáticamente. Para entornos de producción, se recomienda usar cuentas de servicio con roles específicos (por ejemplo, Vertex AI User) y sus archivos de clave JSON. [1, 9]

1.3. Inicializar Vertex AI

En tu código Python, inicializa el SDK con tu ID de proyecto y la región donde operarás. Es una buena práctica usar variables de entorno para estos valores.

import os
import vertexai

# Configura tus variables de entorno o reemplaza directamente
PROJECT_ID = os.getenv("GCP_PROJECT_ID", "tu-project-id") # Reemplaza con tu ID de proyecto
LOCATION = os.getenv("GCP_LOCATION", "us-central1") # Reemplaza con tu región (ej. us-central1)

vertexai.init(project=PROJECT_ID, location=LOCATION)

print(f"Vertex AI inicializado para el proyecto: {PROJECT_ID} en la región: {LOCATION}")

Paso 2: Generación de Texto con el Modelo Gemini

Ahora que Vertex AI está inicializado, puedes cargar y usar modelos fundacionales. Usaremos el modelo Gemini para generar texto. [3, 9]

from vertexai.preview.generative_models import GenerativeModel, Part, FinishReason

# Cargar el modelo Gemini (ej. gemini-pro)
# Puedes explorar otros modelos como 'gemini-pro-vision' para multimodalidad
model = GenerativeModel("gemini-pro")

# Definir un prompt
prompt = "Escribe un eslogan creativo para una startup de IA que ayuda a pequeñas empresas a automatizar tareas."

# Generar contenido
response = model.generate_content(prompt)

# Imprimir la respuesta
print("\n--- Generación de Texto con Gemini ---")
if response.candidates:
    for candidate in response.candidates:
        print(candidate.text)
else:
    print("No se pudo generar texto o se recibió una respuesta vacía.")

Parámetros de Generación

Puedes controlar la salida del modelo ajustando parámetros como temperature (aleatoriedad), top_k (muestreo de los k tokens más probables) y top_p (muestreo acumulativo de probabilidad). [5, 22]

# Generar contenido con parámetros
response_params = model.generate_content(
    prompt,
    generation_config={
        "temperature": 0.9,  # Mayor temperatura = más creatividad
        "top_p": 0.9,        # Muestreo de tokens con probabilidad acumulada del 90%
        "top_k": 40,         # Muestreo de los 40 tokens más probables
        "max_output_tokens": 100 # Límite de tokens en la respuesta
    }
)

print("\n--- Generación de Texto con Parámetros ---")
if response_params.candidates:
    for candidate in response_params.candidates:
        print(candidate.text)
else:
    print("No se pudo generar texto con parámetros.")

Paso 3: Generación de Embeddings de Texto

Los embeddings son vectores numéricos que representan el significado semántico del texto. Son cruciales para la búsqueda de similitud, RAG y otras aplicaciones de IA. Vertex AI ofrece modelos de embeddings como textembedding-gecko o gemini-embedding-001. [2, 4, 8]

from vertexai.language_models import TextEmbeddingModel

# Cargar el modelo de embeddings
# 'textembedding-gecko@003' es una versión común, o 'gemini-embedding-001'
embedding_model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")

# Textos para generar embeddings
texts_to_embed = [
    "La inteligencia artificial está transformando la industria.",
    "El aprendizaje automático es una rama de la IA.",
    "Un nuevo restaurante abrió en el centro de la ciudad."
]

# Generar embeddings
embeddings = embedding_model.get_embeddings(texts_to_embed)

print("\n--- Generación de Embeddings ---")
for i, embedding in enumerate(embeddings):
    print(f"Texto: '{texts_to_embed[i]}'\nEmbedding (primeros 5 dims): {embedding.values[:5]}...")
    print(f"Dimensiones del embedding: {len(embedding.values)}\n")

Mini Proyecto: Generador de Ideas para Blog Posts con Embeddings

Crearemos una pequeña aplicación que genera ideas para artículos de blog usando Gemini y luego calcula los embeddings de esas ideas para una posible búsqueda o categorización futura.

import os
import vertexai
from vertexai.preview.generative_models import GenerativeModel
from vertexai.language_models import TextEmbeddingModel

# --- Configuración inicial (asegúrate de que PROJECT_ID y LOCATION estén definidos) ---
PROJECT_ID = os.getenv("GCP_PROJECT_ID", "tu-project-id") # Reemplaza con tu ID de proyecto
LOCATION = os.getenv("GCP_LOCATION", "us-central1") # Reemplaza con tu región

vertexai.init(project=PROJECT_ID, location=LOCATION)

# --- Cargar modelos ---
generative_model = GenerativeModel("gemini-pro")
embedding_model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")

def generar_ideas_y_embeddings(tema: str, num_ideas: int = 3):
    """
    Genera ideas para artículos de blog sobre un tema dado y sus embeddings.
    """
    print(f"Generando {num_ideas} ideas para el tema: '{tema}'...")
    prompt = f"Genera {num_ideas} títulos de artículos de blog creativos y atractivos sobre '{tema}'. Lista cada título en una nueva línea con un guion."
    
    response = generative_model.generate_content(prompt, generation_config={"max_output_tokens": 200})
    
    ideas_generadas = []
    if response.candidates:
        for candidate in response.candidates:
            # Dividir la respuesta en líneas y limpiar
            raw_ideas = candidate.text.strip().split('\n')
            for idea in raw_ideas:
                cleaned_idea = idea.strip().lstrip('- ').strip()
                if cleaned_idea:
                    ideas_generadas.append(cleaned_idea)
    
    if not ideas_generadas:
        print("No se pudieron generar ideas.")
        return [], []

    print("Ideas generadas:")
    for idea in ideas_generadas:
        print(f"- {idea}")

    print("\nGenerando embeddings para las ideas...")
    embeddings_result = embedding_model.get_embeddings(ideas_generadas)
    
    ideas_con_embeddings = []
    for i, idea in enumerate(ideas_generadas):
        ideas_con_embeddings.append({"idea": idea, "embedding": embeddings_result[i].values})
        
    print("Embeddings generados exitosamente.")
    return ideas_generadas, ideas_con_embeddings

if __name__ == "__main__":
    tema_ejemplo = "el futuro de la IA en la medicina"
    num_ideas_ejemplo = 5
    
    titulos, resultados = generar_ideas_y_embeddings(tema_ejemplo, num_ideas_ejemplo)
    
    if resultados:
        print("\n--- Resumen de Ideas y Embeddings ---")
        for item in resultados:
            print(f"Idea: {item['idea']}")
            print(f"Embedding (primeros 5 dims): {item['embedding'][:5]}...")
            print(f"Dimensiones: {len(item['embedding'])}\n")

    # Ejemplo de cómo podrías usar los embeddings para una búsqueda de similitud (conceptual)
    # Esto requeriría una base de datos vectorial real para ser funcional a gran escala
    query_text = "Aplicaciones de IA para el diagnóstico médico"
    query_embedding = embedding_model.get_embeddings([query_text])[0].values
    print(f"Query: '{query_text}'\nQuery Embedding (primeros 5 dims): {query_embedding[:5]}...")

    # En un escenario real, compararías query_embedding con los embeddings almacenados
    # en una base de datos vectorial (ej. Pinecone, Chroma, Qdrant o Vertex AI Vector Search).
    print("\nPara una búsqueda de similitud real, integrarías esto con una base de datos vectorial.")

Errores Comunes y Depuración

  • google.auth.exceptions.DefaultCredentialsError o 401 Unauthorized: Indica que tus credenciales no están configuradas correctamente. Asegúrate de haber ejecutado gcloud auth application-default login o de que tu variable de entorno GOOGLE_APPLICATION_CREDENTIALS apunte a un archivo de clave de cuenta de servicio válido. [1, 9]
  • 403 Permission denied: Tu cuenta o cuenta de servicio no tiene los permisos necesarios (rol Vertex AI User o similar) para acceder a los recursos de Vertex AI. Verifica los permisos en la consola de Google Cloud. [9]
  • 429 Resource exhausted: Has excedido las cuotas de la API para tu proyecto. Puedes solicitar un aumento de cuota en la consola de Google Cloud o implementar estrategias de reintento con retroceso exponencial.
  • Configuración incorrecta de PROJECT_ID o LOCATION: Asegúrate de que el ID del proyecto y la región en vertexai.init() coincidan con tu configuración de Google Cloud.
  • Modelo no encontrado: Verifica que el nombre del modelo (ej. gemini-pro, textembedding-gecko@003) sea correcto y esté disponible en tu región.

Aprendizaje Futuro

Este artículo es solo el comienzo de lo que puedes lograr con Google Vertex AI. Te animamos a explorar:

  • Otros Modelos Fundacionales: Experimenta con gemini-pro-vision para entradas multimodales (texto e imágenes), o los modelos Codey para generación y finalización de código. [20, 24]
  • Vertex AI Vector Search: Para aplicaciones de búsqueda semántica y RAG a gran escala, integra tus embeddings con el servicio de búsqueda vectorial gestionado de Vertex AI. [4, 21]
  • Ajuste Fino (Fine-tuning) de Modelos: Personaliza modelos fundacionales con tus propios datos para tareas específicas, mejorando su rendimiento y relevancia. [10, 23]
  • Vertex AI Workbench: Un entorno de desarrollo basado en Jupyter para experimentar y desarrollar modelos de IA directamente en la nube. [21]
  • MLOps en Vertex AI: Aprende a gestionar el ciclo de vida completo de tus modelos, incluyendo el monitoreo, despliegue y versionado en producción. [13]
  • Optimización de Costos: Familiarízate con los modelos de precios de Vertex AI para modelos generativos (basados en tokens de entrada/salida) y otras herramientas para monitorear y optimizar tus gastos en la nube. [10, 11]

Dominar el SDK de Python de Vertex AI te equipará con las habilidades necesarias para construir y desplegar aplicaciones de IA de vanguardia en uno de los ecosistemas de nube más potentes del mundo.

Volver al blog