Implemente a fragmentação agêntica para otimizar as entradas de LLMs com o LangChain e o watsonx.ai

Autor

Shalini Harkar

Lead AI Advocate

O que é fragmentação agêntica?

A forma como os modelos de linguagem processam e segmentam o texto está mudando da abordagem estática tradicional para um processo melhor e mais responsivo. Ao contrário da fragmentação de tamanho fixo tradicional, que divide documentos grandes em pontos fixos, a fragmentação agêntica emprega técnicas baseadas em IA para analisar o conteúdo em um processo dinâmico e determinar a melhor maneira de segmentar o texto.

A fragmentação agentes faz uso de métodos de divisão de texto baseados em IA, fragmentos recursivos e métodos de sobreposição de blocos, que funcionam simultaneamente para aprimorar a capacidade de fragmentação, preservando vínculos entre ideias notáveis e otimizando janelas contextuais em tempo real. Com a fragmentação agêntica, cada fragmento é enriquecido com metadados para aumentar a precisão da recuperação e a eficiência geral do modelo. Isso é particularmente importante em aplicações de RAG , onde a segmentação de dados pode afetar diretamente a qualidade da recuperação e a coerência da resposta. O contexto significativo é preservado em todos os fragmentos menores, tornando essa abordagem incrivelmente importante para chatbots, bases de conhecimento e casos de uso de IA generativa (IA gen). Frameworks como Langchain ou LlamaIndex melhoram ainda mais a eficiência da recuperação, tornando esse método altamente eficaz. 

Principais elementos da fragmentação agêntica

1. Estratégia de fragmentação adaptativa: escolha dinamicamente o melhor método de fragmentação com base no tipo de conteúdo, na intenção por trás da consulta e nas necessidades de recuperação para garantir uma segmentação eficaz.

2. Dimensionamento dinâmico de fragmentos: modifique o tamanho dos fragmentos em tempo real considerando a estrutura semântica e o contexto, em vez de se ater a limites fixos de tokens.

3. Sobreposição com preservação de contexto: avalie de forma inteligente a sobreposição entre fragmentos para manter a coerência intacta e evitar a perda de informações essenciais, melhorando, assim, a eficiência da recuperação.

 

As mais recentes tendências em IA, trazidas a você por especialistas

Receba insights selecionados sobre as notícias mais importantes (e intrigantes) sobre IA. Inscreva-se no nosso boletim informativo semanal Think. Consulte a Declaração de privacidade da IBM.

Agradecemos a você! Você se inscreveu.

Sua assinatura será entregue em inglês. Você encontrará um link para cancelar a assinatura em cada boletim informativo. Você pode gerenciar suas assinaturas ou cancelar a assinatura aqui. Consulte nossa Declaração de privacidade da IBM para obter mais informações.

Vantagens da fragmentação agêntica em relação aos métodos tradicionais

A fragmentação agêntica oferece vantagens sobre a fragmentação tradicional:

a. Retém o contexto: mantém informações cruciais sem interrupções desnecessárias.

b. Dimensionamento inteligente: ajusta os limites dos fragmentos de acordo com o significado e a relevância.

c. Otimizada para consultas: refina continuamente fragmentos para corresponder a consultas específicas.

d. Recuperação eficiente: melhora a produção dos sistemas de pesquisa e RAG, minimizando a fragmentação desnecessária.

 

Neste tutorial, você vai experimentar a estratégia de fragmentação agêntica usando o modelo IBM Granite-3,0-8B-Instruct, agora disponível no watsonx.ai. O objetivo geral é realizar uma fragmentação eficiente para implementar a RAG de maneira eficaz.

Pré-requisitos

Você precisa de uma conta do IBM Cloud para criar um projeto do watsonx.ai .

Etapas

Etapa 1. Configure seu ambiente

Embora você possa escolher entre várias ferramentas, este tutorial explica como configurar uma conta da IBM para usar um Jupyter Notebook.

  1. Faça login no watsonx.ai usando sua conta do IBM Cloud.

  2. Crie um projeto do watsonx.ai.
    Você pode obter a ID do projeto a partir de seu projeto. Clique na guia Gerenciar . Em seguida, copie a ID do projeto da seção Detalhes da página Geral . Você precisa dessa ID para este tutorial.

  3. Crie um Jupyter Notebook.

Essa etapa abreá um ambiente do Notebook onde você poderá copiar o código deste tutorial. Ou então, você pode baixar esse Notebook em seu sistema local e carregá-lo como um ativo em seu projeto do watsonx.ai. Para ver mais tutoriais do Granite, consulte a Comunidade IBM Granite. Este Jupyter Notebook , juntamente com os conjuntos de dados utilizados, pode ser encontrado no GitHub.

