Cómo utilizar GPT-4 para generar y analizar imágenes

Name: Lynn Mikami

Published on 30/4/2024

Esta guía paso a paso explora las capacidades innovadoras de GPT-4V, incluyendo la generación y análisis de imágenes, ofreciendo consejos prácticos sobre cómo aprovechar este modelo de IA avanzado tanto para la creación de contenido textual como visual.

La llegada de GPT-4 ha marcado una evolución significativa en el campo de la inteligencia artificial, ampliando sus capacidades más allá del texto para incluir la generación y análisis de imágenes. Este artículo explora las funcionalidades multifacéticas de GPT-4, centrándose en su capacidad para procesar y generar imágenes, y proporciona una guía completa sobre cómo aprovechar estas características de manera efectiva.

¿Qué es GPT-4?

GPT-4, o Generative Pre-trained Transformer 4, es una iteración avanzada de los modelos de IA desarrollados por OpenAI. Destaca por su mayor comprensión y generación de texto similar al humano, pero lo que distingue a GPT-4 es su capacidad para interactuar con imágenes. Esto incluye la generación de imágenes a partir de descripciones (GPT-4 Vision o GPT-4V), el análisis de contenido dentro de imágenes e incluso la lectura de texto capturado en imágenes, lo que lo convierte en una herramienta versátil para diversas aplicaciones.

Comprensión de las capacidades de imágenes de GPT-4

Las capacidades de visión de GPT-4, a menudo conocidas como GPT-4 Vision o GPT-4V, le permiten procesar y generar imágenes basadas en descripciones textuales. Esto significa que puedes cargar una imagen para su análisis o pedirle al modelo que cree nuevas imágenes desde cero. Ya sea para crear obras de arte, generar imágenes visuales para contenido o extraer información de imágenes, GPT-4V está equipado para manejar una variedad de tareas, lo que lo convierte en una poderosa adición a la suite de GPT-4.

Cómo generar imágenes con GPT-4

Generar imágenes con GPT-4 es sencillo. Los usuarios pueden ingresar una descripción detallada de la imagen que imaginan y el modelo generará una imagen correspondiente. Esta función es particularmente útil para artistas, diseñadores y creadores de contenido que deseen dar vida a sus ideas sin necesidad de habilidades de dibujo o diseño manual. También es invaluable para crear imágenes que complementen contenido basado en texto, mejorando la experiencia del usuario en general.

Cómo utilizar GPT-4 para el análisis de imágenes

Además de generar imágenes, GPT-4 puede analizar e interpretar el contenido dentro de las fotos. Esto incluye leer texto en imágenes, reconocer objetos y comprender escenas. Para utilizar esta función, los usuarios pueden cargar una imagen en la plataforma y GPT-4 proporcionará información basada en su análisis. Esta capacidad es especialmente útil para tareas que implican investigación basada en imágenes, extracción de datos y mejoras de accesibilidad, como la lectura de texto para usuarios con discapacidad visual.

Aplicaciones prácticas de GPT-4 Vision

Las aplicaciones potenciales de las capacidades de imágenes de GPT-4 son amplias. En el sector educativo, puede facilitar el aprendizaje interactivo mediante la generación de ayudas visuales o el análisis de fotografías históricas. Los especialistas en marketing pueden utilizar GPT-4 para crear imágenes convincentes para campañas o analizar fotografías de consumidores en busca de información. Además, en la industria creativa, GPT-4 puede ayudar en el proceso de diseño mediante la generación de conceptos iniciales o la modificación de imágenes existentes según los comentarios.

Cómo combinar GPT-4V con RAG - Crear una aplicación de emparejamiento de prendas

¡Bienvenido a la libreta Jupyter de la aplicación de emparejamiento de prendas! Este proyecto demuestra el poder del modelo GPT-4V en el análisis de imágenes de prendas y la extracción de características clave como el color, el estilo y el tipo. El corazón de nuestra aplicación se basa en este modelo avanzado de análisis de imágenes desarrollado por OpenAI, que nos permite identificar con precisión las características de la prenda de entrada.

