Crea un estilista de IA con IBM Granite utilizando watsonx.ai

En este tutorial, se le guiará a través de cómo crear un estilista personal impulsado por IA generativa. Este tutorial aprovecha el modelo de lenguaje de gran tamaño (LLM) IBM Granite Vision 3.2 para procesar la entrada y Granite 3.2 con las últimas capacidades de razonamiento mejoradas para formular ideas de atuendos personalizables.

Introducción

¿Cuántas veces se ha preguntado: "¿Qué me pongo hoy? ¡No sé ni por dónde empezar a elegir la ropa de mi armario!"? Este dilema es uno que muchos de nosotros compartimos. Al utilizar modelos de inteligencia artificial (IA) de vanguardia, esto ya no tiene por qué ser una tarea abrumadora.

Estilo de IA: cómo funciona

Nuestra solución impulsada por IA se compone de las siguientes etapas:

  1. El usuario puede subir imágenes de su armario actual o de los artículos de su lista de deseos, uno por uno.
  2. El usuario selecciona los siguientes criterios:   
  • Ocasión: informal o formal.
  • Hora del día: mañana, tarde o noche.
  • Estación del año: invierno, primavera, verano u otoño.
  • Ubicación (por ejemplo, una cafetería).

3. Tras la entrada del modelo Granite Vision 3.2, itera sobre la lista de imágenes y devuelve el siguiente output:

  • Descripción del artículo.
  • Categoría: camisa, pantalón o zapatos.
  • Ocasión: informal o formal.

4. El modelo Granite 3.2 con razonamiento mejorado sirve como estilista de moda. El LLM utiliza el output del modelo Vision para ofrecer una recomendación de atuendo adecuada para el evento del usuario.

5. Se devuelven al usuario la sugerencia de atuendo, un marco de datos de artículos que el usuario ha subido y las imágenes de la recomendación personalizada descrita.

Requisitos previos

Necesita una cuenta de IBM Cloud para crear un proyecto watsonx.ai.

Pasos

Para utilizar la interfaz de programación de aplicaciones (API) de watsonx, deberá completar los siguientes pasos.  Tenga en cuenta que también puede acceder a este tutorial en GitHub

Paso 1. Configure su entorno

  1. Inicie sesión en watsonx.ai utilizando su cuenta de IBM Cloud.

  2. Cree un proyecto watsonx.ai.

    Puede obtener el ID de su proyecto desde su proyecto. Haga clic en la pestaña Administrar. A continuación, copie el ID del proyecto de la sección Detalles de la página General. Necesita este ID para este tutorial.

Paso 2. Configure el servicio de tiempo de ejecución y la clave API de watsonx.ai

  1. Cree una instancia de servicio watsonx.ai Runtime (elija el plan Lite, que es una instancia gratuita).

  2. Genere una clave API.

  3. Asocie la instancia del servicio watsonx.ai Runtime al proyecto que ha creado en watsonx.ai.

Paso 3. Clone el repositorio (opcional)

Para una experiencia más interactiva al utilizar esta herramienta de IA, clone el repositorio de GitHuby siga las instrucciones de configuración en el archivo README.md dentro del proyecto de estilo de IA para iniciar la aplicación Streamlit en su máquina local. De lo contrario, si prefiere seguir paso a paso, cree un Jupyter Notebook y continúe con este tutorial.

Paso 4. Instale e importe las bibliotecas relevantes y configure sus credenciales

Necesitamos unas pocas bibliotecas y módulos para este tutorial. Asegúrese de importar los siguientes y, si no están instalados, puede resolverlo con una instalación rápida de pip.

# Install required packages
!pip install -q image ibm-watsonx-ai
# Required imports
import getpass, os, base64, json
from ibm_watsonx_ai import Credentials
from ibm_watsonx_ai.foundation_models import ModelInference
from PIL import Image

Para establecer nuestras credenciales, necesitamos la WATSONX_APIKEY  y WATSONX_PROJECT_ID  que generó en el paso 1. También configuraremos elURL que actúa como endpoint de la API.