Etapa 2. Configure uma instância do watsonx.ai Runtime e uma chave de API

  1. Crie uma instância do serviço do watsonx.ai Runtime (tempo de execução) (selecione a região apropriada e escolha o plano Lite, que é uma instância gratuita).

  2. Gere uma chave de API.

  3. Associe a instância do serviço do watsonx.ai Runtime ao projeto que você criou no watsonx.ai.

Etapa 3. Instale e importe bibliotecas relevantes e configure suas credenciais

Você precisará de algumas bibliotecas e módulos para este tutorial. Certifique-se de importar os seguintes e, se não estiverem instalados, uma instalação rápida de pip resolve o problema.

Observe que este tutorial foi criado usando o Python 3.12.7.

!pip install -q langchain langchain-ibm langchain_experimental langchain-text-splitters langchain_chroma transformers bs4 langchain_huggingface sentence-transformers
import getpass
import requests
from bs4 import BeautifulSoup
from langchain_ibm import WatsonxLLM
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.document_loaders import WebBaseLoader
from langchain.schema import SystemMessage, HumanMessage
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.prompts import ChatPromptTemplate
from langchain.vectorstores import Chroma
from langchain.tools import tool
from langchain.agents import AgentExecutor
from langchain.memory import ConversationBufferMemory
from transformers import AutoTokenizer
from ibm_watsonx_ai.foundation_models.utils.enums import EmbeddingTypes
from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.schema import Document
from langchain.chains.combine_documents import create_stuff_documents_chain



 

Para definir nossas credenciais, precisamos do "WATSONX_APIKEY" e do "WATSONX_PROJECT_ID". Também definiremos a URL como o endpoint da API.

load_dotenv(os.getcwd()+"/.env", override=True)
credentials = {
    "url": "https://us-south.ml.cloud.ibm.com",
    "apikey": os.getenv("WATSONX_APIKEY", ""),
}
project_id = os.getenv("PROJECT_ID", "")

Etapa 4. Inicialize seu modelo de linguagem. 

Para este tutorial, sugerimos o uso do modelo Granite-3.0-8B-Instruct da IBM como o LLM para alcançar resultados semelhantes. Você é livre para usar qualquer modelo de IA de sua escolha. Os modelos de base disponíveis no watsonx podem ser encontrados aqui

llm = WatsonxLLM(
    model_id="ibm/granite-3-8b-instruct",
    url=credentials.get("url"),
    apikey=credentials.get("apikey"),
    project_id=project_id,
    params={
        GenParams.DECODING_METHOD: "greedy",
        GenParams.TEMPERATURE: 0,
        GenParams.MIN_NEW_TOKENS: 5,
        GenParams.MAX_NEW_TOKENS: 250,
        GenParams.STOP_SEQUENCES: ["Human:", "Observation"],
    },
)

 Etapa 5. Carregue seu documento

Essa função extrai o conteúdo do texto da página de explicação da IBM sobre aprendizado de máquina. Essa função remove elementos HTML indesejados (scripts, estilos) e retorna um texto limpo e legível.

def get_text_from_url(url):
    response = requests.get(url)
    if response.status_code != 200:
        raise ValueError(f"Failed to fetch the page, status code: {response.status_code}")
    soup = BeautifulSoup(response.text, "html.parser")
    for script in soup(["script", "style"]):
        script.decompose()
    return soup.get_text(separator="\n", strip=True)
url = "https://www.ibm.com/br-pt/think/topics/machine-learning"
web_text = get_text_from_url(url)
web_text

Em vez de usar um método de fragmentação de comprimento fixo, usamos um LLM para dividir o texto com base no significado. Essa função aproveita um LLM para dividir de forma inteligente o texto em fragmentos com significado semântico com base em tópicos.

def agentic_chunking(text):
    """
    Dynamically splits text into meaningful chunks using LLM.
    """
    system_message = SystemMessage(content="You are an AI assistant helping to split text into meaningful chunks based on topics.")
    
    human_message = HumanMessage(content=f"Please divide the following text into semantically different, separate and meaningful chunks:\n\n{text}")

    response = llm.invoke([system_message, human_message]) # LLM returns a string
    return response.split("\n\n") # Split based on meaningful sections
chunks = agentic_chunking(web_text)
chunks

Vamos imprimir os fragmentos para entender melhor sua estrutura de saída.

for i, chunk in enumerate(chunks,1):
    print(f"Chunk {i}:\n{chunk}\n{'-'*40}")

Ótimo! Os fragmentos foram criados com sucesso pelos agentes na produção.

