Como Usar o GPT-4 para Geração e Análise de Imagens

Name: Lynn Mikami

Published on 30/04/2024

Este guia passo a passo explora as capacidades inovadoras do GPT-4V, incluindo geração e análise de imagens, oferecendo conselhos práticos sobre como aproveitar ao máximo esse modelo avançado de IA tanto para criação de conteúdo textual como visual.

A chegada do GPT-4 marcou uma evolução significativa no campo da inteligência artificial, ampliando suas capacidades além do texto para incluir geração e análise de imagens. Este artigo explora as funcionalidades multifacetadas do GPT-4, com foco em sua capacidade de processar e gerar imagens, e fornece um guia abrangente sobre como aproveitar esses recursos de forma eficaz.

O que é o GPT-4?

O GPT-4, ou Generative Pre-trained Transformer 4, é uma iteração avançada dos modelos de IA desenvolvidos pela OpenAI. Ele se destaca por sua compreensão aprimorada e geração de texto semelhante ao humano, mas o que diferencia o GPT-4 é sua capacidade de interagir com imagens. Isso inclui a geração de imagens a partir de descrições (GPT-4 Vision ou GPT-4V), a análise de conteúdo dentro de imagens e até mesmo a leitura de texto capturado em imagens, tornando-o uma ferramenta versátil para várias aplicações.

Compreendendo as Capacidades de Imagem do GPT-4

As capacidades de visão do GPT-4, frequentemente chamadas de GPT-4 Vision ou GPT-4V, permitem que ele processe e gere imagens com base em descrições textuais. Isso significa que você pode fazer o upload de uma imagem para análise ou solicitar que o modelo crie novas imagens do zero. Seja para criar obras de arte, gerar visualizações para conteúdo ou extrair informações de imagens, o GPT-4V está preparado para lidar com uma variedade de tarefas, tornando-o uma adição poderosa à suíte GPT-4.

Como Gerar Imagens com o GPT-4

Gerar imagens com o GPT-4 é simples. Os usuários podem inserir uma descrição detalhada da imagem que desejam e o modelo gerará uma imagem correspondente. Essa funcionalidade é especialmente útil para artistas, designers e criadores de conteúdo que desejam dar vida às suas ideias sem a necessidade de habilidades manuais de desenho ou design. Também é inestimável para a criação de visualizações que complementam o conteúdo baseado em texto, aprimorando a experiência geral do usuário.

Como Usar o GPT-4 para Análise de Imagens

Além de gerar imagens, o GPT-4 pode analisar e interpretar o conteúdo dentro de fotos. Isso inclui a leitura de textos em imagens, o reconhecimento de objetos e a compreensão de cenas. Para usar esse recurso, os usuários podem fazer o upload de uma imagem para a plataforma, e o GPT-4 fornecerá informações com base em sua análise. Essa capacidade é especialmente útil para tarefas que envolvem pesquisa baseada em imagens, extração de dados e aprimoramentos de acessibilidade, como a leitura de textos para usuários com deficiência visual.

Aplicações Práticas do GPT-4 Vision

As aplicações potenciais das capacidades de imagem do GPT-4 são vastas. No setor educacional, ele pode facilitar a aprendizagem interativa, gerando materiais visuais ou analisando fotografias históricas. Os profissionais de marketing podem usar o GPT-4 para criar visualizações cativantes para campanhas ou analisar fotos de consumidores em busca de insights. Além disso, na indústria criativa, o GPT-4 pode ajudar no processo de design, gerando conceitos iniciais ou modificando visualizações existentes com base no feedback.

Como Combinar o GPT-4V com RAG - Criar um Aplicativo de Combinador de Roupas

Bem-vindo ao Caderno Jupyter do Aplicativo de Combinador de Roupas! Este projeto demonstra o poder do modelo GPT-4V na análise de imagens de peças de roupa e na extração de características-chave, como cor, estilo e tipo. O núcleo de nosso aplicativo baseia-se neste modelo avançado de análise de imagens desenvolvido pela OpenAI, que nos permite identificar com precisão as características da peça de roupa de entrada.

