Packaging & Context Handling (PT)

From Systems analysis Wiki
Jump to navigation Jump to search

Packaging & Context Handling — é um conjunto de técnicas para seleção, compressão, organização e fornecimento de fragmentos de conhecimento extraídos para o contexto de LLMs como parte da Geração Aumentada por Recuperação (RAG). O objetivo é maximizar a utilidade de um orçamento de tokens limitado, aumentar a precisão e a robustez das respostas e garantir a citação rastreável das fontes. Por "empacotamento" (packaging) entende-se não apenas a formação de uma lista de fragmentos, mas também sua compressão, ordenação, agrupamento e as instruções para o modelo, incluindo as estratégias stuff, map‑reduce, refine e tree‑of‑chunks.[1][2]

Definição e Motivação

Em sistemas RAG, a qualidade da resposta final é determinada não apenas pela recuperação (retrieval), mas também por como os fragmentos selecionados são inseridos no prompt. As limitações de contexto e o custo dos tokens forçam um equilíbrio entre completude e precisão: fragmentos desnecessários aumentam o risco de "se perder no meio" (lost‑in‑the‑middle) e aumentam a latência, enquanto uma filtragem/compressão agressiva pode remover evidências cruciais.[3] No RAG clássico, as fontes servem como uma "memória não paramétrica" externa, garantindo atualidade e citabilidade, desde que o empacotamento permita que o LLM opere de forma confiável com fatos e referências.[1]

Chunking e Extração de Conteúdo

A política de segmentação (chunking) define o tamanho/sobreposição dos chunks, a normalização e a granularidade (document→passage→sentence). Abordagens típicas incluem:

  • Regra de tamanho fixo (por caracteres/tokens) com sobreposição para manter a coesão entre os chunks;[4][5]
  • Chunking semântico (limites baseados na proximidade dos embeddings), que reduz as "quebras de sentido".[6]
  • Sentence‑window retrieval — inicialmente, as sentenças são indexadas; durante a recuperação, são extraídas as sentenças relevantes com uma janela de sentenças vizinhas (antes/depois) para restaurar o contexto local.[7]
  • Indexação em nível de passagem (Passage‑level) — a divisão da Wikipédia em passagens de aproximadamente 100 palavras tornou-se um padrão em QA de domínio aberto (DPR), o que reflete a utilidade de uma granularidade fina nos estágios iniciais.[8]
  • Normalização e limpeza (remoção de lixo, cabeçalhos/rodapés, unificação de espaços), rastreamento de fontes/páginas/deslocamentos em nível de metadados para rastreabilidade.[9]
  • Desduplicação de chunks candidatos (exatos e near‑duplicate): shingles + MinHash/LSH para reduzir repetições.[10]

Diversificação e Seleção (MMR e outros)

Ao formar o conjunto de contexto, são necessárias alta relevância e baixa redundância. A função clássica de Relevância Marginal Máxima (Maximal Marginal Relevance) seleciona o próximo fragmento levando em conta sua proximidade com a consulta e a maior similaridade com os já selecionados (penalidade por duplicatas):

MMR(di)=arg⁡maxdi∈D∖S[λ⋅sim(q,di)−(1−λ)⋅maxdj∈Ssim(di,dj)], λ∈[0,1].[11]

A combinação de sinais: recuperação híbrida (BM25 + dense) → fusão (por exemplo, Reciprocal Rank Fusion, RRF) → reclassificação com cross‑encoder/ColBERT:

  • RRF: um esquema simples e eficaz, não supervisionado, para fundir classificações de diferentes recuperadores.[12]
  • Reclassificadores cross‑encoder (BERT/MonoT5/APIs comerciais modernas) aumentam significativamente a precisão do top‑k, mas adicionam latência.[13][14]
  • Recuperador multivetor ColBERT (late interaction) frequentemente serve como um reclassificador/recuperador de primeiro nível eficaz em grandes corpus.[15]
  • Busca híbrida (BM25F+vetor) é implementada em motores e bibliotecas industriais com peso/fusão configuráveis (alfa, RRF, etc.).[16][17]