GPT-4V es un modelo que combina el procesamiento del lenguaje natural con el reconocimiento de imágenes, lo que le permite comprender y generar respuestas basadas tanto en texto como en entradas visuales.

Aprovechando las capacidades del modelo GPT-4V, utilizamos un algoritmo de coincidencia personalizado y la técnica RAG para buscar en nuestra base de conocimientos prendas que complementen las características identificadas. Este algoritmo tiene en cuenta factores como la compatibilidad de colores y la coherencia de estilos para proporcionar recomendaciones adecuadas a los usuarios. A través de esta libreta, nuestro objetivo es mostrar la aplicación práctica de estas tecnologías en la creación de un sistema de recomendación de prendas.

El uso de la combinación de GPT-4 Vision + RAG (Recuperación-Generación Aumentada) ofrece varias ventajas:

Comprensión contextual: GPT-4 Vision puede analizar imágenes de entrada y comprender el contexto, como los objetos, escenas y actividades representadas. Esto permite sugerencias o información más precisas y relevantes en diversos dominios, ya sea diseño de interiores, cocina o educación.
Base de conocimientos rica: RAG combina las capacidades generativas de GPT-4 con un componente de recuperación que accede a un corpus de información extenso en diferentes campos. Esto significa que el sistema puede proporcionar sugerencias o conocimientos basados en una amplia gama de conocimientos, desde hechos históricos hasta conceptos científicos.
Personalización: El enfoque permite una fácil personalización para adaptarse a las necesidades o preferencias específicas del usuario en diversas aplicaciones. Ya sea adaptando las sugerencias al gusto de un usuario en arte o proporcionando contenido educativo basado en el nivel de aprendizaje de un estudiante, el sistema se puede adaptar para brindar experiencias personalizadas.

En general, el enfoque de GPT-4 Vision + RAG ofrece una solución potente y flexible para diversas aplicaciones relacionadas con la moda, aprovechando las fortalezas de las técnicas de IA generativa y basada en recuperación.

Configuración del entorno

Primero, instalaremos las dependencias necesarias, luego importaremos las bibliotecas y escribiremos algunas funciones de utilidad que usaremos más adelante.

Creando los Embeddings

Ahora vamos a configurar la base de conocimientos eligiendo una base de datos y generando los embeddings para ella. Estoy usando el archivo sample_styles.csv en la carpeta de datos para esto. Esta es una muestra de un conjunto de datos más grande que contiene ~44K elementos. Este paso también se puede reemplazar utilizando una base de datos de vectores lista para usar. Por ejemplo, puedes seguir uno de estos libros de cocina (opens in a new tab) para configurar tu base de datos de vectores.

styles_filepath = "data/sample_clothes/sample_styles.csv"
styles_df = pd.read_csv(styles_filepath, on_bad_lines='skip')
print(styles_df.head())
print("Se abrió el conjunto de datos correctamente. El dataset contiene {} prendas.".format(len(styles_df)))

Ahora vamos a generar los embeddings para todo el conjunto de datos. Podemos paralelizar la ejecución de estos embeddings para asegurarnos de que el script escala para conjuntos de datos más grandes. Con esta lógica, el tiempo para crear los embeddings para el conjunto completo de 44K registros se reduce de ~4h a ~2-3min.

## Lógica para Embeddings por Lotes
 
# Función simple que toma una lista de objetos de texto y los devuelve como una lista de embeddings
@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(10))
def obtener_embeddings(input: List):
    response = client.embeddings.create(
        input=input,
        model=EMBEDDING_MODEL
    ).data
    return [data.embedding for data in response]
 
 