O GPT-4V é um modelo que combina processamento de linguagem natural com reconhecimento de imagem, permitindo entender e gerar respostas com base tanto em texto quanto em entradas visuais.

Com base nas capacidades do modelo GPT-4V, usamos um algoritmo de correspondência personalizado e a técnica RAG para pesquisar nossa base de conhecimento em busca de itens que completem as características identificadas. Esse algoritmo leva em consideração fatores como compatibilidade de cores e coesão de estilos para fornecer recomendações adequadas aos usuários. Através deste caderno, nosso objetivo é mostrar a aplicação prática dessas tecnologias na criação de um sistema de recomendação de roupas.

O uso da combinação GPT-4 Vision + RAG (Retrieval-Augmented Generation) oferece várias vantagens:

Compreensão Contextual: O GPT-4 Vision pode analisar imagens de entrada e entender o contexto, como objetos, cenas e atividades representadas. Isso permite sugestões ou informações mais precisas e relevantes em diversos domínios, seja design de interiores, culinária ou educação.
Base de Conhecimento Rica: O RAG combina as capacidades generativas do GPT-4 com um componente de recuperação que acessa um grande corpus de informações em diferentes áreas. Isso significa que o sistema pode fornecer sugestões ou insights com base em uma ampla gama de conhecimentos, desde fatos históricos até conceitos científicos.
Customização: A abordagem permite fácil personalização para atender às necessidades ou preferências específicas do usuário em várias aplicações. Seja adaptar sugestões para o gosto artístico de um usuário ou fornecer conteúdo educacional com base no nível de aprendizado de um estudante, o sistema pode ser adaptado para fornecer experiências personalizadas.

Em geral, a abordagem GPT-4 Vision + RAG oferece uma solução poderosa e flexível para diversas aplicações relacionadas à moda, aproveitando as vantagens das técnicas de IA generativas e baseadas em recuperação.

Configuração do Ambiente

Primeiro, vamos instalar as dependências necessárias, em seguida, importar as bibliotecas e escrever algumas funções de utilidade que usaremos posteriormente.

import pandas as pd
import numpy as np
import json
import ast
import tiktoken
import concurrent
from openai import OpenAI
from tqdm import tqdm
from tenacity import retry, wait_random_exponential, stop_after_attempt
from IPython.display import Image, display, HTML
from typing import List
 
client = OpenAI()
 
GPT_MODEL = "gpt-4-vision-preview"
EMBEDDING_MODEL = "text-embedding-3-large"
EMBEDDING_COST_PER_1K_TOKENS = 0,00013

Criando os Embeddings

Agora vamos configurar a base de conhecimento escolhendo um banco de dados e gerando embeddings para ele. Estou usando o arquivo sample_styles.csv para isso, localizado na pasta de dados. Este é um exemplo de um conjunto de dados maior que contém cerca de 44K itens. Esta etapa também pode ser substituída pelo uso de um banco de dados vetorial pronto para uso. Por exemplo, você pode seguir um dos estas receitas (opens in a new tab) para configurar seu banco de dados vetorial.

styles_filepath = "data/sample_clothes/sample_styles.csv"
styles_df = pd.read_csv(styles_filepath, on_bad_lines='skip')
print(styles_df.head())
print("Abertura do conjunto de dados com sucesso. O conjunto de dados possui {} itens de roupa.".format(len(styles_df)))

Agora vamos gerar embeddings para todo o conjunto de dados. Podemos paralelizar a execução desses embeddings para garantir que o script seja dimensionado para conjuntos de dados maiores. Com essa lógica, o tempo para criar embeddings para o conjunto de dados completo de 44K entradas diminui de ~4h para ~2-3min.

## Lógica de Embdedding em Lote
 