Compressão de Contexto

A redução do volume de contexto sem perda de fatos é crucial para o custo e a latência:

  • Compressão extrativa (extração de sentenças/frases-chave); sumarização abstrativa (refraseamento/condensação). Uma perspectiva clássica é a de Nenkova & McKeown.[18]
  • Compressão guiada por consulta/instrução (Query‑guided / instruction‑guided): sumarização orientada à consulta/tarefa (destacando evidências e removendo o que for irrelevante).
  • Compressão de prompt/contexto por meio de filtragem/poda de tokens via LLM (ex., LLMLingua/LLMLingua‑2) reduz o orçamento de tokens com pouca perda de qualidade, mas requer uma validação cuidadosa da faithfulness (fidelidade).[19]
  • A compressão é um compromisso qualidade↔custo↔latência: uma compressão agressiva aumenta o risco de omitir nuances/premissas e piora a atribuição de fatos.[20]

Estratégias de Empacotamento (stuff/map‑reduce/refine/tree)

Abaixo estão quatro esquemas básicos para organizar as fontes no prompt e cenários típicos de sua aplicação (veja também a tabela de comparação).

Stuff (alimentação direta)
Concatenar os fragmentos selecionados (após possível compressão) e fornecê-los inteiramente. Simples e rápido, mas limitado em volume e suscetível ao efeito lost‑in‑the‑middle em entradas longas.[2]
Map‑Reduce
Na etapa map, responder/sumarizar localmente para cada fragmento/documento, e em seguida, reduce agrega os resultados (comparação, votação, fusão). Escala bem com o número de fontes, reduzindo a carga em um único prompt; risco de perder conexões cruzadas entre fontes com uma agregação ingênua.[2][21]
Refine
Melhoria sequencial: uma resposta inicial é gerada com o primeiro fragmento, e depois é iterativamente refinada considerando o próximo fragmento (adicionando/corrigindo). Útil quando a ordem das fontes é importante; risco de "ficar preso" em erros iniciais e acumular distorções.[22]
Tree‑of‑chunks
Compressão/resumo hierárquico: resumos locais por chunks → consolidações em nível de seção → resumo final. Útil para documentos longos; requer a passagem cuidadosa de identificadores de fontes entre os níveis para uma atribuição correta.[23]
Comparação das estratégias de empacotamento
Estratégia Ideia Custo/Latência Risco de perda de contexto Quando aplicar Fontes
Stuff Todos os fragmentos de uma vez em um único prompt Baixo (até o limite de contexto) Alto em entradas longas (lost‑in‑the‑middle) Volume pequeno, perguntas simples [2][3]
Map‑Reduce Respostas locais → agregação Médio/Alto (muitas chamadas) Médio (depende da qualidade do reduce) Muitas fontes, necessidade de escalabilidade [2][21]
Refine Melhoria sequencial da resposta Médio Dependência da ordem, risco de fixação de erros Quando a ordem/evolução da resposta é importante [22]
Tree‑of‑chunks Resumos hierárquicos Médio/Alto Perda de detalhes nos níveis superiores Documentos/coleções longas [23]

Ordem e Posicionamento das Fontes

Os LLMs utilizam menos eficientemente as informações do meio de um contexto longo; fatos úteis devem ser posicionados no início/fim, agrupados por tópico/fonte e marcados com títulos e IDs. A reclassificação que leva em conta a importância query‑aware e a diversificação ajuda a mover os fragmentos-chave para mais perto do início.[3][13]

Integração no Pipeline RAG (fusion → rerank → packaging)

Um pipeline típico de múltiplos estágios: hybrid retrieval (BM25 + dense) → fusion (RRF/mistura ponderada) → rerank (Cross‑Encoder/ColBERT) → packaging (uma das estratégias) → geração + citação. A busca híbrida e o RRF são robustos à incomparabilidade das pontuações de diferentes recuperadores; o cross‑encoder aumenta a precisão da entrada para o LLM, economizando tokens.[16][12][14][15]

