Amazon Bedrock e Python: crie ferramentas de categorização e explore modelos customizados de IA

Representando textos com embeddings - Apresentação

Boas-vindas ao curso! Meu nome é Lucas Mata e sou o instrutor aqui na Alura.

Audiodescrição: Lucas se descreve como um homem de pele clara. Ele usa óculos de armação redonda e preta e veste uma blusa azul-marinho com o texto "Alura". Possui barba e cavanhaque, além de cabelo preto. Ao fundo, nos estúdios da Alura, há uma parede iluminada em tons de roxo e azul.

Para quem é esse curso?

Este curso destina-se àqueles que desejam aplicar a inteligência artificial em seus projetos e aplicações.

Ferramenta

Utilizaremos um serviço da AWS chamado Amazon Bedrock, que oferece diversos recursos e modelos de inteligência artificial para integração em projetos.

Pré-requisitos

Para aproveitar ao máximo este curso, é essencial ter conhecimentos em programação em Python. Também é recomendável ter concluído o curso anterior desta formação.

O que vamos aprender?

Neste curso, exploraremos a interação com modelos de IA generativa, desenvolveremos ferramentas de classificação e categorização de dados utilizando inteligência artificial, e utilizaremos as bases de conhecimento do Bedrock para realizar consultas inteligentes a arquivos, obtendo respostas mais precisas dos LLMs. Também integraremos o Bedrock com outros serviços da AWS, como o API Gateway e o Lambda, um serviço serverless (sem servidor).

Além disso, aprenderemos a realizar o fine-tuning ("ajuste fino") para obtenção de modelos customizados mais adequados a casos de negócios mais específicos. Por fim, analisaremos os custos envolvidos em diferentes abordagens no uso de AR em aplicações e projetos.

Recursos da plataforma

A aprendizagem ocorrerá de maneira prática. Iremos construir ferramentas, projetos e aplicações que integram todos os recursos do Bedrock. Utilizaremos as funcionalidades da plataforma, além de interagir no nosso fórum e na comunidade no Discord.

Conclusão

Nos encontraremos nos próximos vídeos para iniciar essa nova jornada de aprendizado.

Representando textos com embeddings - Compreendendo embeddings

Na primeira etapa de nossa jornada de aprendizado, exploramos os recursos e serviços disponíveis no Amazon Bedrock, na AWS.

Acessamos o console do Bedrock clicando no botão "Conceitos básicos". Somos direcionados para a aba "Explorar e aprender" com uma seção chamada de "Modelos de base". Nela, examinamos diversos modelos de base, incluindo aqueles voltados para a geração de imagens e o processamento de linguagem natural. Por meio de requisições, obtivemos respostas que nos ajudaram a entender melhor as capacidades dessas ferramentas.

Desenvolvemos aplicações práticas, como um chatbot inteligente e uma ferramenta de geração de imagens para o Meteora, um e-commerce de moda. Nesta continuidade, permaneceremos focados no Meteora, porém buscaremos criar ferramentas distintas.

É interessante considerar como esses modelos conseguem interpretar sentenças em linguagem natural que enviamos como requisições. Quando formulamos um pedido como "quero que você gere uma imagem de uma calça jeans", como eles conseguem transformar essa solicitação textual em uma imagem? De um lado, formulamos a requisição e, do outro, recebemos uma resposta resultante desse processamento complexo.

Essas requisições são processadas na nuvem de maneira que os modelos não interpretam palavras da mesma forma que nós. No núcleo do funcionamento, há uma série de circuitos integrados que compõem o hardware do computador, processando sinais elétricos.

Para converter palavras em números, que se transformam em sinais elétricos, utilizamos representações matemáticas, geralmente na forma de vetores. Esse processo de transformação é fundamental para o funcionamento dos modelos. Exploraremos isso em detalhes!

Analisando o modelo

No console do Bedrock, no menu lateral, identificamos a seção "Conceitos básicos", que inclui a opção "Provedores", posicionada logo abaixo de "Exemplos". Ao clicar nessa opção, deparamos com uma variedade de provedores, ou seja, as empresas responsáveis por cada conjunto de modelos disponíveis no Bedrock.

Utilizaremos um modelo específico da Amazon para investigar como os dados são representados e processados por meio de vetores. Na seção dedicada aos modelos disponíveis pelo provedor Amazon, encontramos o "Titan Text G1 - Express", que já utilizamos anteriormente, e o "Titan Embeddings G1 - Text". Ao clicarmos nesse último, podemos aprofundar nossa compreensão sobre seu funcionamento.