# Função simples para receber uma lista de objetos de texto e retorná-los como uma lista de embeddings
@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(10))
def get_embeddings(input: List):
    response = client.embeddings.create(
        input=input,
        model=EMBEDDING_MODEL
    ).data
    return [data.embedding for data in response]
 
 
# Divide um iterável em batches de tamanho n.
def batchify(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx : min(ndx + n, l)]
     
 
# Função para criar batches e processar os embeddings em paralelo
def embed_corpus(
    corpus: List[str],
    batch_size=64,
    num_workers=8,
    max_context_len=8191,
):
    # Codifica o corpus, truncando em max_context_len
    encoding = tiktoken.get_encoding("cl100k_base")
    encoded_corpus = [
        encoded_article[:max_context_len] for encoded_article in encoding.encode_batch(corpus)
    ]
 
    # Calcula estatísticas do corpus: o número de entradas, o número total de tokens e o custo estimado do embedding
    num_tokens = sum(len(article) for article in encoded_corpus)
    cost_to_embed_tokens = num_tokens / 1000 * EMBEDDING_COST_PER_1K_TOKENS
    print(
        f"num_articles={len(encoded_corpus)}, num_tokens={num_tokens}, est_embedding_cost={cost_to_embed_tokens:.2f} USD"
    )
 
    # Faz os embeddings do corpus
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
        
        futures = [
            executor.submit(get_embeddings, text_batch)
            for text_batch in batchify(encoded_corpus, batch_size)
        ]
 
        with tqdm(total=len(encoded_corpus)) as pbar:
            for _ in concurrent.futures.as_completed(futures):
                pbar.update(batch_size)
 
        embeddings = []
        for future in futures:
            data = future.result()
            embeddings.extend(data)
 
        return embeddings
    
# Função para gerar embeddings para uma determinada coluna em um DataFrame
def generate_embeddings(df, column_name):
    # Inicializa uma lista vazia para armazenar os embeddings
    descriptions = df[column_name].astype(str).tolist()
    embeddings = embed_corpus(descriptions)
 
    # Adiciona os embeddings como uma nova coluna no DataFrame
    df['embeddings'] = embeddings
    print("Embeddings criados com sucesso.")

Duas opções para criar os embeddings:

A próxima linha irá criar os embeddings para o conjunto de dados de roupas de exemplo. Isso levará cerca de 0,02s para processar e mais cerca de 30s para escrever os resultados em um arquivo .csv local. O processo está usando nosso modelo text_embedding_3_large, que tem um custo de $0,00013/1K tokens. Dado que o conjunto de dados tem cerca de 1K entradas, a operação seguinte custará aproximadamente $0,001. Se você decidir trabalhar com o conjunto de dados completo de 44K entradas, esta operação levará de 2 a 3 minutos para ser processada e custará aproximadamente $0,07.

Se você não quiser prosseguir com a criação de seus próprios embeddings, usaremos um conjunto de dados de embeddings pré-computados. Você pode pular esta célula e descomentar o código na célula seguinte para prosseguir com o carregamento dos vetores pré-computados. Essa operação leva cerca de 1 minuto para carregar todos os dados na memória.

generate_embeddings(styles_df, 'productDisplayName')
print("Gravando embeddings em arquivo ...")
styles_df.to_csv('data/sample_clothes/sample_styles_with_embeddings.csv', index=False)
print("Embeddings armazenados com sucesso em sample_styles_with_embeddings.csv")

# styles_df = pd.read_csv('data/sample_clothes/sample_styles_with_embeddings.csv', on_bad_lines='skip')
 
# # Converte a coluna 'embeddings' de representações de strings de listas em listas reais de floats
# styles_df['embeddings'] = styles_df['embeddings'].apply(lambda x: ast.literal_eval(x))
 
print(styles_df.head())
print("Conjunto de dados aberto com sucesso. O conjunto de dados possui {} itens de roupas juntamente com seus embeddings.".format(len(styles_df)))

Construindo o Algoritmo de Correspondência