WATSONX_APIKEY = getpass.getpass("Please enter your watsonx.ai Runtime API key (hit enter): ")
WATSONX_PROJECT_ID = getpass.getpass("Please enter your project ID (hit enter): ")
URL = "https://us-south.ml.cloud.ibm.com"

Podemos usar la clase Credentials  para encapsular nuestras credenciales pasadas.

credentials = Credentials(
    url=URL,
    api_key=WATSONX_APIKEY
)

Paso 5. Configure la solicitud de API para el modelo Granite Vision

Se llama al augment_api_request_body  toma la consulta del usuario y la imagen como parámetros y aumenta el cuerpo de la solicitud de la API. Utilizaremos esta función en cada iteración de inferencia del modelo Vision.

def augment_api_request_body(user_query, image):
    messages = [
        {
            "role": "user",
            "content": [{
                "type": "text",
                "text": user_query
            },
            {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{image}"
                }
            }]
        }
    ]
return messages

También podemos instanciar la interfaz del modelo utilizando la clase ModelInference .

model = ModelInference(
    model_id="ibm/granite-vision-3-2-2b",
    credentials=credentials,
    project_id=WATSONX_PROJECT_ID,
    params={
        "max_tokens": 400,
        "temperature": 0
    }
)

Paso 6. Codifique imágenes

Para codificar nuestras imágenes de forma que sean digeribles para el LLM, las codificaremos en bytes que, a continuación, descodificaremos en representación UTF-8. En este caso, nuestras imágenes están en el directorio de imágenes local. Encontrará imágenes de muestra en el directorio IA stylist de nuestro repositorio GitHub.

directory = "images" #directory name
images = []
filenames = []
for filename in os.listdir(directory):
    if filename.endswith(".jpeg") or filename.endswith(".png"):
        filepath = directory + '/' + filename
        with open(filepath, "rb") as f:
            images.append(base64.b64encode(f.read()).decode('utf-8'))
        filenames.append(filename)

Paso 7. Categorice la entrada con el modelo Vision

Ahora que hemos cargado y codificado nuestras imágenes, podemos consultar el modelo Vision. Nuestra instrucción es específica del output deseado para limitar la creatividad del modelo, ya que buscamos un output JSON válido. Almacenaremos la descripción, categoría y ocasión de cada imagen en una lista llamada closet .

user_query = """Provide a description, category, and occasion for the clothing item or shoes in this image.
                Classify the category as shirt, pants, or shoes.
                Classify the occasion as casual or formal.
                Ensure the output is valid JSON. Do not create new categories or occasions. Only use the allowed classifications.
                Your response should be in this schema:
                {
                    "description": "<description>",
                    "category": "<category>",
                    "occasion": "<occasion>"
                }
                """

image_descriptions = []
for i in range(len(images)):
    image = images[i]
    message = augment_api_request_body(user_query, image)
    response = model.chat(messages=message)
    result = response['choices'][0]['message']['content']
    print(result)
    image_descriptions.append(result)

Resultado:

{
    "description": "A pair of polished brown leather dress shoes with a brogue detailing on the toe box and a classic oxford design.",
    "category": "shoes",
    "occasion": "formal"
}
{
    "description": "A pair of checkered trousers with a houndstooth pattern, featuring a zippered pocket and a button closure at the waist.",
    "category": "pants",
"occasion": "casual"
}
{
    "description": "A light blue, button-up shirt with a smooth texture and a classic collar, suitable for casual to semi-formal occasions.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of khaki pants with a buttoned waistband and a button closure at the front.",
    "category": "pants",
    "occasion": "casual"
}
{
    "description": "A blue plaid shirt with a collar and long sleeves, featuring chest pockets and a button-up front.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of bright orange, short-sleeved t-shirts with a crew neck and a simple design.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of blue suede sneakers with white laces and perforations, suitable for casual wear.",
    "category": "shoes",
    "occasion": "casual"
}