O modelo gera embeddings a partir de mensagens, imagens ou textos.

Os embeddings são vetores que representam os textos que enviamos ao modelo, as imagens que ele cria ou até mesmo as imagens que fornecemos para classificação e descrição.

Essa abordagem se estende também a vídeos e outros formatos de dados, possibilitando uma representação numérica eficiente das informações.

Utilidade do modelo

A utilidade desse tipo de modelo é vasta e significativa. Ele pode auxiliar na categorização de produtos, na classificação de itens, na detecção de similaridades e na análise de textos. Essas capacidades contribuem para aprimorar a experiência da pessoa usuária ao navegar em plataformas de e-commerce.

Com base nos dados coletados durante a navegação, é possível oferecer recomendações otimizadas e eficientes de produtos que a pessoa usuária provavelmente terá maior interesse em adquirir.

Testando o modelo no VS Code

Testaremos o funcionamento desse modelo para compreender melhor o processo. Para começar, é fundamental entender como enviar uma requisição a ele, utilizando o formato de solicitação de API. Ao descer um pouco mais na página, encontramos a identificação do modelo e o formato específico necessário para enviar uma requisição.

• Model ID: amazon.titan-embed-text-v1
• Model ARN: arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v1

Na seção "Solicitação de API", temos o formato para enviar a requisição:

{
  "modelId": "amazon.titan-embed-text-v1",
  "contentType": "application/json",
  "accept": "*/*",
  "body": "{\"inputText\":\"this is where you place your input text\"}"
}

Seguiremos para o VS Code para realizar esse teste.

Analisando a estrutura do projeto

No VS Code, criamos uma pasta denominada Meteora, na qual já se encontram alguns arquivos.

• METEORA
  • .venv
  • .gitignore
  • requirements.txt

O primeiro deles é o requirements.txt, onde especificamos a utilização do SDK da AWS para Python, conhecido como a biblioteca boto3.

requirements.txt

boto3 >= 1.34

Essa biblioteca é essencial para consumirmos os recursos disponíveis na Amazon Bedrock.

Também criamos um ambiente virtual (.venv) para execução dos códigos e instalamos a dependência boto3. Incluímos um arquivo de .gitignore para ignorar, por exemplo, a venv ao subir o código para um repositório remoto como o GitHub.

.gitignore

.venv

Criando o arquivo embeddings.py

Para testar o modelo Titan Embeddings, criamos um novo arquivo intitulado embeddings.py. Para isso, clicamos no primeiro ícone de arquivo localizado na parte superior esquerda, que representa a opção "New File", e digitamos o nome desejado para o arquivo.

Nesse arquivo, buscamos compreender o funcionamento do modelo e o processo de representação de texto em vetores. Para isso, importamos duas bibliotecas essenciais: boto3 e json.

embeddings.py

import boto3
import json

Em seguida, criaremos um cliente do Bedrock, especificando o serviço da AWS e a região desse serviço.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

Criaremos uma variável chamada roupa e inseriremos como entrada o termo "calça jeans". Desejamos obter a representação vetorial desse termo.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

roupa = "calça jeans"

Configuraremos a requisição para enviar ao Amazon Titan Embeddings.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

roupa = "calça jeans"

response = client.invoke_model(
    body=json.dumps(
        {
            "inputText": roupa,
        }
    ),
    modelId="amazon.titan-embed-text-v1",
    accept="application/json",
    contentType="application/json",
)

Utilizamos a invocação do modelo como um método, onde incluímos json.dumps para estruturar a mensagem que servirá como prompt de entrada do modelo. No parâmetro modelId, especificamos o nome do modelo a ser utilizado, além de definir o formato de envio e de recepção, que será em JSON.

Em suma, esse código envia um texto contido na variável roupa para o modelo Titan de embeddings de texto e solicita que a resposta seja retornada em formato JSON.

Transformaremos o JSON recebido como resposta em um dicionário e exibiremos o vetor no terminal para representar o termo "calça jeans" com print():

# código omitido

response_body = json.loads(response.get("body").read())
print(response_body.get("embedding"))

Assim, ficamos com:

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

roupa = "calça jeans"

response = client.invoke_model(
    body=json.dumps(
        {
            "inputText": roupa,
        }
    ),
    modelId="amazon.titan-embed-text-v1",
    accept="application/json",
    contentType="application/json",
)

response_body = json.loads(response.get("body").read())
print(response_body.get("embedding"))