Avaliação de Qualidade e Ablações

A avaliação é realizada nos níveis de recuperação, empacotamento e geração:

  • Recuperação: Recall@k, nDCG@k, MRR — métricas padrão de RI.[24]
  • Faithfulness/groundedness: proporção de afirmações apoiadas por citações; frameworks automáticos (RAGAS, TruLens) + validação manual da atribuição.[25][26][27]
  • End‑to‑end QA: EM/F1/ROUGE dependendo da tarefa/dataset (NQ/HotpotQA, etc.).[1]
  • Eficiência: latência p50/p95, número de tokens, custo em $; comparação de estratégias de empacotamento e níveis de compressão em termos de qualidade↔custo.
  • Ablações: desativar MMR/desduplicação/compressão/alterar a ordem para medir a contribuição de cada componente (em 2025‑09‑10, a prática de pesquisa em RAG recomenda registrar claramente k, λ, tamanhos de chunk e limites de tokens).[28]

Recomendações Práticas e Checklist

  • k e diversificação: comece com k=20–40 candidatos da recuperação híbrida; aplique MMR com λ≈0.5–0.8; penalize rigorosamente duplicatas por URL/ID/hash de texto.[11][16]
  • Chunking: 200–400 tokens com 10–20% de sobreposição (overlap) para chunking de tamanho fixo; para documentos técnico-jurídicos, o esquema de sentence/window costuma ser mais útil.[4][7]
  • Compressão: use filtragem extrativa baseada na consulta e abstração com cautela; métodos como LLMLingua devem ser ajustados (aumentados/diminuídos) com base na faithfulness em seus dados (validação A/B obrigatória).[19][27]
  • Ordem: fragmentos importantes/de alta confiança no início do prompt; agrupe por fonte/tópico, marcando explicitamente IDs e títulos; considere o efeito lost‑in‑the‑middle (duplicar um fato-chave no início e no fim pode ajudar).[3]
  • Rerank: se o orçamento permitir, adicione um Cross‑Encoder/ColBERT no top‑k (k≈50–200) antes do empacotamento — isso economiza tokens de geração e aumenta a precisão.[13][15]
  • Estratégias de fallback: (1) falta de fatos → solicitar fontes adicionais; (2) exceder o limite de tokens → mudar de stuff→refine ou ativar a compressão; (3) baixa confiança/contradições → responder com uma recusa e uma lista explícita dos IDs ausentes (veja o template abaixo).

Pseudocódigo do pipeline de empacotamento

# Entrada: consulta q
cands = retrieve(q, K_sparse, K_dense)          # busca BM25, DPR etc.
cands = diversify_MMR(cands, lambda=0.7)        # diversificação (MMR)
snips = compress(query=q, items=cands, mode="extractive|abstractive", budget=tokens)
pkg   = package(snips, strategy="stuff|map_reduce|refine|tree")
resp  = generate(prompt=build_prompt(q, pkg), citations=True)  # LLM com citações

Esqueleto de template de prompt (fragmento)

[CONSULTA DO USUÁRIO]
{q}

[FONTES]
{# Cada fragmento com ID, título e link #}
- [{id}] {title} — {url}
{content_snippet}

[REQUISITOS]
1) Use apenas fatos das fontes, referenciando-os por [ID].
2) Se os dados não forem suficientes, informe e peça esclarecimentos/fontes adicionais.
3) Mantenha a estrutura da resposta e liste os [ID]s utilizados.