Etapa 6: Crie um armazenamento de vetores

Agora que já experimentamos a fragmentação agêntica no texto, vamos migrar com nossa implementação de RAG.

Para este tutorial, escolhemos os fragmentos produzidos pelos agentes e os convertemos em embeddings. Um armazenamento de vetores de código aberto que podemos usar é o Chroma DB. Podemos acessar facilmente a funcionalidade Chroma por meio do pacote langchain_chroma . Vamos inicializar nosso banco de dados de vetores Chroma, dotá-lo com nosso modelo de embeddings e adicionar nossos documentos produzidos por fragmentação agêntica.

embeddings_model = HuggingFaceEmbeddings(model_name="ibm-granite/granite-embedding-30m-english")
 

Crie um banco de dados de vetores Chroma

vector_db = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings_model
)

Converta cada fragmento de texto em um objeto de documento

documents = [Document(page_content=chunk) for chunk in chunks]

Adicione os documentos ao banco de dados de vetores.

vector_db.add_documents(documents)

Etapa 7: estruture o modelo de prompts

Agora, podemos criar um modelo de prompts para nosso LLM. Esse modelo garante que possamos fazer várias perguntas enquanto mantemos uma estrutura de prompts consistente. Além disso, podemos integrar nosso armazenamento de vetores como o recuperador, finalizando o framework de RAG.

prompt_template = """<|start_of_role|>user<|end_of_role|>Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
{context}
Question: {input}<|end_of_text|>
<|start_of_role|>assistant<|end_of_role|>"""
qa_chain_prompt = PromptTemplate.from_template(prompt_template)
combine_docs_chain = create_stuff_documents_chain(llm, qa_chain_prompt)
rag_chain = create_retrieval_chain(vector_db.as_retriever(), combine_docs_chain)

Etapa 8: solicite a cadeia de RAG

Com essas partes do agente no fluxo de trabalho de RAG, vamos iniciar uma consulta do usuário. Primeiro, podemos informar estrategicamente o modelo sem qualquer contexto adicional do armazenamento de vetores que construímos para testar se o modelo está usando seu conhecimento integrado ou realmente usando o contexto de RAG. Usando a explicação de aprendizado de máquina da IBM, vamos fazer a pergunta agora.

output = llm.invoke("What is Model optimization process")
output

Claramente, o modelo não foi treinado com informações sobre o processo de otimização de modelos e, sem ferramentas ou informações externas, ele não pode nos fornecer as informações corretas. O modelo está alucinando. Agora, vamos tentar fornecer a mesma consulta à cadeia de RAG com os fragmentos de agentes que construímos.

rag_output = rag_chain.invoke({"input": "What is Model optimization process?"})
rag_output['answer']

Ótimo! O modelo Granite usou corretamente os fragmentos de RAG agêntica como contexto para nos fornecer informações corretas sobre o processo de otimização de modelos, ao mesmo tempo em que preservou a coerência semântica.

Resumo

Neste tutorial, geramos partes menores de informações relevantes usando agentes de IA no processo de fragmentação e construímos um pipeline de geração aumentada de recuperação (RAG).

Esse método melhora a recuperação de informações e a otimização da janela de contexto usando inteligência artificial e processamento de linguagem natural (NLP). Ele simplifica os fragmentos de dados para melhorar a eficiência da recuperação ao utilizar grandes modelos de linguagem (LLMs), como os modelos GPT da OpenAI, para obter melhores resultados.

Soluções relacionadas
Desenvolvimento de agentes de IA da IBM 

Permita que desenvolvedores criem, implementem e monitorem agentes de IA com o IBM watsonx.ai studio.

Explore o watsonx.ai
Agentes de IA e assistentes da IBM

Atinja uma produtividade revolucionária com um dos conjuntos de recursos mais abrangentes do setor para ajudar as empresas a criar, personalizar e gerenciar agentes e assistentes de IA. 

Explore agentes de IA
IBM Granite

Tenha mais de 90% de economia de custos com os modelos menores e abertos do Granite, projetados para a eficiência do desenvolvedor. Esses modelos prontos para uso corporativo oferecem desempenho excepcional em relação aos benchmarks de segurança e em uma ampla variedade de tarefas corporativas, da cibersegurança a RAG.

Explore Granite
Dê o próximo passo

Automatize seus fluxos de trabalho complexos e crie uma produtividade revolucionária com um dos conjuntos de recursos mais abrangentes do setor para ajudar empresas a construir, personalizar e fazer o gerenciamento de agentes e assistentes de IA. 

Explore o desenvolvimento de agentes no watsonx.ai Conheça o watsonx Orchestrate