Nesta seção, desenvolveremos um algoritmo de recuperação de similaridade cosseno para encontrar itens semelhantes em nosso dataframe. Utilizaremos nossa função de similaridade cosseno personalizada para esse propósito. Embora a biblioteca sklearn ofereça uma função de similaridade cosseno embutida, atualizações recentes em seu SDK causaram problemas de compatibilidade, levando-nos a implementar nosso próprio cálculo de similaridade cosseno padrão.

Se você já tiver um banco de dados de vetores configurado, pode pular esta etapa. A maioria dos bancos de dados padrão vem com suas próprias funções de pesquisa, o que simplifica as etapas subsequentes descritas neste guia. No entanto, nosso objetivo é demonstrar que o algoritmo de correspondência pode ser adaptado para atender a requisitos específicos, como um limite específico ou um número especificado de correspondências retornadas.

A função find_similar_items aceita quatro parâmetros:

embedding: O embedding para o qual queremos encontrar uma correspondência.
embeddings: Uma lista de embeddings para pesquisar as melhores correspondências.
threshold (opcional): Este parâmetro especifica a pontuação mínima de similaridade para uma correspondência ser considerada válida. Um limite mais alto resulta em correspondências mais próximas (melhores), enquanto um limite mais baixo permite que mais itens sejam retornados, embora eles possam não estar tão bem correspondidos ao embedding inicial.
top_k (opcional): Este parâmetro determina o número de itens a serem retornados que excedem o limite fornecido. Esses serão as correspondências com a maior pontuação para o embedding fornecido.

def cosine_similarity_manual(vec1, vec2):
    """Calcula a similaridade cosseno entre dois vetores."""
    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):
    """Encontre os itens mais semelhantes com base na similaridade cosseno."""
    
    # Calcula a similaridade cosseno entre o embedding de entrada e todos os outros embeddings
    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
    
    # Filtra as similaridades abaixo do limiar
    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
    
    # Ordena as similaridades filtradas por pontuação de similaridade
    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
 
    # Retorna os itens mais semelhantes do top-k
    return sorted_indices

def find_matching_items_with_rag(df_items, item_descs):
   """Pegue as descrições dos itens de entrada e encontre os itens mais semelhantes com base na similaridade cosseno para cada descrição."""
   
   # Selecione os embeddings do DataFrame.
   embeddings = df_items['embeddings'].tolist()
 
   
   similar_items = []
   for desc in item_descs:
      
      # Gera o embedding para o item de entrada
      input_embedding = get_embeddings([desc])
    
      # Encontre os itens mais semelhantes com base na similaridade cosseno
      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álise

Neste módulo, aproveitamos o gpt-4-vision-preview para analisar imagens de entrada e extrair características importantes, como descrições detalhadas, estilos e tipos. A análise é realizada por meio de uma chamada de API direta, na qual fornecemos a URL da imagem para análise e solicitamos que o modelo identifique recursos relevantes.

Para garantir que o modelo retorne resultados precisos, usamos técnicas específicas em nosso texto de prompt:

Especificação do Formato de Saída: Instruímos o modelo a retornar um bloco JSON com uma estrutura predefinida, composta por:
- items (str[]): Uma lista de strings, cada uma representando um título conciso para um item de roupa, incluindo estilo, cor e gênero. Esses títulos se assemelham de perto à propriedade productDisplayName em nosso banco de dados original.
- category (str): A categoria que melhor representa o item fornecido. O modelo seleciona a partir de uma lista de todos os articleTypes únicos presentes no dataframe de estilos original.
- gender (str): Um rótulo indicando o gênero para o qual o item é destinado. O modelo escolhe entre as opções [Men, Women, Boys, Girls, Unisex].
Instruções Claras e Concisas:
- Fornecemos instruções claras sobre o que os títulos dos itens devem incluir e qual deve ser o formato de saída. A saída deve estar no formato JSON, mas sem a marcação json que normalmente acompanha a resposta do modelo.
Exemplo Único:
- Para esclarecer ainda mais a saída esperada, fornecemos ao modelo uma descrição de entrada de exemplo e uma saída de exemplo correspondente. Embora isso possa aumentar o número de tokens usados (e, portanto, o custo da chamada), ajuda a orientar o modelo e resulta em um desempenho geral melhor.