Limitações e Questões Abertas

  • Alucinações e agregação em map‑reduce/refine: resumos abstrativos podem introduzir novos fatos; são cruciais instruções claras sobre atribuição e mecanismos de verificação de citações.[20][27]
  • Perda de detalhes com compressão agressiva/hierárquica; é importante manter links de volta para a fonte original/página/deslocamento.
  • Portabilidade de domínio de recuperadores/reclassificadores e compressores; requer adaptação/ajuste fino em corpus de domínio.[28]
  • Privacidade/PII e memorização de LLMs: durante a geração sem um grounding estrito, pode ocorrer o vazamento de strings privadas; aplique filtros, repositórios privados e uma política de recusa.[29][30]
  • "Empacotadores" treináveis, ordem/disposição adaptativa, RLHF/loops de feedback para aumentar a faithfulness, contexto multilíngue e ultralongo — são áreas de pesquisa ativas.[28][3]

Ligações externas

  • LangChain: Summarization (stuff/map_reduce/refine). [29]
  • LangChain: Text splitters. [30]
  • LlamaIndex: Response Synthesizers (refine/tree). [31]
  • LlamaIndex: Node Parsers / SentenceSplitter / SemanticSplitter. [32]
  • Haystack: SentenceWindowRetriever. [33]
  • Haystack: PreProcessors / DocumentSplitter. [34]
  • Weaviate: Hybrid search. [35]
  • Pinecone: Hybrid search. [36]
  • Cohere: Rerank API. [37]
  • RAGAS (repo/docs). [38] [39]
  • TruLens (docs). [40]

Literatura

  • Manning, C. D., Raghavan, P., Schütze, H. (2008). Introduction to Information Retrieval. Cambridge University Press. ISBN 978‑0521865715.
  • Nenkova, A., McKeown, K. (2011). Automatic Summarization. FnT IR, 5(2–3), 103–233. DOI:10.1561/1500000015.
  • Lewis, P., et al. (2020). Retrieval‑Augmented Generation for Knowledge‑Intensive NLP Tasks. NeurIPS. arXiv:2005.11401.
  • Khattab, O., Zaharia, M. (2020). ColBERT. SIGIR’20. DOI:10.1145/3397271.3401075.
  • Izacard, G., Grave, E. (2021). Fusion‑in‑Decoder. EACL. arXiv:2007.01282.
  • Ji, Z., et al. (2023). Survey of Hallucination in NLG. ACM CS. DOI:10.1145/3571730.
  • Gao, S., et al. (2024). RAG for LLM: A Survey. arXiv:2312.10997.

