Manual do
Engenheiro de LLM
Domine a arte da engenharia de grandes modelos de linguagem
PAUL IUSZTIN MAXIME LABONNE
Manual do Engenheiro de LLM
Sobre a imagem da capa Uma observação realizada pelo observatório SPHEREx (Espectrofotômetro para a História do Universo, Época da Reionização e Explorador de Gelos), da NASA, revela as assinaturas químicas de gelo de água (mostrado em azul brilhante) e de hidrocarbonetos aromáticos policíclicos (laranja) em Cygnus X, uma das regiões de formação estelar mais ativas e turbulentas da nossa galáxia, a Via Láctea. A imagem foi divulgada em 15 de abril de 2026, juntamente com um estudo detalhando a observação. Um dos principais objetivos do SPHEREx é mapear as assinaturas químicas de diferentes tipos de gelo interestelar. Esses gelos incluem moléculas como água, dióxido de carbono e monóxido de carbono, fundamentais para os processos químicos que permitem o surgimento da vida. Os pesquisadores acreditam que esses reservatórios de gelo, aderidos à superfície de minúsculos grãos de poeira, são os locais onde a maior parte da água do universo é formada e armazenada. A água dos oceanos da Terra – assim como os gelos presentes em cometas, planetas e luas de nossa galáxia – tem origem nessas regiões. Lançado em 11 de março de 2025, o SPHEREx possui a capacidade única de observar o céu em 102 cores, cada uma correspondente a um comprimento de onda diferente da luz infravermelha. Essas observações fornecem informações valiosas sobre galáxias, estrelas, regiões de formação planetária e outros fenômenos cósmicos. Fonte: NASA. Disponível em: https://www.nasa.gov/image-article/ nasas-spherex-observatory-maps-interstellar-ice-in-milky-way/
Manual do Engenheiro de LLM
Domine a arte da engenharia de grandes modelos de linguagem
Paul Iusztin Maxime Labonne
Manual do Engenheiro de LLM: domine a arte da engenharia de grandes modelos de linguagem Copyright © 2024 Packt Publishing © 2026 Paul Iusztin, Maxime Labonne Editora Edgard Blücher Ltda. Publisher Edgard Blücher Editor Eduardo Blücher Coordenação editorial Rafael Fulanetti Coordenação de produção Ana Cristina Garcia Produção editorial Juliana Midori Horie Diagramação Guilherme Salvador Revisão de texto Susane Schmieg Capa Equipe editorial Imagem da capa NASA/JPL-Caltech/IPAC/Hora et al.
Dados Internacionais de Catalogação na Publicação (CIP) Heytor Diniz Teixeira, CRB-8/10570 Iusztin, Paul Rua Pedroso Alvarenga, 1245, 4 o andar 04531-934 – São Paulo – SP – Brasil Tel.: 55 11 3078-5366
Manual do engenheiro de LLM : domine a arte da engenharia de grandes modelos de linguagem / Paul Iusztin, Maxime Labonne. – São Paulo : Blucher, 2026.
contato@blucher.com.br
470 p. : il.
www.blucher.com.br
Bibliografia ISBN 978-85-212-3347-3 (Impresso) ISBN 978-85-212-3345-9 (Eletrônico – Epub)
Segundo o Novo Acordo Ortográfico, conforme 6. ed.
ISBN 978-85-212-3343-5 (Eletrônico – PDF)
do Vocabulário Ortográfico da Língua Portuguesa, Academia Brasileira de Letras, julho de 2021.
Título original: LLM Engineer’s Handbook: Master the art of engineering large language models from concept to production
É proibida a reprodução total ou parcial por quaisquer
1. Inteligência artificial. 2. Computação. 3. Large language models (LLMs). 4. Grandes modelos de linguagem. I. Título. II. Labonne, Maxime.
meios sem autorização escrita da editora.
Todos os direitos reservados pela Editora Edgard Blücher Ltda.
CDU 004.8
Índice para catálogo sistemático: 1. Inteligência artificial CDU 004.8
Colaboradores
Sobre os autores Paul Iusztin é um engenheiro sênior de ML e MLOps com mais de sete anos de experiência desenvolvendo soluções de IA generativa, visão computacional e MLOps. Sua contribuição mais recente foi na Metaphysic, onde atuou como um de seus engenheiros principais ao levar grandes redes neurais para produção. Anteriormente, trabalhou na CoreAI, Everseen e Continental. É o fundador do Decoding ML, um canal educacional sobre ML em nível de produção que oferece posts, artigos e cursos de código aberto para ajudar outras pessoas a construir sistemas de ML do mundo real.
Maxime Labonne é Head de Pós-treinamento na Liquid AI. Possui um PhD. em ML pelo Polytechnic Institute of Paris e é reconhecido como Google Developer Expert em IA/ML. Como blogueiro ativo, realizou contribuições significativas para a comunidade de código aberto, incluindo o LLM Course no GitHub, ferramentas como LLM AutoEval e diversos modelos de última geração, como o NeuralDaredevil. É autor do livro best-seller Hands-On Graph Neural Networks Using Python, publicado pela Packt.
Quero agradecer à minha família e à minha companheira. Seu apoio inabalável e sua paciência tornaram este livro possível.
vi
Manual do engenheiro de LLM
Sobre o revisor Rany ElHousieny é um arquiteto de soluções de IA e gerente de engenharia de IA com mais de duas décadas de experiência em IA, NLP e ML. Ao longo de sua carreira, ele se concentrou no desenvolvimento e na implantação de modelos de IA, sendo autor de diversos artigos sobre arquitetura de sistemas de IA e implantação ética de IA. Ele liderou projetos inovadores em empresas como a Microsoft, onde impulsionou avanços em NLP e no Language Understanding Intelligent Service (LUIS). Atualmente, desempenha um papel fundamental na Clearwater Analytics, impulsionando a inovação em GenAI e em soluções financeiras e de gestão de investimentos impulsionadas por IA.
Gostaria de agradecer à Clearwater Analytics por proporcionar um ambiente de apoio e de aprendizado que promove crescimento e inovação. A visão de nossos líderes, sempre à frente com as tecnologias mais recentes, tem sido uma fonte constante de inspiração. Seu compromisso com os avanços em IA tornou minha experiência de revisar este livro esclarecedora e enriquecedora. Um agradecimento especial à minha família pelo incentivo contínuo ao longo desta jornada.
Textos introdutórios
Como meu cofundador na Hugging Face, Clement Delangue, e eu costumamos dizer, a IA está se tornando a forma padrão de desenvolver tecnologia. Nos últimos 3 anos, LLMs já tiveram um impacto profundo na tecnologia, e estão destinados a ter um impacto ainda maior nos próximos 5 anos. Eles estarão incorporados a cada vez mais produtos e, acredito, no centro de qualquer atividade humana baseada em conhecimento ou criatividade. Por exemplo, programadores já estão aproveitando LLMs e mudando a forma como trabalham, focando em pensamento e tarefas de ordem superior enquanto colaboram com máquinas. Músicos de estúdio contam com ferramentas impulsionadas por IA para acelerar a exploração do espaço da criatividade musical. Advogados estão ampliando seu impacto por meio da geração aumentada por recuperação (RAG) e grandes bases de dados de jurisprudência. Na Hugging Face, sempre defendemos um futuro em que não apenas uma empresa ou um pequeno número de cientistas controlem os modelos de IA usados pelo restante da população, mas sim um futuro em que o maior número possível de pessoas — dos perfis mais diversos possíveis — sejam capazes de aprofundar-se no modo como modelos de machine learning de ponta realmente funcionam. Maxime Labonne e Paul Iusztin foram fundamentais neste movimento para democratizar LLMs ao escrever este livro e garantir que o maior número possível de pessoas não apenas possa usá-los, mas também adaptá-los, realizar ajuste fino, quantizá-los e torná-los eficientes o suficiente para, de fato, implantá-los no mundo real. O trabalho deles é essencial, e fico feliz por estarem disponibilizando este recurso para a comunidade. Isso expande a casca convexa do conhecimento humano. Julien Chaumond Cofundador e CTO, Hugging Face
viii
Manual do engenheiro de LLM
Como alguém profundamente imerso no mundo de operações de aprendizado de máquina, estou entusiasmado em endossar Manual do Engenheiro de LLM. Este guia abrangente chega em um momento crucial, quando a demanda por especialização em LLMs está disparando em todos os setores. O que diferencia este livro é sua abordagem prática, de ponta a ponta. Ao conduzir os leitores pela criação de um LLM Twin, ele preenche a lacuna frequentemente assustadora entre teoria e aplicação no mundo real. Da engenharia de dados e do ajuste fino de modelos a tópicos avançados como pipelines de RAG e otimização de inferência, os autores não deixam nada de fora. Estou particularmente impressionado com a ênfase nos princípios de MLOps e LLMOps. À medida que as organizações dependem cada vez mais de LLMs, entender como construir sistemas escaláveis, reproduzíveis e robustos é primordial. A inclusão de estratégias de orquestração e integração com a nuvem demonstra o compromisso dos autores em capacitar os leitores com habilidades verdadeiramente prontas para produção. Se você é um profissional experiente de ML buscando se especializar em LLMs ou um engenheiro de software que deseja ingressar nesse campo empolgante, este manual oferece a combinação perfeita de conhecimento fundamental e técnicas de ponta. As explicações claras, os exemplos práticos e o foco nas melhores práticas fazem dele um recurso inestimável para qualquer pessoa séria em dominar a engenharia de LLM. Em uma era em que a IA está remodelando setores a uma velocidade vertiginosa, Manual do Engenheiro de LLM destaca-se como um guia essencial para navegar pelas complexidades dos modelos de linguagem de grande porte. Não é apenas um livro; é um roteiro para se tornar um engenheiro de LLM proficiente no cenário atual movido por IA. Hamza Tahir Cofundador e CTO, ZenML
Textos introdutórios
ix
O livro Manual do Engenheiro de LLM serve como um recurso inestimável para quem busca uma compreensão prática de LLMs. Por meio de exemplos práticos e de uma exploração abrangente do projeto LLM Twin, o autor desmistifica de forma eficaz as complexidades da construção e implantação de aplicações de LLM em nível de produção. Uma das características de destaque do livro é o uso do projeto LLM Twin como um exemplo contínuo. Este personagem de IA, projetado para emular o estilo de escrita de um indivíduo específico, fornece uma ilustração tangível de como LLMs podem ser aplicados em cenários do mundo real. O autor conduz habilmente os leitores pelas ferramentas e tecnologias essenciais necessárias para o desenvolvimento de LLMs, incluindo Hugging Face, ZenML, Comet, Opik, MongoDB e Qdrant. Cada ferramenta é explicada em detalhes, facilitando que os leitores entendam suas funções e como podem ser integradas a um pipeline de LLM. Manual do Engenheiro de LLM também aborda uma ampla gama de tópicos relacionados ao desenvolvimento de LLMs, como coleta de dados, ajuste fino, avaliação, otimização de inferência e MLOps. Notavelmente, os capítulos sobre ajuste fino supervisionado, alinhamento por preferência e geração aumentada por recuperação (RAG) fornecem insights aprofundados sobre esses aspectos críticos do desenvolvimento de LLMs. Um ponto forte particular deste livro está em seu foco na implementação prática. O autor se destaca em fornecer exemplos concretos e orientações sobre como otimizar pipelines de inferência e implantar LLMs de forma eficaz. Isso torna o livro um recurso valioso tanto para pesquisadores quanto para profissionais. Este livro é altamente recomendado para qualquer pessoa interessada em aprender sobre LLMs e suas aplicações práticas. Ao fornecer uma visão geral abrangente das ferramentas, técnicas e melhores práticas envolvidas no desenvolvimento de LLMs, os autores criaram um recurso valioso que, sem dúvida, será uma referência para muitos engenheiros de LLM. Antonio Gulli Diretor Sênior, Google
Sumário
Prefácio xxi
1 Entendendo o conceito e a arquitetura do LLM Twin
1
Compreendendo o conceito de LLM Twin
2
O que é um LLM Twin? Por que construir um LLM Twin é importante Por que não usar o ChatGPT (ou outro chatbot semelhante)?
Planejamento do MVP do produto LLM Twin O que é um MVP? Definindo o MVP do LLM Twin
2 3 4
6 6 7
Construindo sistemas de ML com pipelines de atributos/treinamento/ inferência 8 O problema com o desenvolvimento de sistemas de ML O problema com as soluções anteriores A solução – pipelines de ML para sistemas de aprendizado de máquina
8 10 12
O pipeline de características 13 O pipeline de treinamento 14 O pipeline de inferência 14 Benefícios da arquitetura FTI
14
xii
Manual do engenheiro de LLM
Projetando a arquitetura do sistema do LLM Twin Listando os detalhes técnicos da arquitetura do LLM Twin Como projetar a arquitetura do LLM Twin usando o design do pipeline de FTI
16 16 17
Pipeline de coleta de dados 18 Pipeline de características 19 Pipeline de treinamento 20 Pipeline de inferência 21 Considerações finais sobre o design do FTI e a arquitetura do LLM Twin
22
Resumo 23 Referências 23
2 Ferramentas e instalação
25
Ecossistema do Python e instalação do projeto
26
Poetry: gerenciamento de dependências e de ambientes virtuais Poe the Poet: ferramenta de execução de tarefas
Ferramentas de MLOps e LLMOps Hugging Face: registro de modelos ZenML: orquestrador, artefatos e metadados
27 29
30 31 32
Orquestrador 33 Artefatos e metadados 37 Como executar e configurar um pipeline do ZenML 41 Comet ML: rastreador de experimentos Opik: monitoramento de prompts
Bancos de dados para armazenamento de dados não estruturados e vetoriais MongoDB: banco de dados NoSQL Qdrant: banco de dados vetorial
Preparação para a AWS Configurando uma conta da AWS, uma chave de acesso e a CLI Amazon SageMaker: computação para treinamento e inferência
43 44
45 45 45
46 46 48
Por que optar pelo AWS SageMaker? 49
Resumo 50 Referências 50
3 Engenharia de dados
53
Projetando o pipeline de coleta de dados do LLM Twin
54
Sumário
Implementando o pipeline de coleta de dados do LLM Twin Pipeline e etapas do ZenML O despachante: como instanciar o rastreador correto? Os rastreadores
xiii
58 58 63 65
Classes base 66 Classe GitHubCrawler 69 Classe CustomArticleCrawler 71 Classe MediumCrawler 73 Os documentos do data warehouse NoSQL
76
Os padrões de software ORM e ODM 76 Implementar a classe ODM 78 Categorias de dados e classes de documentos do usuário 83
Coletando dados brutos no data warehouse Solução de problemas
85 89
Problemas do Selenium 89 Importe nossos dados de backup 90
Resumo 90 Referências 91
4 Pipeline de atributos de RAG
93
Entendendo a RAG
94
Por que usar RAG?
94
Alucinações 95 Informação antiga 95 O framework RAG básico
95
Pipeline de ingestão de dados 97 Pipeline de recuperação 98 Pipeline de geração 99 O que são embeddings?
100
Por que embeddings são tão poderosos 102 Como os embeddings são criados? 104 Aplicações de embeddings 107 Mais sobre bancos de dados vetoriais
107
Como funciona um banco de dados vetorial? 108 Algoritmos para a criação do índice vetorial 109 Operações de banco de dados 109
xiv
Manual do engenheiro de LLM
Uma visão geral de RAG avançada
110
Pré-recuperação 111 Recuperação 114 Pós-recuperação 116
Explorar a arquitetura do pipeline da funcionalidade de RAG do LLM Twin 118 O problema que estamos resolvendo
119
O feature store
119
De onde vêm os dados brutos?
120
Projetando a arquitetura do pipeline do atributo RAG
120
Pipelines em lote 121 Pipelines em lote versus pipelines de streaming 122 Etapas principais 125 Captura de alterações de dados: sincronizando o data warehouse e a feature store 126 Por que os dados são armazenados em dois snapshots? 129 Orquestração 129
Implementando o pipeline do atributo RAG do LLM Twin
130
Configurações 130 Pipeline e etapas do ZenML
131
Consultando o data warehouse 133 Limpeza de dados dos documentos 136 Fragmentar e gerar embeddings dos documentos limpos 137 Carregando os documentos no banco de dados vetorial 139 Entidades de domínio do Pydantic
140
OVM 143 A camada despachante
149
Os handlers
151
Os handlers de limpeza 152 Os handlers de fragmentação 153 Os handlers de embedding 157
Resumo 161 Referências 161
5 Ajuste fino supervisionado
163
Criação de um conjunto de dados de instruções
164
Arcabouço geral
164
Sumário
xv
Quantidade de dados 166 Curadoria de dados Filtragem baseada em regras Deduplicação de dados Descontaminação de dados Avaliação da qualidade dos dados Exploração de dados Geração de dados Aumento de dados
Criação do nosso próprio conjunto de dados de instruções Explorando o SFT e suas técnicas Quando realizar o ajuste fino Formatos de conjuntos de dados de instruções Templates de chat Técnicas de ajuste fino com eficiência de parâmetros
167 168 169 171 171 174 176 177
179 188 188 189 190 192
Ajuste fino completo 192 LoRA 194 QLoRA 196 Parâmetros de treinamento
197
Taxa de aprendizado e agendador 197 Tamanho do lote 198 Comprimento máximo e empacotamento 199 Número de epochs 199 Otimizadores 200 Decaimento de pesos 200 Checkpointing de gradiente 200
Ajuste fino na prática 201 Resumo 208 Referências 208
6 Ajuste fino com alinhamento às preferências humanas
211
Compreendendo conjuntos de dados de preferências
212
Dados de preferências
212
Quantidade de dados 214 Geração de dados e avaliação
215
Geração de preferências 215 Dicas para geração de dados 216
xvi
Manual do engenheiro de LLM
Avaliação de preferências 217
Criação do nosso próprio conjunto de dados de preferências Alinhamento às preferências humanas Aprendizado por reforço a partir de feedback humano Otimização Direta de Preferências (DPO)
219 226 227 228
Implementando DPO 230 Resumo 237 Referências 238
7 Avaliação de LLMs
239
Avaliação de modelos
240
Comparando a avaliação de ML e de LLM Avaliações de LLMs de propósito geral Avaliações de LLMs específicas de domínio Avaliações de LLMs específicas à tarefa
Avaliação de RAG
240 241 243 245
248
Ragas 249 ARES 251
Avaliando o TwinLlama-3.1-8B Geração de respostas Avaliação de respostas Analisando resultados
252 253 254 259
Resumo 262 Referências 263
8 Otimização de inferência
265
Estratégias de otimização de modelos
266
Cache KV Processamento contínuo em lotes Decodificação especulativa Mecanismos de atenção otimizados
267 269 270 272
Paralelismo de modelo
273
Paralelismo de dados
274
Sumário xvii
Paralelismo de pipeline
275
Paralelismo de tensores
276
Combinando abordagens
277
Quantização de modelos
278
Introdução à quantização
278
Quantização com GGUF e llama.cpp
282
Quantização com GPTQ e EXL2
284
Outras técnicas de quantização
286
Resumo 287 Referências 288
9 Pipeline de inferência de RAG
289
Compreendendo o pipeline de inferência de RAG do LLM Twin
290
Explorando as técnicas avançadas de RAG do LLM Twin
292
Otimizações avançadas de pré-recuperação para RAG: expansão de consulta e autoextração de metadados da consulta
295
Expansão de consulta 295 Autoextração de metadados da consulta 299 Otimização avançada da recuperação em RAG: busca vetorial filtrada
303
Otimização pós-recuperação avançada em RAG: rerranqueamento
304
Implementando o pipeline de inferência RAG do LLM Twin
309
Implementando o módulo de recuperação
309
Reunindo tudo no pipeline de inferência de RAG
316
Resumo 321 Referências 321
10 Implantação do pipeline de inferência
323
Critérios para escolher tipos de implantação
324
Vazão e latência
324
Dados 325 Infraestrutura 325
Entendendo os tipos de implantação de inferência
326
xviii Manual do engenheiro de LLM
Inferência online em tempo real Inferência assíncrona Transformação em lote offline
328 328 329
Arquitetura monolítica versus arquitetura de microsserviços no serviço de modelos 330 Arquitetura monolítica Arquitetura de microsserviços Escolhendo entre arquiteturas monolíticas e de microsserviços
331 332 333
Explorando a estratégia de implantação do pipeline de inferência do LLM Twin 334 O treinamento versus o pipeline de inferência
Implantação do serviço LLM Twin Implementando o microsserviço de LLM usando AWS SageMaker
337
338 339
O que são os DLCs da Hugging Face? 339 Configurando funções do Amazon SageMaker 340 Implantação do modelo LLM Twin no AWS SageMaker 341 Chamando o endpoint de inferência do AWS SageMaker 351 Construindo o microserviço de negócios usando FastAPI
Capacidades de escalonamento automático para lidar com picos de uso Registrando um alvo escalável Criação de uma política escalável Limites mínimos e máximos de normalização
355
358 360 361 362
Período de cooldown 362
Resumo 363 Referências 363
11 MLOps e LLMOps
365
O caminho para o LLMOps: compreendendo suas raízes em DevOps e MLOps 366 DevOps 366 O ciclo de vida do DevOps 367 Os conceitos fundamentais de DevOps 368 MLOps 369 Componentes centrais de MLOps 370 Princípios de MLOps 371
Sumário
xix
ML vs. engenharia de MLOps 372 LLMOps 373 Feedback humano 374 Salvaguardas 374 Monitoramento de prompts 376
Implantação dos pipelines do LLM Twin na nuvem
378
Compreendendo a infraestrutura
378
Configurar o MongoDB
381
Configurando o Qdrant
382
Configurando a nuvem do ZenML
383
Containerizar o código usando Docker 386 Execute os pipelines na AWS 391 Solução de problemas do erro ResourceLimitExceeded após a execução de um pipeline do ZenML no Amazon SageMaker 393
Adicionando LLMOps ao LLM Twin Fluxo do pipeline de CI/CD do LLM Twin
394 395
Mais sobre erros de formatação 397 Mais sobre erros de linting 397 Visão geral rápida do GitHub Actions
397
O pipeline de CI
399
Arquivo YAML de CI do GitHub Actions 399 O pipeline de entrega contínua
402
Teste o pipeline de integração contínua e entrega contínua
405
O pipeline de CT
406
Gatilhos iniciais 407 Acionar pipelines a jusante 408 Monitoramento de prompts
411
Alertas 416
Resumo 417 Referências 417
Apêndice Princípios de MLOps
419
1. Automação ou operacionalização
419
2. Versionamento
421
3. Rastreamento de experimentos
422
xx
Manual do engenheiro de LLM
4. Testes
422
Tipos de teste O que testamos? Exemplos de teste
422 423 423
5. Monitoramento
426
Logs 426 Métricas 426 Métricas do sistema 427 Métricas do modelo 427 Derivas 427 Deriva de dados 428 Deriva do alvo 428 Deriva de conceito 429 Como detectar e medir derivas 430 Monitoramento vs. observabilidade 430 Alertas 431
6. Reprodutibilidade
431
Índice remissivo
433
Prefácio
O campo da engenharia de LLM emergiu rapidamente como uma área crítica em inteligência artificial e machine learning. À medida que os LLMs continuam a revolucionar o processamento e a geração de linguagem natural, a demanda por profissionais que possam implementar, otimizar e implantar esses modelos de forma eficaz em cenários do mundo real cresceu exponencialmente. A engenharia de LLM abrange uma ampla gama de disciplinas, desde a preparação de dados e o ajuste fino de modelo até a otimização de inferência e a implantação em produção, exigindo uma combinação única de engenharia de software, especialização em machine learning e conhecimento de domínio. Operações de Machine Learning (MLOps) desempenha um papel crucial na implementação bem-sucedida de LLMs em ambientes de produção. MLOps estende os princípios de DevOps a projetos de machine learning, focando em automatizar e racionalizar todo o ciclo de vida de ML. Para LLMs, MLOps é particularmente importante devido à complexidade e à escala desses modelos. Ele aborda desafios como gerenciar grandes conjuntos de dados, lidar com o versionamento de modelos, garantir reprodutibilidade e manter a performance do modelo ao longo do tempo. Ao incorporar práticas de MLOps, projetos de LLM podem alcançar maior eficiência, confiabilidade e escalabilidade, resultando, em última instância, em implantações mais bem-sucedidas e impactantes. O Manual do Engenheiro de LLM é um guia abrangente para aplicar as melhores práticas ao novo campo da engenharia de LLM. Ao longo dos capítulos, os leitores encontrarão conceitos-chave simplificados, técnicas práticas e dicas de especialistas para cada etapa do ciclo de vida de LLMs. O livro aborda tópicos como engenharia de dados, ajuste fino supervisionado, avaliação de modelo, otimização de inferência e desenvolvimento de pipelines de Retrieval-Augmented Generation (RAG). Para ilustrar esses conceitos em ação, um projeto de ponta a ponta chamado LLM Twin será desenvolvido ao longo do livro, com o objetivo de imitar o estilo de escrita e a personalidade
xxii Manual do engenheiro de LLM
de alguém. Esse caso de uso demonstrará como construir um produto mínimo viável para resolver um problema específico, utilizando vários aspectos da engenharia de LLM e de MLOps. Os leitores podem esperar obter uma compreensão mais profunda de como coletar e preparar dados para LLMs, realizar ajuste fino de modelos para tarefas específicas, otimizar a performance de inferência e implementar pipelines de RAG. Eles aprenderão como avaliar a performance de LLMs, alinhar modelos com preferências humanas e implantar aplicações baseadas em LLMs. O livro também aborda princípios e práticas essenciais de MLOps, permitindo que os leitores construam aplicações baseadas em LLMs escaláveis, reprodutíveis e robustas.
Para quem é este livro Este livro se destina a uma ampla gama de profissionais e entusiastas de tecnologia interessados nas aplicações práticas de LLMs. É ideal para engenheiros de software que pretendem fazer a transição para projetos de IA. Embora seja útil ter alguma familiaridade com desenvolvimento de software, o livro explica muitos conceitos do zero, tornando-o acessível mesmo para quem é iniciante em IA e aprendizado de máquina. Para quem já trabalha com aprendizado de máquina, este livro aprimorará suas habilidades de implementar e implantar sistemas baseados em LLMs. Oferecemos um estudo aprofundado dos fundamentos de MLOps, guiando você pelo processo de criação de um produto mínimo viável usando um LLM de código aberto para resolver problemas do mundo real.
O que este livro abrange Capítulo 1, Entendendo o conceito e a arquitetura do LLM Twin, apresenta o projeto LLM Twin, que é usado ao longo do livro como um exemplo completo de uma aplicação de LLM em nível de produção, e define a arquitetura FTI para construir sistemas de ML escaláveis e a aplica ao caso de uso do LLM Twin. Capítulo 2, Ferramentas e instalação, apresenta Python, MLOps e ferramentas de nuvem usadas para construir aplicações de LLM do mundo real, como um orquestrador, rastreador de experimentos, ferramenta de monitoramento de prompts e avaliação de LLM. Mostra como usá-las e instalá-las localmente para teste e desenvolvimento. Capítulo 3, Engenharia de dados, mostra a implementação de um pipeline de coleta de dados que faz raspagem de vários sites, como Medium, GitHub e Substack, e armazena os dados brutos em um data warehouse. Enfatiza a coleta de dados brutos de fontes dinâmicas em vez de conjuntos de dados estáticos para aplicações de ML do mundo real. Capítulo 4, Pipeline de atributos de RAG, apresenta conceitos fundamentais de RAG, como embeddings, o framework RAG básico, bancos de dados vetoriais e como otimizar aplicações RAG. Aplica a teoria de RAG ao arquitetar e implementar o pipeline de funcionalidade de RAG do LLM Twin usando as melhores práticas de software.
1 Entendendo o conceito e a arquitetura do LLM Twin Ao final deste livro, teremos conduzido você na jornada de construção de um produto de modelo de linguagem de grande porte (LLM) completo. Acreditamos firmemente que a melhor maneira de aprender sobre LLMs e aprendizado de máquina (ML) em produção é pôr a mão na massa e construir sistemas. Este livro mostrará como construir um LLM Twin, um personagem de IA que aprende a escrever como uma pessoa específica, ao incorporar seu estilo, voz e personalidade em um LLM. Usando este exemplo, vamos conduzi-lo por todo o ciclo de vida de ML, da coleta de dados à implantação e ao monitoramento. A maioria dos conceitos aprendidos ao implementar seu LLM Twin pode ser aplicada em outras aplicações baseadas em LLM ou em ML. Ao começar a implementar um novo produto, do ponto de vista de engenharia, há três etapas de planejamento pelas quais devemos passar antes de iniciar a construção. Primeiro, é fundamental entender o problema que estamos tentando resolver e o que queremos construir. No nosso caso, o que exatamente é um LLM Twin e por que construí-lo? Nesta etapa, devemos sonhar e focar no “Por quê”. Em segundo lugar, para refletir um cenário do mundo real, projetaremos a primeira iteração de um produto com funcionalidade mínima. Aqui, devemos definir claramente as características essenciais necessárias para criar um produto funcional e valioso. As escolhas são feitas com base no cronograma, nos recursos e no conhecimento da equipe. É aqui que fazemos a ponte entre sonhar e focar no que é realista e, por fim, respondemos à seguinte pergunta: “O que vamos construir?” Por fim, passaremos por uma etapa de design de sistema, detalhando a arquitetura principal e as escolhas de design usadas para construir o sistema de LLM. Observe que os dois primeiros componentes estão principalmente relacionados ao produto, enquanto o último é técnico e tem foco no “Como”.
Manual do engenheiro de LLM
2
Essas três etapas são naturais na construção de um produto do mundo real. Mesmo que as duas primeiras não exijam muito conhecimento de ML, é fundamental percorrê-las para entender “como” construir o produto com uma visão clara. Em resumo, este Capítulo aborda os seguintes tópicos: •
Compreendendo o conceito de LLM Twin
•
Planejando o MVP do produto LLM Twin
•
Construindo sistemas de ML com pipelines de atributos/treinamento/inferência
•
Projetando a arquitetura do sistema do LLM Twin
Ao final deste Capítulo, você terá uma visão clara do que aprenderá a construir ao longo do livro.
Compreendendo o conceito de LLM Twin O primeiro passo é ter uma visão clara do que queremos criar e por que é valioso construí-lo. O conceito de um LLM Twin é novo. Assim, antes de entrar nos detalhes técnicos, é essencial entender o que ele é, o que devemos esperar dele e como ele deve funcionar. Ter uma intuição sólida do seu objetivo final torna muito mais fácil assimilar a teoria, o código e a infraestrutura apresentados neste livro.
O que é um LLM Twin? Em poucas palavras, um LLM Twin é um personagem de IA que incorpora seu estilo de escrita, voz e personalidade em um LLM, que é um modelo de IA complexo. É uma versão digital de você mesmo projetada em um LLM. Em vez de um LLM genérico treinado em toda a internet, um LLM Twin é submetido a ajuste fino tendo você como base. Naturalmente, como um modelo de ML reflete os dados em que foi treinado, esse LLM incorporará seu estilo de escrita, voz e personalidade. Usamos intencionalmente a palavra “projetada”. Como em qualquer outra projeção, você perde muita informação ao longo do caminho. Assim, esse LLM não será você; ele copiará o seu lado refletido nos dados em que foi treinado. É essencial entender que um LLM reflete os dados em que foi treinado. Se você alimentá-lo com Shakespeare, ele começará a escrever como ele. Se você treiná-lo com Billie Eilish, ele começará a escrever músicas no estilo dela. Isso também é conhecido como transferência de estilo. Esse conceito também é bastante comum na geração de imagens. Por exemplo, digamos que você queira criar uma imagem de um gato usando o estilo de Van Gogh. Vamos alavancar a estratégia de transferência de estilo, mas, em vez de escolher uma personalidade, faremos isso em nossa própria persona. Para ajustar o LLM a um determinado estilo e voz, juntamente com o ajuste fino, também vamos alavancar várias técnicas avançadas de geração aumentada por recuperação (RAG) para condicionar o processo autorregressivo com embeddings prévios de nós mesmos.
2 Ferramentas e instalação
Este capítulo apresenta todas as ferramentas essenciais que serão usadas ao longo do livro, especialmente para implementar e implantar o projeto de LLM Twin. Neste ponto do livro, não planejamos apresentar conceitos aprofundados de LLM, RAG, MLOps ou LLMOps. Vamos guiá-lo rapidamente pela nossa stack de tecnologia e pelos pré-requisitos, para evitar nos repetirmos ao longo do livro sobre como configurar uma ferramenta específica e por que a escolhemos. A partir do Capítulo 3, começaremos a explorar nosso caso de uso de LLM Twin implementando um ETL de coleta de dados que rastreia dados na internet. Na primeira parte do capítulo, apresentaremos as ferramentas no ecossistema Python para gerenciar várias versões do Python, criar um ambiente virtual e instalar as dependências com versões fixadas necessárias para que nosso projeto seja executado. Junto com a apresentação dessas ferramentas, também mostraremos como instalar o repositório LLM-Engineers-Handbook na sua máquina local (caso você queira testar o código por conta própria): https://github.com/PacktPublishing/LLM-Engineers-Handbook. Em seguida, exploraremos todas as ferramentas de MLOps e LLMOps que usaremos, começando com ferramentas mais genéricas, como um registro de modelos, e passando para ferramentas mais voltadas para LLM, como ferramentas de avaliação de LLM e monitoramento de prompts. Também entenderemos como gerenciar um projeto com vários pipelines de ML usando o ZenML, um orquestrador que preenche a lacuna entre ML e MLOps. Além disso, exploraremos rapidamente quais bancos de dados usaremos para armazenamento NoSQL e vetorial. Mostraremos como executar todos esses componentes em sua máquina local usando o Docker. Por fim, revisaremos rapidamente a AWS e mostraremos como criar um usuário e chaves de acesso da AWS, além de instalar e configurar a AWS CLI para manipular seus recursos na nuvem programaticamente. Também exploraremos o SageMaker e por que o usamos para treinar e implantar nossos LLMs de código aberto.
Manual do engenheiro de LLM
26
Se você já está familiarizado com essas ferramentas, pode pular este capítulo sem problemas. Também explicamos como instalar o projeto e configurar todos os componentes necessários no README do repositório. Assim, você também tem a opção de usá-lo como documentação mais concisa se você planeja executar o código enquanto lê o livro. Para resumir tudo isso, neste capítulo, vamos explorar os seguintes tópicos: •
Ecossistema do Python e instalação do projeto
•
Ferramentas de MLOps e LLMOps
•
Bancos de dados para armazenamento de dados não estruturados e vetoriais
•
Preparação para a AWS
Ao final deste capítulo, você conhecerá todas as ferramentas que usaremos ao longo do livro. Além disso, você terá aprendido a instalar o repositório LLM-Engineers-Handbook, configurar o restante das ferramentas e usá-las se executar o código enquanto lê o livro.
Ecossistema do Python e instalação do projeto Qualquer projeto em Python precisa de três ferramentas fundamentais: o interpretador do Python, o gerenciamento de dependências e uma ferramenta de execução de tarefas. O interpretador do Python executa seu projeto em Python como esperado. Todo o código neste livro foi testado com Python 3.11.8. Você pode baixar o interpretador do Python aqui: https://www.python.org/downloads/. Recomendamos instalar a versão exata do Python (Python 3.11.8) para executar o projeto LLM Twin usando pyenv, tornando o processo de instalação simples. Em vez de instalar várias versões globais do Python, recomendamos gerenciá-las usando pyenv, uma ferramenta de gerenciamento de versões do Python que permite gerenciar várias versões do Python entre projetos. Você pode instalá-la usando este link: https:// github.com/pyenv/pyenv?tab=readme-ov-file#installation. Depois de instalar pyenv, você pode instalar a versão mais recente do Python 3.11, usando pyenv, da seguinte forma: pyenv install 3.11.8
Agora liste todas as versões do Python instaladas para confirmar que foi instalado corretamente: pyenv versions
Você deve ver algo assim: # * sistema # 3.11.8
3 Engenharia de dados
Este capítulo começará a explorar o projeto LLM Twin em mais profundidade. Aprenderemos como projetar e implementar o pipeline de coleta de dados para reunir os dados brutos que usaremos em todos os nossos casos de uso de LLMs, como ajuste fino ou inferência. Como este não é um livro sobre engenharia de dados, manteremos este capítulo curto e focaremos apenas no que é estritamente necessário para coletar os dados brutos requeridos. Começando pelo Capítulo 4, nos concentraremos em LLMs e GenAI, explorando sua teoria e detalhes concretos de implementação. Ao trabalhar em projetos didáticos ou fazer pesquisa, geralmente você tem um conjunto de dados estático com o qual se trabalha. Mas, no nosso caso de uso do LLM Twin, queremos simular um cenário do mundo real em que devemos reunir e fazer a curadoria dos dados por conta própria. Assim, implementar nosso pipeline de dados conectará os pontos sobre como funciona um projeto de ML de ponta a ponta. Este capítulo explorará como projetar e implementar um pipeline de Extração, Transformação e Carga (ETL) que rastreia várias plataformas sociais, como Medium, Substack ou GitHub, e agrega os dados coletados em um data warehouse no MongoDB. Mostraremos como implementar vários métodos de rastreamento, padronizar os dados e carregá-los em um data warehouse. Começaremos projetando o pipeline de coleta de dados do LLM Twin e explicando a arquitetura do pipeline de ETL. Em seguida, partiremos diretamente para a implementação do pipeline, começando com ZenML, que orquestrará todo o processo. Investigaremos a implementação do rastreador e entenderemos como implementar uma camada despachante que instancia a classe de rastreador correta com base no domínio do link fornecido, seguindo as boas práticas de software. Em seguida, aprenderemos como implementar cada rastreador
Manual do engenheiro de LLM
54
individualmente. Além disso, mostraremos como implementar uma camada de dados no MongoDB para estruturar todos os nossos documentos e interagir com o banco de dados. Por fim, exploraremos como executar o pipeline de coleta de dados usando ZenML e consultar os dados coletados no MongoDB. Assim, neste capítulo, estudaremos os seguintes tópicos: •
Projetando o pipeline de coleta de dados do LLM Twin
•
Implementando o pipeline de coleta de dados do LLM Twin
•
Coletando dados brutos no data warehouse
Ao final deste capítulo, você saberá como projetar e implementar um pipeline de ETL para extrair, transformar e carregar dados brutos prontos para serem ingeridos na aplicação de ML.
Projetando o pipeline de coleta de dados do LLM Twin Antes de nos aprofundarmos na implementação, devemos entender a arquitetura de ETL de coleta de dados do LLM Twin, ilustrada na Figura 3.1. Devemos explorar quais plataformas vamos rastrear para extrair dados e como projetaremos nossas estruturas e processos de dados. No entanto, a primeira etapa é entender como nosso pipeline de coleta de dados se mapeia para um processo de ETL. Um pipeline de ETL envolve três etapas fundamentais: 1.
Nós extraímos dados de várias fontes. Nós faremos rastreamento de dados em plataformas como Medium, Substack e GitHub para coletar dados brutos.
2.
Nós transformamos estes dados realizando limpeza de dados e padronizando-os em um formato consistente adequado para armazenamento e análise.
3.
Nós carregamos os dados transformados para um data warehouse ou banco de dados.
Para o nosso projeto, utilizamos o MongoDB como nosso data warehouse NoSQL. Embora essa não seja uma abordagem padrão, explicaremos o raciocínio por trás dessa escolha em breve.
4 Pipeline de atributos de RAG Geração aumentada por recuperação (RAG) é fundamental na maioria das aplicações de IA generativa. A responsabilidade central da RAG é injetar dados personalizados no modelo de linguagem de grande porte (LLM) para executar uma determinada ação (por exemplo, resumir, reformular e extrair os dados injetados). Com frequência, você deseja usar o LLM em dados nos quais ele não foi treinado (por exemplo, dados privados ou novos). Como o ajuste fino de um LLM é uma operação altamente custosa, a RAG é uma estratégia convincente que contorna a necessidade de ajuste fino constante para acessar esses novos dados. Começaremos este capítulo com uma parte teórica que se concentra nos fundamentos de RAG e em como ele funciona. Em seguida, guiaremos você por todos os componentes de um sistema RAG ingênuo: fragmentação, embedding e bancos de dados vetoriais. Por fim, apresentaremos várias otimizações usadas em um sistema RAG avançado. Depois, continuaremos a explorar a arquitetura do pipeline da funcionalidade de RAG do LLM Twin. Nesta etapa, aplicaremos todos os aspectos teóricos discutidos no início do capítulo. Por fim, passaremos por um exemplo prático, implementando o pipeline da funcionalidade de RAG do LLM Twin com base no design do sistema descrito ao longo do livro. As principais seções deste capítulo são: •
Compreendendo o RAG
•
Uma visão geral do RAG avançado
•
Explorando a arquitetura do pipeline da funcionalidade de RAG do LLM Twin
•
Implementando o pipeline da funcionalidade de RAG do LLM Twin
Manual do engenheiro de LLM
94
Ao final deste capítulo, você terá uma compreensão clara e abrangente do que é RAG e de como ele se aplica ao nosso caso de uso de LLM Twin.
Entendendo a RAG A RAG melhora a acurácia e a confiabilidade de modelos de IA generativa com informação obtida de fontes externas. É uma técnica complementar ao conhecimento interno dos LLMs. Antes de entrar nos detalhes, vamos entender o que significa RAG: •
Recuperação: Pesquisar dados relevantes
•
Aumentada: Adicionar os dados como contexto ao prompt
•
Geração: Usar o prompt aumentado com um LLM para geração
Qualquer LLM está limitado a compreender os dados nos quais foi treinado, o que às vezes é chamado de conhecimento parametrizado. Assim, mesmo que o LLM consiga responder perfeitamente ao que aconteceu no passado, ele não terá acesso aos dados mais recentes nem a quaisquer outras fontes externas nas quais não foi treinado. Vamos tomar como exemplo o modelo mais poderoso da OpenAI, que, no verão de 2024, é o GPT-4o. O modelo é treinado com dados até outubro de 2023. Assim, se perguntarmos o que aconteceu durante a pandemia de 2020, a pergunta poderá ser respondida perfeitamente graças ao seu conhecimento parametrizado. No entanto, não saberá a resposta se perguntarmos sobre os resultados do Campeonato Europeu de Futebol de 2024, devido ao seu conhecimento parametrizado limitado. Outro cenário é que ele começará a alucinar com confiança e fornecerá uma resposta incorreta. A RAG supera essas duas limitações dos LLMs. Ela fornece acesso a dados externos ou mais recentes e evita alucinações, aumentando a acurácia e a confiabilidade dos modelos de IA generativa.
Por que usar RAG? Anteriormente, demos uma breve explicação sobre a importância de usar RAG em aplicações de IA generativa. Agora, vamos nos aprofundar no “porquê”; em seguida, nos concentraremos em como é uma estrutura RAG ingênua. Por ora, para ter uma intuição sobre RAG, você precisa saber que, ao usar RAG, injetamos a informação necessária no prompt para responder à pergunta inicial do usuário. Depois disso, passamos o prompt aumentado ao LLM para a resposta final. Agora, o LLM usará o contexto adicional para responder à pergunta do usuário. Existem dois problemas fundamentais que o RAG resolve: •
Alucinações
•
Informação antiga ou privada
5 Ajuste fino supervisionado
Ajuste fino supervisionado (SFT) é uma etapa crucial na preparação de LLMs para aplicações do mundo real. Após a fase inicial de pré-treinamento, em que um LLM aprende a prever o próximo token em uma sequência, o SFT refina as capacidades do modelo usando pares cuidadosamente selecionados de instruções e respostas correspondentes. Esse processo cumpre dois propósitos principais: ele ensina o modelo a entender e seguir um formato de chat específico, efetivamente transformando-o em um agente conversacional, e permite que o modelo adapte sua ampla base de conhecimento para se destacar em tarefas direcionadas ou domínios especializados. A importância do SFT está em sua capacidade de preencher a lacuna entre a compreensão geral de linguagem de um modelo e sua utilidade prática. Ao expor o modelo a exemplos de padrões desejados de entrada e saída, o SFT molda o comportamento do LLM para se alinhar a objetivos específicos, sejam eles de conclusão de tarefas (como sumarização ou tradução) ou de especialização em domínios (como conhecimento médico ou jurídico). Essa abordagem sob medida não apenas aprimora a performance do modelo nas áreas pretendidas, mas também melhora sua capacidade de seguir instruções e gerar respostas mais relevantes e coerentes. Neste Capítulo, abordaremos os seguintes tópicos: •
Criação de um conjunto de dados de instruções de alta qualidade
•
Técnicas de SFT
•
Implementando ajuste fino na prática
Ao final deste capítulo, você será capaz de criar seus próprios conjuntos de dados de instruções e realizar o ajuste fino de LLMs neles de forma eficiente.
164 Manual do engenheiro de LLM
Todos os exemplos de código deste capítulo podem ser encontrados no GitHub em https://github.com/PacktPublishing/ LLM-Engineering.
Criação de um conjunto de dados de instruções Na maioria dos casos de uso, a criação de um conjunto de dados de instruções é a parte mais difícil do processo de ajuste fino. Isso se deve a múltiplos fatores. A maioria dos casos de uso pode ser associada a texto bruto, mas é raro encontrar pares naturais de instruções e respostas. Esse texto bruto precisa ser transformado em um formato que inclua tanto instruções quanto respostas. Além disso, a qualidade dos dados também é crucial. Por causa disso, muito tempo é investido na verificação e validação manuais de amostras individuais. Essa revisão cuidadosa ajuda a garantir que o conjunto de dados seja preciso e útil para o treinamento do modelo.
Figura 5.1: Visão geral do pipeline de dados pós-treinamento abordado neste capítulo
Nesta seção, apresentaremos um arcabouço geral para criar seus próprios conjuntos de dados de instruções, independentemente do caso de uso final. Em seguida, alavancaremos os dados raspados do Capítulo 3 e os transformaremos em um conjunto de dados de instruções. As diferentes etapas do nosso pipeline de geração de dados estão resumidas na Figura 5.1.
Arcabouço geral Conjuntos de dados de instruções são definidos como pares de instruções e respostas. As instruções são as entradas do modelo, usadas como contexto durante o ajuste fino. As respostas são as saídas esperadas do modelo. Durante o ajuste fino, você pode optar por treinar o modelo com as instruções e as respostas, ou apenas com as respostas. Pares de instruções e respostas seguem um determinado modelo (template). Alguns modelos de instrução, como o Alpaca, introduzem campos adicionais como inputs e system. Ambos podem ser considerados subcampos do instruction campo. Neste caso, “inputs” contêm os dados de que o modelo precisa para completar a instrução, e “system” é um meta-prompt para orientar o comportamento geral do modelo. Aqui está um exemplo do conjunto de dados SlimOrca, com “system” e “instruction”:
6 Ajuste fino com alinhamento às preferências humanas Ajuste fino supervisionado (SFT) tem sido crucial para adaptar LLMs para realizar tarefas específicas. No entanto, o SFT tem dificuldade em capturar as nuances das preferências humanas e a cauda longa de interações potenciais que um modelo pode encontrar. Essa limitação levou ao desenvolvimento de técnicas mais avançadas para alinhar sistemas de IA às preferências humanas, agrupadas sob o termo guarda-chuva alinhamento às preferências humanas. O alinhamento às preferências humanas aborda as deficiências do SFT ao incorporar feedback humano direto ou de IA ao processo de treinamento. Esse método permite uma compreensão com mais nuances das preferências humanas, especialmente em cenários complexos nos quais um aprendizado supervisionado simples deixa a desejar. Embora existam inúmeras técnicas para o alinhamento às preferências humanas, este capítulo se concentrará principalmente em Otimização Direta de Preferências (DPO) por simplicidade e eficiência. Neste capítulo, falaremos sobre o tipo de dados exigido por algoritmos de alinhamento às preferências humanas como o DPO. Vamos construir nosso próprio conjunto de dados para modificar o estilo de escrita do nosso modelo, tornando-o menos artificial e mais autêntico. Apresentaremos o algoritmo DPO e o implementaremos para alinhar o modelo treinado no Capítulo 5. Neste capítulo, abordaremos os seguintes tópicos: •
Compreendendo conjuntos de dados de preferências
•
Como criar nosso próprio conjunto de dados de preferências
•
Otimização direta de preferências (DPO)
•
Implementando DPO na prática para alinhar nosso modelo
212 Manual do engenheiro de LLM
Ao final deste capítulo, você será capaz de criar seus próprios conjuntos de dados de preferências e alinhar modelos com diversas técnicas. Todos os exemplos de código deste Capítulo podem ser encontrados no GitHub em https://github.com/PacktPublishing/ LLM-Engineering.
Compreendendo conjuntos de dados de preferências Os princípios para a criação de conjuntos de dados de preferências de alta qualidade são os mesmos que os discutidos no Capítulo 5 para conjuntos de dados de instruções. Queremos maximizar a acurácia, a diversidade e a complexidade de nossas amostras. Para isso, seguimos as mesmas etapas, conforme descritas na Figura 6.1: curadoria de dados, deduplicação, descontaminação, avaliação de qualidade, exploração, geração e aumento de dados.
Figura 6.1: Visão geral do pipeline de dados pós-treinamento abordado neste capítulo
Para evitar repetição, esta seção se concentrará nas principais diferenças entre conjuntos de dados de instruções e de preferências. Apresentaremos a estrutura das amostras de preferências e o tamanho ideal para conjuntos de dados de preferências. Em seguida, nos concentraremos nas duas etapas que mais diferem da criação de conjuntos de dados de instruções: geração de dados e avaliação.
Dados de preferências Conjuntos de dados de preferências carecem da padronização dos conjuntos de dados de instruções devido a requisitos de dados variados entre diferentes algoritmos de treinamento. Os dados de preferências compreendem uma coleção de respostas a uma determinada instrução, classificadas por humanos ou por modelos de linguagem. Este Capítulo se concentra em DPO, portanto examinaremos o formato de dados específico exigido por este algoritmo. Como ilustrado na Tabela 6.1, a estrutura dos conjuntos de dados de DPO é simples: cada instrução é associada a uma resposta preferida e uma resposta rejeitada. O objetivo é treinar o modelo para gerar a resposta preferida em vez da rejeitada.
7 Avaliação de LLMs
A avaliação de LLM é um processo crucial usado para avaliar a performance e as capacidades de modelos de LLM. Ela pode assumir múltiplas formas, como respostas a perguntas de múltipla escolha, instruções abertas e feedback de usuários reais. Atualmente, não há uma abordagem unificada para a mensuração da performance de um modelo, mas há padrões e receitas que podemos adaptar a casos de uso específicos. Embora as avaliações de propósito geral sejam as mais populares, com benchmarks como Massive Multi-Task Language Understanding (MMLU) ou LMSYS Chatbot Arena, modelos específicos de domínio e de tarefa se beneficiam de abordagens mais restritas. Isso é particularmente verdadeiro ao lidar com sistemas de LLM completos (em oposição a modelos), frequentemente centrados em um geração aumentada por recuperação (RAG) . Nesses cenários, precisamos expandir nosso framework de avaliação para abranger todo o sistema, incluindo novos módulos como recuperadores e pós-processadores. Neste Capítulo, abordaremos os seguintes tópicos: •
Avaliação de modelos
•
Avaliação de RAG
•
Avaliação do TwinLlama-3.1-8B
Ao final deste capítulo, você conhecerá as avaliações de LLM mais populares e como avaliar modelos e sistemas de RAG utilizando diferentes técnicas.
240 Manual do engenheiro de LLM
Avaliação de modelos Na avaliação de modelos, o objetivo é avaliar as capacidades de um único modelo sem qualquer engenharia de prompt, pipeline de RAG, e assim por diante. Essa avaliação é essencial por vários motivos, como selecionar o LLM mais relevante ou garantir que o processo de ajuste fino de fato melhorou o modelo. Nesta seção, compararemos a avaliação de ML e de LLM para entender as principais diferenças entre essas duas áreas. Em seguida, exploraremos benchmarks para modelos de propósito geral, específicos de domínio e específicos de tarefa.
Comparando a avaliação de ML e de LLM A avaliação de ML é centrada na avaliação da performance de modelos projetados para tarefas como previsão, classificação e regressão. Diferentemente da avaliação de LLMs, que frequentemente se concentra em quão bem um modelo compreende e gera linguagem, a avaliação de ML está mais preocupada com a precisão e a eficiência com que um modelo pode processar dados estruturados para produzir resultados específicos. Essa diferença decorre da natureza das tarefas que esses modelos executam. Os modelos de aprendizado de máquina costumam ser projetados para problemas de escopo estreito, como a previsão de preços das ações ou a detecção de valores discrepantes, que frequentemente envolvem dados numéricos ou categóricos, tornando o processo de avaliação mais direto. Por outro lado, os LLMs têm como tarefa a interpretação e a geração de linguagem, o que adiciona uma camada de subjetividade ao processo de avaliação. Em vez de depender apenas de benchmarks numéricos, a avaliação de LLM requer uma abordagem mais refinada e frequentemente incorpora avaliações qualitativas, com análise de quão bem o modelo produz respostas coerentes, relevantes e contextualmente precisas em linguagem natural. Em particular, podemos observar três diferenças-chave em como esses modelos funcionam, que impactam o processo de avaliação: •
Métricas numéricas: A avaliação de modelos de aprendizado de máquina geralmente envolve a mensuração de métricas de performance objetivas, como acurácia, precisão, revocação ou erro quadrático médio, dependendo do tipo de tarefa em questão. Isso é menos claro com LLMs, que podem lidar com múltiplas tarefas (portanto, múltiplas avaliações) e raramente podem depender das mesmas métricas numéricas.
•
Engenharia de atributos: No ML tradicional, uma parte crítica do processo envolve selecionar e transformar manualmente características de dados relevantes antes do treinamento do modelo. A avaliação do sucesso dessa engenharia de atributos frequentemente se torna parte da avaliação mais ampla do modelo. LLMs, no entanto, são projetados para lidar diretamente com dados de texto bruto, reduzindo a necessidade de engenharia de atributos manual.
•
Interpretabilidade: Com modelos de aprendizado de máquina, é mais fácil interpretar por que um modelo fez determinadas predições ou classificações, e essa
8 Otimização de inferência
A implantação de LLMs é desafiadora devido aos seus requisitos significativos de computação e memória. A execução eficiente desses modelos exige o uso de aceleradores especializados, como GPUs ou TPUs, que podem paralelizar operações e alcançar maior vazão. Embora algumas tarefas, como geração de documentos, possam ser processadas em lotes durante a noite, outras exigem baixa latência e geração rápida, como a autocompletação de código. Como resultado, otimizar o processo de inferência – como esses modelos fazem predições com base em dados de entrada – é crucial para muitas aplicações práticas. Isso inclui reduzir o tempo necessário para gerar o primeiro token (latência), aumentar o número de tokens gerados por segundo (vazão) e minimizar a pegada de memória dos LLMs. De fato, abordagens ingênuas de implantação levam a uma baixa utilização do hardware e a uma vazão e latência aquém do ideal. Felizmente, uma variedade de técnicas de otimização surgiu para acelerar dramaticamente a inferência. Este capítulo explorará métodos-chave como decodificação especulativa, paralelismo de modelo e quantização de pesos, demonstrando como implementações bem planejadas podem alcançar acelerações de 2–4X ou mais. Também apresentaremos três motores de inferência populares (Text Generation Inference, vLLM e TensorRT-LLM) e compararemos suas características em termos de otimização de inferência. Neste capítulo, abordaremos os seguintes tópicos: •
Estratégias de otimização de modelos
•
Paralelismo de modelo
•
Quantização de modelos
266 Manual do engenheiro de LLM
Ao final deste capítulo, você compreenderá os desafios centrais na inferência de LLMs e estará familiarizado com técnicas de otimização de ponta, incluindo paralelismo de modelo e quantização de pesos. Todos os exemplos de código deste Capítulo podem ser encontrados no GitHub em https://github.com/PacktPublishing/ LLM-Engineering.
Estratégias de otimização de modelos A maioria dos LLMs utilizados atualmente, como GPT ou Llama, é baseada em uma arquitetura Transformer somente de decodificador. A decoder-only arquitetura somente de decodificador é projetada para tarefas de geração de texto. Ela prevê a próxima palavra em uma sequência com base nas palavras anteriores, o que a torna eficaz para gerar continuações de texto contextualmente apropriadas. Em contraste, uma encoder-only arquitetura somente de codificador, como o BERT, concentra-se em compreender e representar o texto de entrada com embeddings detalhados. Ela se destaca em tarefas que exigem compreensão abrangente do contexto, como classificação de texto e reconhecimento de entidades nomeadas. Por fim, a arquitetura codificador-decodificador, como o T5, combina ambas as funcionalidades. O codificador processa o texto de entrada para gerar uma representação rica em contexto, que o decodificador então usa para produzir o texto de saída. Essa estrutura dupla é particularmente poderosa para tarefas de sequência para sequência, como tradução e sumarização, em que compreender o contexto de entrada e gerar uma saída relevante são igualmente importantes. Neste livro, focamos apenas na arquitetura somente de decodificador, que domina a área de LLMs.
Figura 8.1: Processo de inferência com modelos somente de decodificador. Fornecemos “I have a dream” como entrada e obtemos “of” como saída
Como mostrado na Figura 8.1, o processo básico de inferência para um modelo somente com decodificador envolve: 1.
Tokenização do prompt de entrada e sua passagem por uma camada de embedding e pela codificação posicional.
2.
Computação de pares de chave e valor para cada token de entrada usando o mecanismo de atenção multi-cabeça.
3.
Geração de tokens de saída sequencialmente, um de cada vez, usando as chaves e os valores computados.
9 Pipeline de inferência de RAG
No Capítulo 4, implementamos a geração aumentada por recuperação (RAG) de atributos do pipeline para popular o banco de dados vetorial (DB). Dentro do pipeline de atributos, coletamos dados do data warehouse, limpamos, segmentamos em chunks e geramos embeddings dos documentos e, por fim, os carregamos no banco de dados vetorial. Assim, neste ponto, o banco de dados vetorial está preenchido com documentos e pronto para ser usado para RAG. Com base na metodologia RAG, você pode dividir sua arquitetura de software em três módulos: um para recuperação, um para enriquecer o prompt e um para gerar a resposta. Seguiremos um padrão semelhante ao implementar um módulo de recuperação para consultar o banco de dados vetorial. Dentro desse módulo, implementaremos técnicas avançadas de RAG para otimizar a busca. Em seguida, não dedicaremos um módulo inteiro ao enriquecimento do prompt, pois isso seria um excesso de engenharia, que procuramos evitar. No entanto, escreveremos um serviço de inferência que recebe a consulta do usuário e o contexto, constrói o prompt e chama o LLM para gerar a resposta. Em resumo, implementaremos dois módulos centrais em Python, um para recuperação e outro para chamar o LLM, usando como entrada a consulta e o contexto do usuário. Ao juntá-los, teremos um fluxo de RAG de ponta a ponta. Nos Capítulos 5 e 6, fizemos ajuste fino do nosso modelo LLM Twin, e no Capítulo 8, aprendemos a otimizá-lo para inferência. Assim, neste ponto, o LLM está pronto para produção. O que resta é construir e implantar os dois módulos descritos acima. Dedicaremos o próximo capítulo inteiramente à implantação do nosso modelo LLM Twin ajustado por ajuste fino no AWS SageMaker, como um endpoint de inferência do AWS SageMaker. Assim, o foco deste capítulo é aprofundar na implementação do módulo de recuperação avançado de RAG. Dedicamos um capítulo inteiro à etapa de recuperação porque é aqui que a mágica acontece em um sistema de RAG. Na etapa de recuperação (e
290 Manual do engenheiro de LLM
não ao chamar o LLM), você escreve a maior parte do código de inferência de RAG. Essa etapa é onde você precisa tratar seus dados para garantir que recupere os pontos de dados mais relevantes do banco de dados vetorial. Portanto, a maior parte da lógica avançada de RAG fica dentro da etapa de recuperação. Para resumir, neste capítulo, abordaremos os seguintes tópicos: •
Compreendendo o pipeline de inferência RAG do LLM Twin
•
Explorando as técnicas RAG avançadas do LLM Twin
•
Implementando o pipeline de inferência RAG do LLM Twin
Ao final deste capítulo, você saberá como implementar um módulo de recuperação avançado de RAG, enriquecer um prompt usando o contexto recuperado e chamar um LLM para gerar a resposta final. Por fim, você saberá como construir um pipeline de inferência de RAG pronto para produção de ponta a ponta.
Compreendendo o pipeline de inferência de RAG do LLM Twin Antes de implementar o pipeline de inferência RAG, queremos discutir sua arquitetura de software e técnicas avançadas de RAG. A Figura 9.1 ilustra uma visão geral do fluxo de inferência RAG. O pipeline de inferência começa com a consulta de entrada, recupera o contexto usando o módulo de recuperação (com base na consulta) e chama o serviço de LLM do Amazon SageMaker para gerar a resposta final.
Figura 9.1: Arquitetura do pipeline de inferência RAG
10 Implantação do pipeline de inferência A implantação do pipeline de inferência para o modelo de linguagem de grande porte (LLM) da aplicação Twin é uma etapa crítica no ciclo de vida da aplicação de aprendizado de máquina (ML). É onde o maior valor é agregado ao seu negócio, tornando seus modelos acessíveis aos seus usuários finais. No entanto, implantar modelos de IA com sucesso pode ser desafiador, pois os modelos exigem poder de computação caro e acesso a características atualizadas para executar a inferência. Para superar essas restrições, é crucial projetar cuidadosamente sua estratégia de implantação. Isso garante que ela atenda aos requisitos da aplicação, como latência, vazão e custos. À medida que trabalhamos com LLMs, devemos considerar as técnicas de otimização de inferência apresentadas no Capítulo 8, como a quantização de modelos. Além disso, para automatizar os processos de implantação, devemos alavancar as boas práticas de MLOps, como registros de modelos que versionam e compartilham nossos modelos em toda a nossa infraestrutura. Para entender como projetar a arquitetura de implantação do LLM Twin, primeiro analisaremos três tipos de implantação entre os quais podemos escolher: inferência online em tempo real, inferência assíncrona e transformação em lote offline. Além disso, para entender melhor qual opção escolher para o nosso caso de uso do LLM Twin, apresentaremos rapidamente um conjunto de critérios críticos que devemos considerar antes de tomar uma decisão arquitetural, como latência, vazão, dados e infraestrutura. Também ponderaremos os prós e contras da arquitetura monolítica e da arquitetura de microsserviços em serviço de modelos, uma decisão que pode influenciar significativamente a escalabilidade e a manutenibilidade do seu serviço. Uma vez que tenhamos compreendido as várias opções de design disponíveis, vamos nos concentrar em entender a estratégia de implantação para o pipeline de inferência do LLM Twin. Na sequência, conduziremos você por um tutorial ponta a ponta sobre a implantação do serviço LLM Twin, incluindo a implantação do nosso LLM personalizado ajustado por ajuste fino em endpoints do AWS SageMaker e a implementação de um servidor FastAPI como o ponto de entrada central para nossos usuários. Em seguida,
324 Manual do engenheiro de LLM
encerraremos este capítulo com uma breve discussão sobre estratégias de escalonamento automático e como usá-las no SageMaker. Portanto, neste capítulo, abordaremos os seguintes tópicos: •
Critérios para a escolha de tipos de implantação
•
Compreendendo os tipos de implantação de inferência
•
Arquitetura monolítica versus arquitetura de microsserviços em serviço de modelos
•
Explorando a estratégia de implantação do pipeline de inferência do LLM Twin
•
Implantação do serviço LLM Twin
•
Capacidades de escalonamento automático para lidar com picos de uso
Critérios para escolher tipos de implantação Quando se trata da implantação de modelos de aprendizado de máquina, o primeiro passo é entender os quatro requisitos presentes em toda aplicação de ML: vazão, latência, dados e infraestrutura. Entendê-los e sua interação é essencial. Ao projetar a arquitetura de implantação para seus modelos, sempre há uma compensação entre os quatro que impactará diretamente a experiência do usuário. Por exemplo, sua implantação de modelo deve ser otimizada para baixa latência ou alta vazão?
Vazão e latência Vazão refere-se ao número de requisições de inferência que um sistema pode processar em um determinado período. Geralmente é medida em requisições por segundo (RPS). A vazão é crucial na implantação de modelos de aprendizado de máquina quando você espera processar muitas requisições. Ela garante que o sistema possa lidar com muitas requisições de forma eficiente, sem se tornar um gargalo. Alta vazão frequentemente exige infraestrutura escalável e robusta, como máquinas ou clusters com várias GPUs de ponta.Latência é o tempo que leva para um sistema processar uma única requisição de inferência desde o momento em que ela é recebida até o momento em que o resultado é retornado. A latência é crítica em aplicações em tempo real nas quais tempos de resposta rápidos são essenciais, como em interações ao vivo com usuários, detecção de fraudes ou qualquer sistema que exija feedback imediato. Por exemplo, a latência média da API da OpenAI é o tempo médio de resposta desde quando um usuário envia uma requisição, e o serviço fornece um resultado que é acessível dentro da sua aplicação. A latência é a soma de E/S de rede, serialização e desserialização, e o tempo de inferência do LLM. Enquanto isso, a vazão é o número médio de requisições que a API processa e atende por segundo.
11 MLOps e LLMOps
Ao longo do livro, já usamos componentes e princípios de operações de aprendizado de máquina (MLOps) como um registro de modelos para compartilhar e versionar nossos modelos de linguagem de grande porte com ajuste fino (LLMs), um feature store lógico para nossos dados de ajuste fino e de RAG, e um orquestrador para integrar todos os nossos pipelines de ML. Mas MLOps não se resume a esses componentes; ele leva uma aplicação de ML a um novo patamar ao automatizar a coleta de dados, o treinamento, os testes e a implantação. Assim, o objetivo final de MLOps é automatizar o máximo possível e permitir que os usuários se concentrem nas decisões mais críticas, como quando é detectada uma mudança na distribuição e é preciso decidir se é essencial retreinar o modelo ou não. Mas e quanto a operações de LLMs (LLMOps)? Como ele difere de MLOps? O termo LLMOps é um produto da ampla adoção de LLMs. Ele é construído sobre MLOps, que é construído sobre operações de desenvolvimento (DevOps). Assim, para compreender plenamente do que se trata LLMOps, precisamos fornecer um contexto histórico, começando com DevOps e desenvolvendo o termo a partir daí — que é precisamente o que este capítulo fará. No cerne, LLMOps se concentra em problemas específicos de LLMs, como monitoramento de prompts e versionamento, salvaguardas de entrada e de saída para impedir comportamento tóxico e ciclos de feedback para coletar dados de ajuste fino. Também se concentra em problemas de normalização que aparecem ao trabalhar com LLMs, como coletar trilhões de tokens para conjuntos de dados de treinamento, treinar modelos em clusters massivos de GPU e reduzir custos de infraestrutura. Felizmente para as pessoas em geral, esses problemas são resolvidos principalmente por algumas empresas que fazem ajuste fino de modelos fundamentais, como a Meta, que fornece a família de modelos Llama. A maioria das empresas adotará esses modelos fundamentais pré-treinados para seus casos de uso, concentrando-se em problemas de LLMOps como monitoramento de prompts e versionamento.
366 Manual do engenheiro de LLM
Do lado da implementação, para adicionar LLMOps ao nosso caso de uso LLM Twin, vamos implantar todos os nossos pipelines do ZenML na AWS. Vamos implementar um pipeline de integração contínua e entrega contínua (CI/CD) para testar a integridade do nosso código e automatizar o processo de implantação, um pipeline de treinamento contínuo (CT) para automatizar nosso treinamento, e um pipeline de monitoramento para rastrear todos os nossos prompts e respostas geradas. Esta é uma progressão natural em qualquer projeto de ML, independentemente de você usar LLMs. Nos capítulos anteriores, você aprendeu a construir uma aplicação de LLM. Agora, é hora de explorar três objetivos principais relacionados a LLMOps. O primeiro é obter um entendimento teórico de LLMOps, começando com DevOps, depois passando pelos princípios fundamentais de MLOps e, por fim, aprofundando em LLMOps. Não pretendemos fornecer toda a teoria sobre DevOps, MLOps e LLMOps, pois seria fácil escrever um livro inteiro sobre esses tópicos. No entanto, queremos construir um entendimento sólido sobre por que tomamos certas decisões ao implementar o caso de uso LLM Twin. Nosso segundo objetivo é implantar os pipelines do ZenML na AWS (no momento, implantamos apenas nosso pipeline de inferência na AWS no Capítulo 10). Esta seção será prática, mostrando como alavancar o ZenML para implantar tudo na AWS. Precisamos disso para implementar nosso terceiro e último objetivo, que é aplicar o que aprendemos na seção teórica ao nosso caso de uso LLM Twin. Vamos implementar um pipeline de integração contínua e entrega contínua usando GitHub Actions, um pipeline de CT e de alertas usando ZenML e um pipeline de monitoramento usando o Opik da Comet ML. Assim, neste capítulo, vamos abordar os seguintes tópicos: •
O caminho para LLMOps: compreendendo suas raízes em DevOps e MLOps
•
Implantação dos pipelines do LLM Twin na nuvem
•
Adicionando LLMOps ao LLM Twin
O caminho para o LLMOps: compreendendo suas raízes em DevOps e MLOps Para entender LLMOps, precisamos começar pela origem da área, que é o DevOps, pois grande parte dos princípios fundamentais é herdada de lá. Em seguida, passaremos para o MLOps para entender como o domínio do DevOps foi adaptado para dar suporte a sistemas de ML. Por fim, explicaremos o que é LLMOps e como ele surgiu a partir do MLOps após a ampla adoção de LLMs.
DevOps Entregar software manualmente é demorado, propenso a erros, envolve riscos de segurança e não escala. Assim, surgiu o DevOps para automatizar o processo de entrega de software em escala. Mais especificamente, o DevOps é usado no desenvolvimento de software, onde se
MANUAL DO ENGENHEIRO DE LLM GPT/LLMS ■ INTELIGÊNCIA ARTIFICIAL ■ MACHINE LEARNING ■ DEEP LEARNING ■ DATA SCIENCE
A inteligência artificial evolui rapidamente, e os Large Language Models (LLMs) lideram essa transformação. Este livro apresenta, de forma prática, como projetar, treinar e implantar LLMs em cenários reais utilizando boas práticas de MLOps. O leitor aprende a construir sistemas escaláveis, modulares e prontos para produção, indo além de notebooks isolados. O conteúdo aborda engenharia de dados, fine-tuning supervisionado, otimização de inferência, alinhamento de preferências e processamento em tempo real. Ideal para profissionais que desejam aplicar LLMs de forma eficiente e confiável em projetos reais. O que você vai encontrar: • Implementação de pipelines de dados robustos e gestão do ciclo de treinamento de LLMs • Criação e refinamento de LLMs com exemplos práticos • Introdução a LLMOps e princípios de MLOps, como orquestração e monitoramento de prompts • Fine-tuning supervisionado e avaliação de LLMs • Implantação de soluções completas com AWS e outras ferramentas • Desenvolvimento de sistemas escaláveis e modulares • Aplicações de RAG com construção de pipelines de features e inferência
Conheça mais livros em:
tech .
. com.br
“Manual do Engenheiro de LLM é um guia prático e essencial para quem deseja dominar aplicações com LLMs. Com exemplos reais, o livro aborda fine-tuning, RAG, MLOps e otimização de inferência, além de ferramentas como Hugging Face, MongoDB e Qdrant. Uma referência valiosa para engenheiros e profissionais de IA generativa.” — Antonio Gulli, Senior Director, Google
Paul Iusztin
é engenheiro sênior de ML e MLOps, com experiência em IA generativa, visão computacional e sistemas de ML em produção. Atuou na Metaphysic, CoreAI, Everseen e Continental, e é fundador da Decoding ML, plataforma educacional focada em aplicações reais de machine learning.
Maxime Labonne
é Head of Post-Training na Liquid AI, doutor em Machine Learning pelo Instituto Politécnico de Paris e Google Developer Expert em IA/ML. Contribui ativamente para a comunidade open source com cursos, ferramentas e modelos de IA, além de ser autor do best-seller Hands-On Graph Neural Networks Using Python.