{
    "description": "A pair of red canvas sneakers with white laces, isolated on a white background.",
    "category": "shoes",
    "occasion": "casual"
}
{
    "description": "A pair of grey dress pants with a smooth texture and a classic design, suitable for formal occasions.",
    "category": "pants",
    "occasion": "formal"
}
{
    "description": "A plain white T-shirt with short sleeves and a crew neck, displayed from the front and back.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A black short-sleeved t-shirt with a crew neck and a simple design.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "Black pants with a zippered pocket and a buttoned fly, showing the waistband and pocket details.",
    "category": "pants",
    "occasion": "casual"
}
{
    "description": "A pair of tan leather boots with a chunky sole and a high-top design, suitable for casual wear.",
    "category": "shoes",
    "occasion": "casual"
}

Paso 8. Genere conjuntos con el modelo de razonamiento

Ahora que tenemos cada prenda y calzado categorizados, será mucho más fácil para el modelo de razonamiento generar un atuendo para la ocasión seleccionada. Instanciemos y consultemos el modelo de razonamiento.

reasoning_model = ModelInference(
    model_id="ibm/granite-3-2-8b-instruct",
    credentials=credentials,
    project_id=WATSONX_PROJECT_ID
)

Para alinear los nombres de archivo con las descripciones de las imágenes, podemos enumerar la lista de descripciones de imágenes y crear una lista de diccionarios en los que almacenamos la descripción, la categoría, la ocasión y el nombre de archivo de cada elemento en los campos correspondientes.

# Add filenames to the image descriptions
closet = []
for i, desc in enumerate(image_descriptions):
    desc_dict = json.loads(desc)
    desc_dict['filename'] = filenames[i]
    image_descriptions[i] = json.dumps(desc_dict)

closet = [json.loads(js) for js in image_descriptions]

Ahora, consultemos el modelo Granite 3.2 con razonamiento para producir un conjunto para nuestros criterios especificados utilizando la lista closet .

occasion = input("Enter the occasion") #casual or formal (e.g. "casual")
time_of_day = input("Enter the time of day") #morning, afternoon or evening (e.g. "morning")
location = input("Enter the location") #any location (e.g. "park")
season = input("Enter the season") #spring, summer, fall or winter (e.g. "fall")

prompt = f"""Use the description, category, and occasion of the clothes in my closet to put together an outfit for a {occasion} {time_of_day} at the {location}. The event takes place in the {season} season. Make sure to return only one shirt, bottoms, and shoes. Use the description, category, and occasion provided. Do not classify the items yourself. Include the file name of each image in your output along with the file extension. Here are the items in my closet: {closet}"""

messages = [
        {"role": "control",
        "content": "thinking"},
        {"role": "user",
        "content": [
                {"type": "text",
                 "text": f"{prompt}"}
            ]}
        ]
outfit = reasoning_model.chat(messages=messages)['choices'][0]['message']['content']
print(outfit)

Resultado

Este es mi proceso de pensamiento:
- El atuendo debe ser adecuado para una mañana informal en el parque durante el otoño.
- Seleccionaré una camisa, un par de pantalones y un par de zapatos que se ajusten a la categoría de ocasión "casual".
- Evitaré prendas formales o demasiado elegantes y elegiré prendas que sean cómodas para las actividades en el parque.

Esta es mi respuesta:

para una mañana informal en el parque en otoño, sugiero el siguiente atuendo:

1. **Camisa**: una camisa azul a cuadros con cuello y mangas largas (archivo: 'image13.jpeg')
- El estampado a cuadros es clásico para el otoño y combina bien con los ambientes informales de los parques. Las mangas largas ofrecen cierta protección contra las temperaturas más frías de la mañana.

2. **Pantalones**: pantalones caqui con cinturilla abotonada y cierre de botones en la parte delantera (archivo: 'image7.jpeg')
- El caqui es una opción versátil que puede combinar con el ambiente informal y también proporciona un buen equilibrio con el camisa a cuadros. Es práctico y cómodo para caminar.