# Divide un iterable en lotes de tamaño n.
def dividir_en_lotes(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx : min(ndx + n, l)]
     
 
# Función para poner por lotes y procesamiento paralelo de los embeddings
def incrustar_corpus(
    corpus: List[str],
    tamaño_lote=64,
    num_trabajadores=8,
    longitud_contexto_max=8191,
):
    # Codificar el corpus, truncando a longitud_contexto_max
    encoding = tiktoken.get_encoding("cl100k_base")
    corpus_codificado = [
        articulo_codificado[:longitud_contexto_max] for articulo_codificado in encoding.encode_batch(corpus)
    ]
 
    # Calcular estadísticas del corpus: el número de entradas, el número total de tokens y el costo estimado para los embeddings
    num_tokens = sum(len(articulo) for articulo in corpus_codificado)
    costo_para_embed_tokens = num_tokens / 1000 * EMBEDDING_COST_PER_1K_TOKENS
    print(
        f"num_articulos={len(corpus_codificado)}, num_tokens={num_tokens}, costo_estimado={costo_para_embed_tokens:.2f} USD"
    )
 
    # Generar los embeddings para el corpus
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_trabajadores) as executor:
        
        futuros = [
            executor.submit(obtener_embeddings, lote_texto)
            for lote_texto in dividir_en_lotes(corpus_codificado, tamaño_lote)
        ]
 
        with tqdm(total=len(corpus_codificado)) as pbar:
            for _ in concurrent.futures.as_completed(futuros):
                pbar.update(tamaño_lote)
 
        embeddings = []
        for futuro in futuros:
            data = futuro.result()
            embeddings.extend(data)
 
        return embeddings
    
# Función para generar los embeddings para una columna dada en un DataFrame
def generar_embeddings(df, nombre_columna):
    # Inicializar una lista vacía para almacenar los embeddings
    descripciones = df[nombre_columna].astype(str).tolist()
    embeddings = incrustar_corpus(descripciones)
 
    # Añadir los embeddings como una nueva columna al DataFrame
    df['embeddings'] = embeddings
    print("Los embeddings se crearon con éxito.")

Dos opciones para crear los embeddings:

La siguiente línea creará los embeddings para el conjunto de datos de prendas de muestra. Esto tomará alrededor de 0.02s para procesar y otros ~30s para escribir los resultados en un archivo .csv local. El proceso utiliza nuestro modelo text_embedding_3_large que tiene un precio de $0.00013/1K tokens. Dado que el conjunto de datos tiene alrededor de 1K registros, la siguiente operación costará aproximadamente $0.001. Si decides trabajar con el conjunto de datos completo de 44K registros, esta operación tomará 2-3min para procesar y costará aproximadamente $0.07.

Si no deseas continuar con la creación de tus propios embeddings, utilizaremos un conjunto de datos de embeddings precalculados. Puedes saltar esta celda y descomentar el código en la siguiente celda para continuar con la carga de los vectores precalculados. Esta operación tarda ~1min en cargar todos los datos en la memoria.

generar_embeddings(styles_df, 'productDisplayName')
print("Escribiendo los embeddings en el archivo ...")
styles_df.to_csv('data/sample_clothes/sample_styles_with_embeddings.csv', index=False)
print("Los embeddings se almacenaron correctamente en sample_styles_with_embeddings.csv")

# styles_df = pd.read_csv('data/sample_clothes/sample_styles_with_embeddings.csv', on_bad_lines='skip')
 
# # Convertir la columna 'embeddings' de representaciones de cadenas de listas a listas reales de números en punto flotante
# styles_df['embeddings'] = styles_df['embeddings'].apply(lambda x: ast.literal_eval(x))
 
print(styles_df.head())
print("Se abrió el conjunto de datos correctamente. El dataset contiene {} prendas junto con sus embeddings.".format(len(styles_df)))

Construyendo el algoritmo de coincidencia

En esta sección, desarrollaremos un algoritmo de recuperación de similitud coseno para encontrar elementos similares en nuestro dataframe. Utilizaremos nuestra función de similitud coseno personalizada para este propósito. Mientras que la biblioteca sklearn ofrece una función de similitud coseno incorporada, las actualizaciones recientes en su SDK han provocado problemas de compatibilidad, lo que nos ha llevado a implementar nuestro propio cálculo estándar de similitud coseno.