Ao seguir essa abordagem estruturada, pretendemos obter informações precisas e úteis do modelo gpt-4-vision-preview para análise posterior e integração em nosso banco de dados.

def analyze_image(image_base64, subcategories):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """Dada uma imagem de uma peça de roupa, analise a peça e gere uma saída JSON com os seguintes campos: "items", "category" e "gender".
                           Use seu entendimento de tendências de moda, estilos e preferências de gênero para fornecer sugestões precisas e relevantes sobre como completar o visual.
                           Os campos de itens devem ser uma lista de itens que combinariam bem com a peça na imagem. Cada item deve representar o título de uma peça de roupa que contém o estilo, a cor e o gênero da peça.

O documento do Markdown contém código e comentários que são escritos em inglês, então não é necessário traduzir o conteúdo do código e dos comentários. Aqui está a tradução do restante do documento:

A categoria precisa ser escolhida entre os tipos nesta lista: {subcategories}.
Você precisa escolher entre os gêneros nesta lista: [Homens, Mulheres, Meninos, Meninas, Unissex]
Não inclua a descrição do item na imagem. Não inclua a tag ```json``` no resultado.

Exemplo de entrada: Uma imagem representando uma jaqueta de couro preta.

Exemplo de saída: {"items": ["Camiseta branca justa feminina", "Tênis branco de lona", "Calça jeans skinny preta feminina"], "category": "Jaquetas", "gender": "Mulheres"}

Testando o Prompt com Imagens de Amostra

Para avaliar a eficácia do nosso prompt, vamos carregá-lo e testá-lo com uma seleção de imagens do nosso conjunto de dados. Usaremos imagens da pasta "data/sample_clothes/sample_images", garantindo uma variedade de estilos, gêneros e tipos. Aqui estão as amostras escolhidas:

2133.jpg: Camisa masculina
7143.jpg: Camisa feminina
4226.jpg: Camiseta masculina casual estampada

Ao testar o prompt com essas imagens diversas, podemos avaliar sua capacidade de analisar e extrair recursos relevantes de diferentes tipos de roupas e acessórios.

Precisamos de uma função utilitária para codificar as imagens .jpg em base64.

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')

# Defina o caminho das imagens e selecione uma imagem de teste
image_path = "data/sample_clothes/sample_images/"
test_images = ["2133.jpg", "7143.jpg", "4226.jpg"]
 
# Codifique a imagem de teste em base64
reference_image = image_path + test_images[0]
encoded_image = encode_image_to_base64(reference_image)

# Selecione as subcategorias únicas do DataFrame
unique_subcategories = styles_df['articleType'].unique()
 
# Analise a imagem e retorne os resultados
análise = analyze_image(encoded_image, unique_subcategories)
análise_imagem = json.loads(análise)
 
# Exiba a imagem e os resultados da análise
display(Image(filename=reference_image))
print(análise_imagem)

Em seguida, processamos a saída da análise da imagem e a utilizamos para filtrar e exibir os itens correspondentes em nosso conjunto de dados. Aqui está uma explicação do código:

Extraindo os Resultados da Análise da Imagem: Extraímos as descrições dos itens, a categoria e o gênero do dicionário análise_imagem.
Filtrando o Conjunto de Dados: Filtramos o DataFrame styles_df para incluir apenas itens que correspondem ao gênero da análise da imagem (ou são unissex) e excluímos itens da mesma categoria da imagem analisada.
Encontrando Itens Correspondentes: Usamos a função find_matching_items_with_rag para encontrar itens no conjunto de dados filtrado que correspondam às descrições extraídas da imagem analisada.
Exibindo os Itens Correspondentes: Criamos uma string HTML para exibir imagens dos itens correspondentes. Construímos os caminhos das imagens usando os IDs dos itens e adicionamos cada imagem à string HTML. Por fim, usamos display(HTML(html)) para exibir as imagens no notebook.

Essa célula demonstra de forma eficaz como usar os resultados da análise da imagem para filtrar um conjunto de dados e exibir visualmente os itens que correspondem às características da imagem analisada.

# Extrai os recursos relevantes da análise
descs_itens = análise_imagem['items']
categoria_item = análise_imagem['category']
gênero_item = análise_imagem['gender']
 
 
# Filtra os dados para procurar apenas os itens do mesmo gênero (ou unissex) e categoria diferente
itens_filtrados = styles_df.loc[styles_df['gender'].isin([gênero_item, 'Unissex'])]
itens_filtrados = itens_filtrados[itens_filtrados['articleType'] != categoria_item]
print(str(len(itens_filtrados)) + " Itens Restantes")
 
# Encontra os itens mais semelhantes com base nas descrições dos itens fornecidas
itens_correspondentes = find_matching_items_with_rag(itens_filtrados, descs_itens)
 
# Exibe os itens correspondentes (isso irá exibir 2 itens para cada descrição da análise da imagem)
html = ""
caminhos = []
for i, item in enumerate(itens_correspondentes):
    item_id = item['id']
        
    # Caminho para o arquivo da imagem
    caminho_imagem = f'data/sample_clothes/sample_images/{item_id}.jpg'
    caminhos.append(caminho_imagem)
    html += f'<img src="{caminho_imagem}" style="display:inline;margin:1px"/>'
 
# Imprime a descrição do item correspondente como lembrete do que estamos procurando
print(descs_itens)
# Exibe a imagem
display(HTML(html))

Guardrails

No contexto da utilização de Modelos de Linguagem Avançada (LLMs, da sigla em inglês) como GPT-4V, "guardrails" se refere a mecanismos ou verificações implementados para garantir que a saída do modelo permaneça dentro dos parâmetros ou limites desejados. Essas restrições são cruciais para manter a qualidade e relevância das respostas do modelo, especialmente ao lidar com tarefas complexas ou nuances.

Guardrails são úteis por várias razões:

Precisão: Eles ajudam a garantir que a saída do modelo seja precisa e relevante para a entrada fornecida.
Consistência: Eles mantêm a consistência na resposta do modelo, especialmente ao lidar com entradas similares ou relacionadas.
Segurança: Eles impedem que o modelo gere conteúdo prejudicial, ofensivo ou inadequado.
Relevância Contextual: Eles garantem que a saída do modelo seja contextualmente relevante para a tarefa ou domínio específico em que está sendo usado. Neste caso, estamos usando o GPT-4V para analisar imagens de moda e sugerir itens que complementariam um outfit original. Para implementar guardrails, podemos refinar os resultados: Depois de obter sugestões iniciais do GPT-4V, podemos enviar a imagem original e os itens sugeridos de volta para o modelo. Podemos então pedir ao GPT-4V para avaliar se cada item sugerido realmente seria uma boa combinação para o outfit original.

Isso dá ao modelo a capacidade de se auto-corrigir e ajustar sua própria saída com base no feedback ou informações adicionais. Ao implementar esses guardrails e permitir a auto-correção, podemos melhorar a confiabilidade e utilidade da saída do modelo no contexto da análise e recomendação de moda.

Para facilitar isso, escrevemos uma prompt que pede ao LLM uma resposta simples "sim" ou "não" para a pergunta se os itens sugeridos combinam ou não com o outfit original. Essa resposta binária ajuda a agilizar o processo de refinamento e garante um feedback claro e acionável do 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": """Você receberá duas imagens de duas peças de roupa diferentes.
                            Seu objetivo é decidir se as peças nas imagens ficariam bem em um outfit juntas.
                            A primeira imagem é a peça de referência (a peça que o usuário está tentando combinar com outra peça).
                            Você precisa decidir se a segunda peça ficaria bem com a peça de referência.
                            Sua resposta deve ser uma saída JSON com os seguintes campos: "answer", "reason".
                            O campo "answer" deve ser "sim" ou "não", dependendo se você acha que as peças ficariam bem juntas.
                            O campo "reason" deve ser uma breve explicação do seu raciocínio para sua decisão. Não inclua as descrições das 2 imagens.
                            Não inclua a tag ```json ``` na saída.
                           """,
                },
                {
                "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,
    )
    # Extrai recursos relevantes da resposta
    features = response.choices[0].message.content
    return features

Por fim, vamos determinar quais dos itens identificados acima realmente complementam o outfit.

# Seleciona os caminhos únicos para as imagens geradas
paths = list(set(paths))
 
for path in paths:
    # Codifica a imagem de teste para base64
    suggested_image = encode_image_to_base64(path)
    
    # Verifica se os itens combinam
    match = json.loads(check_match(encoded_image, suggested_image))
    
    # Exibe a imagem e os resultados da análise
    if match["answer"] == 'sim':
        display(Image(filename=path))
        print("Os itens combinam!")
        print(match["reason"])

Podemos observar que a lista inicial de itens potenciais foi ainda mais refinada, resultando em uma seleção mais curada que se alinha bem com o outfit. Além disso, o modelo fornece explicações de por que cada item é considerado uma boa combinação, oferecendo insights valiosos no processo de tomada de decisão.

Revisão

Neste tutorial, exploramos a aplicação do GPT-4 com Visão e outras técnicas de aprendizado de máquina no domínio da moda. Demonstramos como analisar imagens de peças de roupa, extrair recursos relevantes e usar essas informações para encontrar itens correspondentes que complementam um outfit original. Através da implementação de guardrails e mecanismos de auto-correção, refinamos as sugestões do modelo para garantir que sejam precisas e contextualmente relevantes.

Essa abordagem tem várias utilidades práticas no mundo real, incluindo:

Assistentes de Compras Personalizados: Varejistas podem usar essa tecnologia para oferecer recomendações de outfits personalizadas aos clientes, aprimorando a experiência de compra e aumentando a satisfação do cliente.
Aplicações de Guarda-Roupa Virtual: Os usuários podem fazer upload de imagens de suas próprias peças de roupa para criar um guarda-roupa virtual e receber sugestões de novos itens que combinam com suas peças existentes.
Design e Estilização de Moda: Designers de moda e estilistas podem usar essa ferramenta para experimentar diferentes combinações e estilos, agilizando o processo criativo.

No entanto, é importante ter em mente um dos aspectos a serem considerados: custo. O uso de LLMs e modelos de análise de imagem pode incorrer em custos, especialmente se usados em grande escala. É importante considerar a relação custo-efetividade da implementação dessas tecnologias. gpt-4-vision-preview tem um preço de $0,01 por 1000 tokens. Isso resulta em um custo de $0,00255 para uma imagem de 256px x 256px.

Em geral, este guia serve como base para exploração e desenvolvimento adicionais na intersecção da moda e da IA, abrindo portas para sistemas de recomendação de moda mais personalizados e inteligentes.

Conclusão

A expansão do GPT-4 para o processamento e geração de imagens marca um marco significativo no desenvolvimento da IA. Ao entender como utilizar as capacidades de visão do GPT-4, os usuários podem aproveitar o poder da IA para criar e analisar imagens de maneiras anteriormente consideradas impossíveis. Seja para fins criativos, educacionais ou analíticos, o GPT-4 abre novas possibilidades para integrar imagens ao mundo digital, aprimorando tanto a criação quanto a compreensão de conteúdo em vários domínios.

Como Usar a API DALLE3 para Melhor Geração de Imagens Jamba: O Modelo Hibrido SSM-Transformer Revolucionário da AI21 Redefine o Cenário de IA