AI Engineering Academy · Aula

Por que a divisão ingênua prejudica a recuperação

Analise falhas reais de recuperação causadas por uma divisão inadequada, incluindo respostas separadas entre os limites dos fragmentos e perda de contexto de cabeçalhos e títulos de seções.

Aula 1 de 413 etapas

Por que a divisão ingênua prejudica a recuperação é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.

O custo de uma segmentação inadequada

Segmentação é o processo de dividir documentos em partes menores antes de incorporá-los a um armazenamento vetorial. A forma como você segmenta determina qual contexto estará disponível durante a recuperação. Uma segmentação inadequada é uma das causas mais comuns e impactantes de falhas em sistemas RAG.

Respostas divididas entre limites

Imagine um documento que diga: 'A política de reembolso é de 30 dias a partir da compra. Os clientes devem incluir o recibo original.' Se um divisor de tamanho fixo cortar o texto depois de 'compra.', essas duas frases ficarão em trechos diferentes. Uma consulta sobre a política de reembolso poderá recuperar apenas a primeira metade — impedindo o modelo de mencionar a exigência do recibo.

Contexto perdido nos cabeçalhos

Os documentos costumam usar cabeçalhos de seção para fornecer significado. Considere uma tabela intitulada 'Preços dos planos empresariais', seguida por linhas de números. Se o cabeçalho e a tabela ficarem em trechos diferentes, o trecho recuperado da tabela conterá números sem identificação — e o modelo não conseguirá responder corretamente a 'Qual é o preço empresarial?'.

Problemas da segmentação de tamanho fixo

A segmentação de tamanho fixo divide o texto a cada N caracteres ou tokens, independentemente dos limites das frases. Ela é rápida e simples, mas frequentemente interrompe as frases no meio. Um trecho que termina com 'The model was trained on' e o trecho seguinte, que começa com 'a dataset of 500 billion tokens', não têm sentido isoladamente.

from langchain.text_splitter import CharacterTextSplitter

# Naive fixed-size: may break mid-sentence
splitter = CharacterTextSplitter(chunk_size=200, chunk_overlap=0)
chunks = splitter.split_text(document_text)
print(f'Created {len(chunks)} chunks')
print('First chunk:', chunks[0])

A sobreposição nem sempre ajuda

Uma correção comum é adicionar sobreposição entre trechos — repetindo os últimos N tokens de um trecho no início do próximo. Isso ajuda com frases divididas, mas introduz redundância e pode confundir os recuperadores quando dois trechos muito semelhantes são recuperados. A sobreposição é um paliativo, não uma solução para problemas estruturais de segmentação.

# Overlap helps partially but adds redundancy
splitter = CharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50  # last 50 chars repeated in next chunk
)
chunks = splitter.split_text(document_text)

Medindo a taxa de falhas de recuperação

Você pode medir com que frequência sua segmentação prejudica a recuperação criando um pequeno conjunto de avaliação de referência: uma lista de perguntas com passagens de origem corretas conhecidas. Depois, verifique com que frequência a passagem correta está entre os k principais trechos recuperados. Uma hit rate baixa geralmente revela problemas de segmentação antes mesmo de você analisar a qualidade da geração.

def hit_rate(queries_and_answers, retriever, k=5):
    hits = 0
    for query, expected_text in queries_and_answers:
        results = retriever.retrieve(query, k=k)
        retrieved_texts = [r.page_content for r in results]
        if any(expected_text in text for text in retrieved_texts):
            hits += 1
    return hits / len(queries_and_answers)

Problemas com código e dados estruturados

Arquivos de código, JSON e tabelas têm unidades lógicas — funções, objetos e linhas de tabela — que não devem ser divididas. Dividir a definição de uma função Python entre dois trechos significa que nenhum deles será compreensível de forma independente. Um recuperador que encontre o segundo trecho verá um código sem argumentos e sem contexto.

# Bad: splits code arbitrarily
bad_chunk_1 = 'def calculate_price(item, qty'  # incomplete!
bad_chunk_2 = ', discount):\n    return item.price * qty * (1 - discount)'

# Good: keep the full function together
good_chunk = 'def calculate_price(item, qty, discount):\n    return item.price * qty * (1 - discount)'

Documentos longos e perda do conteúdo central

Pesquisas sobre LLMs mostram o fenômeno de 'perda no meio': quando muitos trechos são recuperados e inseridos em um prompt, o modelo presta atenção ao conteúdo próximo do início e do fim, mas tende a ignorar o meio. Uma segmentação inadequada, que produz muitos trechos pequenos e de baixa qualidade, piora isso ao diluir o sinal relevante.

Diagnosticando trechos ruins manualmente

Um diagnóstico rápido é imprimir uma amostra aleatória dos seus trechos e lê-los. Pergunte a si mesmo: Este trecho é significativo isoladamente? Se um usuário fizesse uma pergunta, o modelo conseguiria respondê-la apenas com base neste trecho? Trechos que fazem referência a pronomes sem antecedente ('Ele disse que...'), código incompleto ou números sem contexto são sinais de alerta.

import random

def audit_chunks(chunks, sample_size=10):
    sample = random.sample(chunks, min(sample_size, len(chunks)))
    for i, chunk in enumerate(sample):
        print(f'--- Chunk {i+1} ({len(chunk)} chars) ---')
        print(chunk[:300])
        print()

Quando o tamanho do trecho é grande demais

Trechos muito grandes prejudicam a precisão da recuperação. Um trecho de 2.000 tokens sobre um tema amplo pode corresponder a muitas consultas, mas fornecer ruído demais ao LLM. O modelo precisa encontrar uma agulha no palheiro dentro desse trecho. Trechos menores e focados melhoram a precisão, mas podem deixar de incluir o contexto ao redor.

Estratégias que resolvem esses problemas

Alternativas melhores à segmentação ingênua de tamanho fixo incluem: divisão nos limites das frases, que nunca corta uma frase no meio; segmentação semântica, que divide o texto nos limites entre tópicos; segmentação pai-filho, que preserva um contexto mais amplo; e divisão consciente da estrutura do documento, que respeita funções de código, tags HTML e cabeçalhos Markdown. Cada lição a seguir aborda uma dessas estratégias.

Verificação rápida

Teste sua compreensão dos modos de falha da segmentação apresentados nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: a segmentação ingênua de tamanho fixo rompe os limites de frases e seções, a sobreposição é uma solução parcial, mas acrescenta redundância e a qualidade dos trechos determina diretamente a hit rate da recuperação. A seguir, exploraremos a segmentação semântica, que divide o texto nos limites naturais entre tópicos usando a similaridade das incorporações.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Por que a divisão ingênua prejudica a recuperação” é grátis?

Sim — o texto completo de “Por que a divisão ingênua prejudica a recuperação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.

O que vou aprender em “Por que a divisão ingênua prejudica a recuperação”?

Analise falhas reais de recuperação causadas por uma divisão inadequada, incluindo respostas separadas entre os limites dos fragmentos e perda de contexto de cabeçalhos e títulos de seções. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Engineering Academy?

Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Por que a divisão ingênua prejudica a recuperação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Engineering Academy?

Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Por que a divisão ingênua prejudica a recuperação
  2. Divisão semântica com similaridade de embeddings
  3. Recuperação pai-filho e do pequeno para o grande
  4. Estratégias específicas para código e HTML
← Voltar para AI Engineering Academy