3. **Zapatos**: un par de botas de cuero tostado con suela gruesa y diseño de caña alta (archivo: 'image3.jpeg')
- Las botas de cuero tostado ofrecen una opción elegante pero cómoda. La suela gruesa proporciona un buen agarre y soporte, ideal para navegar por senderos de parques o terrenos irregulares.

Esta combinación proporciona un look relajado y elegante, adecuado para una salida informal por la mañana, al tiempo que tiene en cuenta la comodidad y la practicidad.

¡Con esta descripción de atuendo generada, también podemos mostrar las prendas de vestir que recomienda el modelo! Para hacerlo, simplemente podemos extraer los nombres de archivo. En caso de que el modelo mencione el mismo nombre de archivo dos veces, es importante comprobar si la imagen no se ha mostrado ya mientras iteramos la lista de imágenes. Podemos hacerlo almacenando las imágenes mostradas en la lista selected_items . Finalmente, podemos mostrar los elementos seleccionados.

selected_items = []
#extract the images of clothing that the model recommends
for item, uploaded_file in zip(closet, images):
    if item['filename'].lower() in outfit.lower() and not any(key['filename'] == item['filename'] for key in selected_items):
        selected_items.append({
            'image': uploaded_file,
            'category': item['category'],
            'filename': item['filename']
        })

#display the selected clothing items
if len(selected_items) > 0:
    for item in selected_items:
        display(Image.open(directory + '/' + item['filename']))

Conclusión

En este tutorial, ha creado un sistema que utiliza la IA para dar consejos de estilo a un usuario para un evento concreto. Utilizando fotos o capturas de pantalla de la ropa del usuario, los conjuntos se personalizan para cumplir con los criterios especificados. El modelo Granite-Vision-3-2-2b era crítico para etiquetar y clasificar cada artículo. Además, el modelo Granite-3-2-8B-instruct aprovechó sus capacidades de razonamiento para generar ideas de atuendos personalizados.

Algunos de los próximos pasos para crear esta aplicación pueden incluir:

  • Personalización de atuendos según el estilo personal del usuario, el tipo de cuerpo, la paleta de colores preferida y más.
  • Ampliación de los criterios para incluir chaquetas y accesorios. Por ejemplo, el sistema podría proponer una chaqueta para un usuario que asista a una conferencia formal, además de la camisa, los pantalones y los zapatos seleccionados.
  • Actuar como personal shopper proporcionando recomendaciones de productos de comercio electrónico y precios que se alineen con el estilo y presupuesto únicos del usuario.
  • Añadir la función de chatbot para hacer preguntas al LLM sobre cada atuendo.
  • Proporcionar una experiencia de prueba virtual que utilice una selfie del usuario para simular el aspecto final.
Soluciones relacionadas
IBM watsonx.ai

Entrene, valide, ajuste e implemente IA generativa, modelos fundacionales y capacidades de machine learning con IBM watsonx.ai, un estudio empresarial de nueva generación para desarrolladores de IA. Cree aplicaciones de IA en menos tiempo y con menos datos.

Descubra watsonx.ai
Soluciones de inteligencia artificial

Ponga la IA a trabajar en su negocio con la experiencia líder en IA del sector de IBM y junto a su cartera de soluciones.

Explore las soluciones de IA
Consultoría y servicios de IA

Reinvente las operaciones y flujos de trabajo críticos añadiendo IA para maximizar las experiencias, la toma de decisiones en tiempo real y el valor empresarial.

Explore los servicios de IA
Dé el siguiente paso

Obtenga acceso único a capacidades que abarcan el ciclo de vida de desarrollo de la IA. Produzca potentes soluciones de IA con interfaces intuitivas, flujos de trabajo y acceso a API y SDK estándar del sector.

Explore watsonx.ai Solicite una demostración en directo