Salvamos o código com "Ctrl + S" e o executamos no terminal do VS Code digitando python embeddings.py.

python embeddings.py

Assim, observamos o vetor gerado, que representa o termo "calça jeans" de forma vetorial.

O retorno abaixo foi parcialmente transcrito:

0.11962890625, -0.85546875, 0.171875, 0.2275390625, -0.453125, -0.25390625, 0.4296875, -0.21484375, -0.208984375, -0.099609375, -0.1015625, 1.03125, -0.1923828125, -0.5859375, 0.5078125, 0.057861328125, 0.31640625, -0.431640625, -0.115234375, 0.1884765625, -0.427734375, 0.330078125

A utilidade prática dessa representação é a classificação e categorização de produtos, um procedimento comum em plataformas que lidam com grandes volumes de dados, incluindo informações sobre a navegação das pessoas usuárias. Esse tipo de modelo é empregado precisamente para esses fins. Demos, portanto, o primeiro passo para compreender o funcionamento do modelo.

Próximo passo

A seguir, exploraremos como aplicar essa técnica no contexto do Meteora.

Representando textos com embeddings - Classificando produtos

Já analisamos que, ao utilizar os modelos de IA disponíveis no Bedrock, conseguimos desenvolver diversas ferramentas. Essas ferramentas têm um papel fundamental na redução do trabalho repetitivo que frequentemente algumas equipes enfrentam em uma empresa. Por exemplo, ao inserir um novo produto na plataforma, é essencial que ele esteja alocado em uma categoria adequada.

Consideremos o caso do lançamento de uma calça jeans voltada para ocasiões mais formais, como um evento de formatura ou uma entrevista de emprego. Esse item deve ser classificado em uma categoria de produtos formais, e não em uma categoria destinada a itens de praia. Essa categorização é crucial, pois permite que as pessoas usuárias, ao realizarem suas buscas na plataforma, encontrem os produtos de acordo com a demanda que desejam atender em um determinado momento.

A chave para realizar essa tarefa com IA é o modelo que exploramos no vídeo anterior. Com o arquivo embeddings aberto, podemos gerar um embedding (representação vetorial) da calça jeans. Isso nos permite criar uma ferramenta que ajudará a equipe de publicação do Meteora a categorizar produtos a partir de suas descrições, utilizando algumas categorias definidas no código.

Começamos criando a ferramenta para utilizar o modelo de geração de embeddings do Bedrock de forma prática.

Criando a pasta categorizador

Criamos uma nova pasta dentro do diretório Meteora, chamada categorizador. Dentro dessa pasta, adicionamos outra pasta chamada classificacao. Na pasta classificacao, inserimos os módulos necessários para o funcionamento da ferramenta de categorização de produtos.

Iniciamos com o arquivo __init__.py, que serve para indicar que todos os itens dentro dessa pasta são módulos que podem ser acessados pelo código principal na raiz do diretório categorizador.

Dentro do diretório classificacao, criaremos um novo arquivo chamado embeddings.py. A função desse arquivo será gerar os embeddings para as entradas de texto que utilizarmos na ferramenta, abrangendo tanto os embeddings das categorias quanto dos produtos que desejamos categorizar.

• categorizador
  • classificacao
    • __init__.py
    • embeddings.py

O código do arquivo embeddings.py será similar ao que desenvolvemos no vídeo anterior. Iniciaremos importando as bibliotecas necessárias, como boto3 e json:

embeddings.py

import boto3
import json

Para enviar uma requisição ao modelo no Bedrock, precisamos de um cliente do Bedrock especificando a região. Copiamos o trecho do código anterior e colamos na linha 4 do nosso novo módulo embeddings.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

Salvamos o progresso com "Ctrl + S".

Não especificaremos diretamente no código, pois a proposta é criar uma ferramenta que permita à pessoa usuária inserir uma entrada de forma dinâmica. Dessa maneira, a entrada não será fixa no código, possibilitando maior flexibilidade e personalização.

Então, criaremos uma função para cuidar da geração dos embeddings dentro desse módulo. A função se chamará generate_embedding e terá como parâmetro de entrada um texto, que será enviado ao modelo "Titan Embeddings G1 - Text". A função retornará a representação vetorial da entrada de texto.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

def generate_embedding(text):
    response = client.invoke_model(
        body=json.dumps({"inputText": text}),
        modelId="amazon.titan-embed-text-v1",
        accept="application/json",
        contentType="application/json",
    )