Notas

  1. ↑ 1.0 1.1 1.2 Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., et al. (2020). Retrieval‑Augmented Generation for Knowledge‑Intensive NLP Tasks. NeurIPS. arXiv:2005.11401. [1]
  2. ↑ 2.0 2.1 2.2 2.3 2.4 LangChain Docs. Summarization (stuff/map_reduce/refine/map_rerank). (acesso: 2025‑09‑10). [2]
  3. ↑ 3.0 3.1 3.2 3.3 3.4 Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., Liang, P. (2024). Lost in the Middle: How Language Models Use Long Contexts. TACL. arXiv:2307.03172. [3]
  4. ↑ 4.0 4.1 LangChain Docs. Text splitters (RecursiveCharacter/TokenTextSplitter). (acesso: 2025‑09‑10). [4]
  5. ↑ LlamaIndex Docs. SentenceSplitter / TokenTextSplitter / SemanticSplitter. (acesso: 2025‑09‑10). [5] [6] [7]
  6. ↑ LlamaIndex Docs. SemanticSplitterNodeParser. (acesso: 2025‑09‑10). [8]
  7. ↑ 7.0 7.1 Haystack Docs. SentenceWindowRetriever. (acesso: 2025‑09‑10). [9]
  8. ↑ Karpukhin, V., Oguz, B., Min, S., Lewis, P., Wu, L., Edunov, S., Chen, D., Yih, W.‑T. (2020). Dense Passage Retrieval for Open‑Domain Question Answering. EMNLP. arXiv:2004.04906. [10]
  9. ↑ Haystack Docs. PreProcessors / DocumentSplitter. (acesso: 2025‑09‑10). [11] [12]
  10. ↑ Broder, A. Z. (1997). On the Resemblance and Containment of Documents. Compression and Complexity of Sequences. [13]
  11. ↑ 11.0 11.1 Carbonell, J., Goldstein, J. (1998). The Use of MMR, Diversity‑Based Reranking for Reordering Documents and Producing Summaries. SIGIR’98, pp. 335–336. DOI:10.1145/290941.291025.
  12. ↑ 12.0 12.1 Cormack, G. V., Clarke, C. L. A., Büttcher, S. (2009). Reciprocal Rank Fusion outperforms Condorcet and Individual Rank Learning Methods. SIGIR’09, pp. 758–759. DOI:10.1145/1571941.1572114. [14]
  13. ↑ 13.0 13.1 13.2 Nogueira, R., Cho, K. (2019). Passage Re‑ranking with BERT. arXiv:1901.04085. [15]
  14. ↑ 14.0 14.1 Cohere Docs. Rerank API overview. (acesso: 2025‑09‑10). [16]
  15. ↑ 15.0 15.1 15.2 Khattab, O., Zaharia, M. (2020). ColBERT: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT. SIGIR’20, pp. 39–48. DOI:10.1145/3397271.3401075. arXiv:2004.12832.
  16. ↑ 16.0 16.1 16.2 Weaviate Docs. Hybrid search (BM25F + vector). (acesso: 2025‑09‑10). [17]
  17. ↑ Pinecone Docs. Hybrid search. (acesso: 2025‑09‑10). [18]
  18. ↑ Nenkova, A., McKeown, K. (2011). Automatic Summarization. Foundations and Trends in Information Retrieval, 5(2–3), 103–233. DOI:10.1561/1500000015.
  19. ↑ 19.0 19.1 Zhu, Y., Shao, Z., Li, M., et al. (2023). LLMLingua: Compressing Prompts for Accelerating LLM Inference. arXiv:2310.05736. [19]
  20. ↑ 20.0 20.1 Ji, Z., Lee, N., Frieske, R., et al. (2023). Survey of Hallucination in Natural Language Generation. ACM Computing Surveys, 55(12), Art.248. DOI:10.1145/3571730.
  21. ↑ 21.0 21.1 Izacard, G., Grave, E. (2021). Leveraging Passage Retrieval with Generative Models for Open‑Domain QA (Fusion‑in‑Decoder). EACL. arXiv:2007.01282. [20]
  22. ↑ 22.0 22.1 LlamaIndex Docs. Response Synthesizers: refine. (acesso: 2025‑09‑10). [21]
  23. ↑ 23.0 23.1 LlamaIndex Docs. Tree Summarize. (acesso: 2025‑09‑10). [22]
  24. ↑ Manning, C. D., Raghavan, P., Schütze, H. (2008). Introduction to Information Retrieval. Cambridge Univ. Press. (ver capítulos sobre nDCG/MRR). [23]
  25. ↑ Es, S., et al. (2023). RAGAS: Automated Evaluation of Retrieval‑Augmented Generation. arXiv:2309.15217. [24]
  26. ↑ TruLens Docs. Evaluating RAG (groundedness, relevance). (acesso: 2025‑09‑10). [25]
  27. ↑ 27.0 27.1 27.2 Rashkin, H., Nakov, P., et al. (2023). Measuring Attribution in Natural Language Generation. Computational Linguistics, 49(4), 1207–1261. DOI:10.1162/coli_a_00486.
  28. ↑ 28.0 28.1 28.2 Gao, S., et al. (2024). Retrieval‑Augmented Generation for Large Language Models: A Survey. arXiv:2312.10997. [26]
  29. ↑ Carlini, N., Tramèr, F., et al. (2021). Extracting Training Data from Large Language Models. USENIX Security. [27]
  30. ↑ Shokri, R., Stronati, M., Song, C., Shmatikov, V. (2017). Membership Inference Attacks Against ML Models. IEEE S&P. [28]
Retrieved from "https://systems-analysis.info/int/index.php?title=Packaging_%26_Context_Handling_(PT)&oldid=5392"