Si ya tienes configurada una base de datos de vectores, puedes omitir este paso. La mayoría de las bases de datos estándar vienen con sus propias funciones de búsqueda, que simplifican los pasos subsiguientes descritos en esta guía. Sin embargo, nuestro objetivo es demostrar que el algoritmo de coincidencia se puede adaptar para cumplir con requisitos específicos, como un umbral particular o un número especificado de coincidencias devueltas.

La función find_similar_items acepta cuatro parámetros:

embedding: El embedding para el cual queremos encontrar una coincidencia.
embeddings: Una lista de embeddings para buscar las mejores coincidencias.
threshold (opcional): Este parámetro especifica la puntuación de similitud mínima para que una coincidencia sea considerada válida. Un umbral más alto produce coincidencias más cercanas (mejores), mientras que un umbral más bajo permite que se devuelvan más elementos, aunque no estén tan cercanamente emparejados con el embedding inicial.
top_k (opcional): Este parámetro determina el número de elementos a devolver que superen el umbral dado. Estos serán las mejores coincidencias según la puntuación para el embedding proporcionado.

def cosine_similarity_manual(vec1, vec2):
    """Calcula la similitud coseno entre dos vectores."""
    vec1 = np.array(vec1, dtype=float)
    vec2 = np.array(vec2, dtype=float)
 
 
    dot_product = np.dot(vec1, vec2)
    norm_vec1 = np.linalg.norm(vec1)
    norm_vec2 = np.linalg.norm(vec2)
    return dot_product / (norm_vec1 * norm_vec2)
 
 
def find_similar_items(input_embedding, embeddings, threshold=0.5, top_k=2):
    """Encuentra los elementos más similares basados en la similitud coseno."""
    
    # Calcula la similitud coseno entre el embedding de entrada y todos los otros embeddings
    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
    
    # Filtra cualquier similitud por debajo del umbral
    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
    
    # Ordena las similitudes filtradas por puntuación de similitud
    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
 
    # Devuelve los elementos más similares según el top-k
    return sorted_indices

def find_matching_items_with_rag(df_items, item_descs):
   """Toma las descripciones de los elementos de entrada y encuentra los elementos más similares basados en la similitud coseno para cada descripción."""
   
   # Selecciona los embeddings del DataFrame.
   embeddings = df_items['embeddings'].tolist()
 
   
   similar_items = []
   for desc in item_descs:
      
      # Genera el embedding para el elemento de entrada
      input_embedding = get_embeddings([desc])
    
      # Encuentra los elementos más similares basados en la similitud coseno
      similar_indices = find_similar_items(input_embedding, embeddings, threshold=0.6)
      similar_items += [df_items.iloc[i] for i in similar_indices]
    
   return similar_items

Módulo de Análisis

En este módulo, aprovechamos gpt-4-vision-preview para analizar imágenes de entrada y extraer características importantes como descripciones detalladas, estilos y tipos. El análisis se realiza mediante una llamada sencilla a la API, donde proporcionamos la URL de la imagen para el análisis y solicitamos al modelo que identifique características relevantes.

Para asegurar que el modelo devuelva resultados precisos, utilizamos técnicas específicas en nuestra solicitud:

Especificación del Formato de Salida: Instruimos al modelo que devuelva un bloque JSON con una estructura predefinida, que consiste en:
- items (str[]): Una lista de strings, cada uno representando un título conciso para un artículo de ropa, incluyendo estilo, color y género. Estos títulos se asemejan estrechamente a la propiedad productDisplayName en nuestra base de datos original.
- category (str): La categoría que mejor representa el artículo dado. El modelo selecciona de una lista de todos los articleTypes únicos presentes en el dataframe original de estilos.
- gender (str): Una etiqueta que indica el género para el que está destinado el artículo. El modelo elige entre las opciones [Men, Women, Boys, Girls, Unisex].
Instrucciones Claras y Concisas:
- Proporcionamos instrucciones claras sobre lo que deben incluir los títulos de los elementos y cómo debe ser el formato de salida. La salida debe estar en formato JSON, pero sin la etiqueta json que normalmente contiene la respuesta del modelo.
Ejemplo de One Shot:
- Para aclarar aún más la salida esperada, proporcionamos al modelo una descripción de entrada de ejemplo y una salida de ejemplo correspondiente. Aunque esto puede aumentar el número de tokens utilizados (y, por lo tanto, el costo de la llamada), ayuda a guiar al modelo y mejora su rendimiento general.