Dentro da função, invocaremos o modelo e enviaremos o corpo da requisição, que incluirá o inputText (texto a ser convertido em vetor). Em modelId, especificaremos o modelo a ser utilizado, bem como o formato da requisição e da resposta.

Por fim, converteremos a resposta em um dicionário Python e o retornaremos quando a função for chamada.

import boto3
import json

client = boto3.client(service_name="bedrock-runtime", region_name="us-east-1")

def generate_embedding(text):
    response = client.invoke_model(
        body=json.dumps({"inputText": text}),
        modelId="amazon.titan-embed-text-v1",
        accept="application/json",
        contentType="application/json",
    )
    response_body = json.loads(response.get("body").read())
    return response_body.get("embedding")

Teclamos "Ctrl + S" para salvar.

Com isso, o módulo embeddings estará preparado para ser utilizado, tanto para gerar o vetor que representa as categorias quanto para representar cada um dos produtos.

Criando o subdiretório categories

Criaremos um novo módulo dentro do subdiretório classificacao, chamado categories ("categorias").

• classificacao
  • __init__.py
  • embeddings.py
  • categories.py

Nesse módulo, começaremos importando a função que definimos no módulo embeddings. Isso porque dentro desse arquivo definiremos as categorias de produtos.

Em vez de listar de forma exaustiva, optaremos por estabelecer quatro categorias simples, com o intuito de demonstrar como utilizar a IA para criar uma ferramenta útil no dia a dia do time de publicação.

Inseriremos a importação da função generate_embedding e, em seguida, definiremos as categorias com uma breve descrição de cada uma usando o category_descriptions:

categories.py

from .embeddings import generate_embedding

category_descriptions = {
    "esporte": "Roupas confortáveis e respiráveis para atividades físicas. Itens adotados em práticas esportivas.",
    "formal": "Vestuário elegante para ocasiões formais e de negócios.",
    "casual": "Roupas confortáveis e descontraídas para o dia a dia.",
    "Frio": "Roupas quentes para invernos e dias frios, mantendo o corpo aquecido."
}

Essa etapa é fundamental, pois ao converter a categoria para uma representação vetorial, teremos características semânticas adicionais que permitem uma classificação mais precisa dos produtos.

Isso ocorre porque, se o texto de entrada for apenas "calça jeans" e tivermos como categorias apenas "esporte", "formal", "casual" e "fino", dispomos de informações limitadas sobre cada uma delas.

Nesse caso, é possível que a calça jeans seja equivocadamente categorizada como pertencente à categoria "esporte", o que não faz muito sentido. Ao descrever as categorias de forma mais detalhada, como "roupas confortáveis e respiráveis para atividades físicas" para a categoria de esporte, evitamos essas confusões e garantimos uma classificação mais precisa.

Após definir as categorias, geraremos os vetores que representam cada uma delas, utilizando a função de embeddings que definimos no módulo anterior denominado de category_embeddings.

from .embeddings import generate_embedding

category_descriptions = {
    "esporte": "Roupas confortáveis e respiráveis para atividades físicas. Itens adotados em práticas esportivas.",
    "formal": "Vestuário elegante para ocasiões formais e de negócios.",
    "casual": "Roupas confortáveis e descontraídas para o dia a dia.",
    "Frio": "Roupas quentes para invernos e dias frios, mantendo o corpo aquecido."
}

category_embeddings = {
    category: generate_embedding(description)
    for category, description in category_descriptions.items()
}

Usaremos um laço for para iterar sobre as categorias e gerar os embeddings.

Próximo passo

Com as categorias definidas e os embeddings gerados, precisamos de um arquivo main dentro do categorizador, onde a pessoa usuária poderá categorizar um produto, como um short de praia.

O que acontecerá é que geraremos um vetor que representa o short de praia e teremos vetores que representam cada uma das categorias. Precisamos de um módulo dentro de classificacao que faça a análise desses vetores para identificar com qual categoria o short de praia se assemelha mais: formal, casual, frio ou esporte. Analisaremos como construir esse módulo na sequência!

Sobre o curso Amazon Bedrock e Python: crie ferramentas de categorização e explore modelos customizados de IA

O curso Amazon Bedrock e Python: crie ferramentas de categorização e explore modelos customizados de IA possui 129 minutos de vídeos, em um total de 50 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Representando textos com embeddings
• Usando bases de conhecimento
• Criando Web Service Inteligente
• Personalizando modelos de IA
• Comparando imagens