Siguiendo este enfoque estructurado, buscamos obtener información precisa y útil del modelo gpt-4-vision-preview para su posterior análisis e integración en nuestra base de datos.

def analyze_image(image_base64, subcategories):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """Dada una imagen de una prenda de vestir, analiza la prenda y genera una salida JSON con los siguientes campos: "items", "category" y "gender". 
                           Utiliza tu comprensión de las tendencias de moda, los estilos y las preferencias de género para proporcionar sugerencias precisas y relevantes sobre cómo completar el conjunto.
                           El campo "items" debe ser una lista de elementos que combinarían bien con la prenda en la imagen. Cada elemento debe representar un título de una prenda de vestir que contenga el estilo, color y género de la prenda.
El archivo markdown que se proporciona se encuentra a continuación:
 
```markdown
La categoría debe elegirse entre los tipos en esta lista: {subcategories}.
Debes elegir entre los géneros en esta lista: [Hombres, Mujeres, Niños, Niñas, Unisex]
No incluyas la descripción del artículo en la imagen. No incluyas la etiqueta ```json ``` en la salida.
 
Ejemplo de entrada: Una imagen que representa una chaqueta de cuero negro.
 
Ejemplo de salida: {"items": ["Camiseta blanca ajustada para mujer", "Zapatillas de lona blancas", "Vaqueros negros ajustados para mujer"], "category": "Chaquetas", "gender": "Mujeres"}

import base64
 
def encode_image_to_base64(image_path):
    with open(image_path, 'rb') as image_file:
        encoded_image = base64.b64encode(image_file.read())
        return encoded_image.decode('utf-8')

# Establecer la ruta a las imágenes y seleccionar una imagen de prueba
ruta_imagen = "data/sample_clothes/sample_images/"
imagenes_prueba = ["2133.jpg", "7143.jpg", "4226.jpg"]
 
# Codificar la imagen de prueba en base64
imagen_referencia = ruta_imagen + imagenes_prueba[0]
imagen_codificada = encode_image_to_base64(imagen_referencia)

Análisis de la imagen y retorno de los resultados

# Seleccionar las subcategorías únicas del DataFrame
subcategorias_unicas = styles_df['articleType'].unique()
 
# Analizar la imagen y devolver los resultados
analisis = analyze_image(imagen_codificada, subcategorias_unicas)
analisis_imagen = json.loads(analisis)
 
# Mostrar la imagen y los resultados del análisis
display(Image(filename=imagen_referencia))
print(analisis_imagen)

A continuación, procesamos la salida del análisis de imagen y la utilizamos para filtrar y mostrar los elementos coincidentes de nuestro conjunto de datos. A continuación se muestra una descripción del código:

Extracción de los resultados del análisis de imagen: Extraemos las descripciones de los elementos, la categoría y el género del diccionario analisis_imagen.
Filtrar el conjunto de datos: Filtramos el DataFrame styles_df para incluir solo elementos que coincidan con el género del análisis de imagen (o sean unisexuales) y excluimos elementos de la misma categoría que la imagen analizada.
Buscar elementos coincidentes: Utilizamos la función find_matching_items_with_rag para encontrar elementos en el conjunto de datos filtrado que coincidan con las descripciones extraídas de la imagen analizada.
Mostrar elementos coincidentes: Creamos una cadena HTML para mostrar imágenes de los elementos coincidentes. Construimos las rutas de las imágenes utilizando los identificadores de los elementos y agregamos cada imagen a la cadena HTML. Por último, utilizamos display(HTML(html)) para mostrar las imágenes en el cuaderno.

Esta celda demuestra eficazmente cómo utilizar los resultados del análisis de imagen para filtrar un conjunto de datos y mostrar visualmente los elementos que coinciden con las características de la imagen analizada.

# Extraer las características relevantes del análisis
desc_items = analisis_imagen['items']
categoria_item = analisis_imagen['category']
genero_item = analisis_imagen['gender']
 
 
# Filtrar los datos para buscar solo los elementos del mismo género (o unisexuales) y de una categoría diferente
elementos_filtrados = styles_df.loc[styles_df['genero'].isin([genero_item, 'Unisex'])]
elementos_filtrados = elementos_filtrados[elementos_filtrados['articleType'] != categoria_item]
print(str(len(elementos_filtrados)) + " elementos restantes")
 
# Encontrar los elementos más similares en función de las descripciones de los elementos de entrada
elementos_coincidentes = find_matching_items_with_rag(elementos_filtrados, desc_items)
 
# Mostrar los elementos coincidentes (esto mostrará 2 elementos para cada descripción en el análisis de imagen)
html = ""
rutas = []
for i, item in enumerate(elementos_coincidentes):
    item_id = item['id']
        
    # Ruta al archivo de la imagen
    ruta_imagen = f'data/sample_clothes/sample_images/{item_id}.jpg'
    rutas.append(ruta_imagen)
    html += f'<img src="{ruta_imagen}" style="display:inline;margin:1px"/>'
 
# Imprimir la descripción del elemento coincidente como recordatorio de lo que estamos buscando
print(desc_items)
# Mostrar la imagen
display(HTML(html))

Barreras

En el contexto del uso de modelos de lenguaje grandes (LLMs) como GPT-4V, "barreras" se refieren a mecanismos o verificaciones que se implementan para asegurarse de que la salida del modelo se mantenga dentro de los parámetros o límites deseados. Estas barreras son cruciales para mantener la calidad y relevancia de las respuestas del modelo, especialmente cuando se trata de tareas complejas o sutiles.

Las barreras son útiles por varias razones:

Precisión: Ayudan a asegurar que la salida del modelo sea precisa y relevante para la entrada proporcionada.
Consistencia: Mantienen la consistencia en las respuestas del modelo, especialmente cuando se trata de entradas similares o relacionadas.
Seguridad: Evitan que el modelo genere contenido nocivo, ofensivo o inapropiado.
Relevancia contextual: Aseguran que la salida del modelo sea relevante en el contexto de la tarea o dominio específico para el que se está utilizando. En nuestro caso, estamos utilizando GPT-4V para analizar imágenes de moda y sugerir artículos que complementarían un conjunto original. Para implementar las barreras de seguridad, podemos refinar resultados: Después de obtener sugerencias iniciales de GPT-4V, podemos enviar la imagen original y los artículos sugeridos de vuelta al modelo. Luego, podemos pedirle a GPT-4V que evalúe si cada artículo sugerido en verdad sería una buena combinación para el conjunto original.

Esto le da al modelo la capacidad de autocorrección y ajuste de su propia producción basado en retroalimentación o información adicional. Al implementar estas barreras de seguridad y habilitar la autocorrección, podemos mejorar la confiabilidad y utilidad de la producción del modelo en el contexto del análisis y recomendación de moda.

Para facilitar esto, escribimos un mensaje que le pide al LLM una respuesta simple de "sí" o "no" a la pregunta de si los artículos sugeridos coinciden con el conjunto original o no. Esta respuesta binaria ayuda a agilizar el proceso de refinamiento y garantiza una retroalimentación clara y práctica del modelo.

def check_match(reference_image_base64, suggested_image_base64):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """ Se te darán dos imágenes de dos prendas de ropa diferentes.
                            Tu objetivo es decidir si las prendas en las imágenes funcionarían juntas en un conjunto.
                            La primera imagen es el artículo de referencia (la prenda con la que el usuario intenta combinar otra prenda).
                            Debes decidir si la segunda prenda funcionaría bien con el artículo de referencia.
                            Tu respuesta debe ser una salida JSON con los siguientes campos: "respuesta", "razón".
                            El campo "respuesta" debe ser "sí" o "no", según si crees que las prendas funcionarían bien juntas.
                            El campo "razón" debe ser una explicación breve de tu razonamiento para tu decisión. No incluyas las descripciones de las 2 imágenes.
                            No incluyas la etiqueta ```json``` en la salida.
                           """,
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{reference_image_base64}",
                },
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{suggested_image_base64}",
                },
                }
            ],
            }
        ],
        max_tokens=300,
    )
    # Extraemos características relevantes de la respuesta
    características = response.choices[0].message.content
    return características

Finalmente, determinemos cuáles de los artículos identificados anteriormente realmente complementan el conjunto.

# Seleccionamos los rutas únicas para las imágenes generadas
rutas = list(set(rutas))
 
for ruta in rutas:
    # Codificamos la imagen de prueba a base64
    image_sugerida = codificar_imagen_a_base64(ruta)
    
    # Verificamos si las prendas hacen juego
    coincidencia = json.loads(verificar_coincidencia(imagen_codificada, image_sugerida))
    
    # Mostramos la imagen y los resultados del análisis
    if coincidencia["respuesta"] == 'sí':
        display(Image(filename=ruta))
        print("¡Las prendas hacen juego!")
        print(coincidencia["razón"])

Podemos observar que la lista inicial de artículos potenciales se ha refinado aún más, lo que resulta en una selección más cuidadosa que se alinea bien con el conjunto. Además, el modelo proporciona explicaciones de por qué se considera que cada artículo es una buena combinación, ofreciendo conocimientos valiosos sobre el proceso de toma de decisiones.

Revisión

En este tutorial, exploramos la aplicación de GPT-4 con Visión y otras técnicas de aprendizaje automático en el ámbito de la moda. Demostramos cómo analizar imágenes de prendas de vestir, extraer características relevantes y utilizar esta información para encontrar artículos que hagan juego y complementen un conjunto original. Mediante la implementación de barreras de seguridad y mecanismos de autocorrección, refinamos las sugerencias del modelo para garantizar que sean precisas y contextualmente relevantes.

Este enfoque tiene varios usos prácticos en el mundo real, incluyendo:

Asistentes de compra personalizados: Los minoristas pueden utilizar esta tecnología para ofrecer recomendaciones de conjuntos personalizados a los clientes, mejorando la experiencia de compra y aumentando la satisfacción del cliente.
Aplicaciones de armario virtual: Los usuarios pueden cargar imágenes de sus propias prendas de vestir para crear un armario virtual y recibir sugerencias de nuevos artículos que hagan juego con sus piezas existentes.
Diseño y estilo de moda: Los diseñadores y estilistas de moda pueden utilizar esta herramienta para experimentar con diferentes combinaciones y estilos, optimizando el proceso creativo.

Sin embargo, uno de los aspectos a tener en cuenta es el costo. El uso de LLMs y modelos de análisis de imágenes puede generar costos, especialmente si se utilizan ampliamente. Es importante considerar la relación costo-efectividad de implementar estas tecnologías. gpt-4-vision-preview tiene un precio de $0.01 por cada 1000 tokens. Esto suma $0.00255 por una imagen de 256px x 256px.

En general, esta guía sirve como base para una exploración y desarrollo más profundos en la intersección de la moda y la IA, abriendo puertas a sistemas de recomendación de moda más personalizados e inteligentes.

Conclusión

La expansión de GPT-4 al procesamiento y generación de imágenes marca un hito importante en el desarrollo de la IA. Al comprender cómo aprovechar las capacidades de visión de GPT-4, los usuarios pueden aprovechar el poder de la IA para crear y analizar imágenes de formas que antes se consideraban imposibles. Ya sea para fines creativos, educativos o analíticos, GPT-4 abre nuevas posibilidades para integrar lo visual en el mundo digital, mejorando tanto la creación como la comprensión de contenido en diversos ámbitos.

Cómo utilizar la API de DALLE3 para generar imágenes mejores Jamba: El modelo híbrido SSM-Transformer revolucionario de AI21 redefine el panorama de la IA