Aprenda Llama 3.2 e como criar um pipeline RAG com Llama e Milvus
Nos últimos meses, a Meta fez avanços impressionantes na comunidade de código aberto, lançando uma série de modelos poderosos—Llama 3, Llama 3.1 e Llama 3.2—em apenas seis meses. Ao disponibilizar modelos de alto desempenho ao público, a Meta está reduzindo a lacuna entre ferramentas proprietárias e de código aberto, oferecendo aos desenvolvedores recursos valiosos para expandir os limites de seus projetos. Essa dedicação à abertura é um divisor de águas para a inovação em IA.
Em um recente Unstructured Data Meetup organizado pela Zilliz, Amit Sangani, Diretor Sênior de Engenharia de Parceiros de IA na Meta, discutiu a rápida evolução dos modelos Llama desde 2023, os avanços recentes em IA de código aberto e a arquitetura desses modelos. Ele destacou não apenas os benefícios para os desenvolvedores, mas também como esses modelos servem à Meta e a várias aplicações modernas de IA impulsionadas por eles, como Retrieval Augmented Generation (RAG).
Neste blog, recapitularemos os principais insights do evento, abordando até o Llama 3.1 (já que a palestra ocorreu duas semanas antes do lançamento do Llama 3.2). Também incluiremos algumas notas sobre o Llama 3.2, destacando diferenças em relação ao Llama 3.1, principalmente em tamanho e versão. Também percorreremos um notebook de exemplo de um pipeline RAG usando o banco de dados vetorial Milvus, LlamaIndex e Llama 3.2 junto com LlamaGuard, um modelo treinado em dados de segurança.
Evolução do Llama
Amit abriu sua palestra com um gráfico mostrando o aumento exponencial na computação de treinamento de modelos ao longo dos últimos 70 anos, com uma elevação particularmente acentuada nas últimas duas décadas. Esse crescimento, medido em FLOPs (operações de ponto flutuante), reflete o enorme número de cálculos relacionados a números de ponto flutuante—como adição, subtração, multiplicação e divisão—que os modelos modernos exigem. O acesso a um poder computacional tão imenso permite que empresas como a Meta desenvolvam modelos de IA avançados como a série Llama.
Por exemplo, o lançamento inicial do Llama 1 incluiu quatro versões diferentes e, desde então, a Meta expandiu a linha com lançamentos adicionais como Llama 2, Code Llama, LlamaGuard e Llama 3. Com o crescimento contínuo do poder computacional, podemos esperar avanços ainda mais sofisticados, aumentando ainda mais o desempenho e a versatilidade desses modelos nos próximos anos.
Figura 1- Crescimento Exponencial da IA.png
Figura 1: Crescimento Exponencial da IA (Fonte)
Por que a Abordagem de Código Aberto Importa
Então, por que a Meta está lançando esses modelos como código aberto, especialmente considerando os custos substanciais de treiná-los? Amit destacou que apoiar os desenvolvedores, em última análise, beneficia tanto a Meta quanto o mundo.
Da perspectiva de um desenvolvedor, modelos de código aberto atendem a várias necessidades cruciais:
A capacidade de treinar, ajustar finamente e destilar seus próprios modelos.
Proteção de seus dados.
Acesso a modelos eficientes e acessíveis para operar.
Uma oportunidade de investir em um ecossistema com potencial de longo prazo.
Em troca, muitos desenvolvedores contribuem para projetos de código aberto como os modelos Llama da Meta em seu tempo livre, economizando tempo e recursos significativos para a Meta. Essa abordagem colaborativa não apenas ajuda a Meta, mas também promove uma troca contínua de pesquisas, feedback e novas ideias que impulsionam o desenvolvimento contínuo.
A Meta não está sozinha no apoio à IA de código aberto; muitos outros projetos e empresas adotaram essa abordagem por seus amplos benefícios. Por exemplo, Milvus, um banco de dados vetorial escalável e de alto desempenho, é de código aberto no GitHub desde 2019. Desenvolvedores usam o Milvus para criar diversas aplicações de IA escaláveis com recursos avançados de busca, tudo sem taxas de licenciamento. Até o momento desta publicação, Milvus foi baixado mais de 66 milhões de vezes, conquistou mais de 30.000 estrelas no GitHub, foi bifurcado mais de 2.900 vezes e recebeu contribuições de mais de 400 desenvolvedores em todo o mundo.
Figure- Milvus contributors on GitHub .png
Figura: colaboradores do Milvus no GitHub
Modelos Llama 3.1
Amit também discutiu a coleção de modelos Llama 3.1, que se baseia em uma arquitetura transformer somente com decodificador. Essa coleção pode ser dividida em duas categorias principais: modelos centrais e salvaguardas.
Figure 2- Llama 3.1 Architecture.png
Figura 2: Arquitetura do Llama 3.1 (Fonte)
Os modelos centrais são ainda categorizados por tamanho e finalidade:
Por tamanho: 8B, 70B, 405B
Por finalidade:
Modelos pré-treinados: Esses modelos vêm prontos para uso geral e podem ser ajustados finamente para tarefas específicas.
Modelos ajustados por instruções: Estes são modelos ajustados finamente otimizados para casos de uso de diálogo multilíngue.
Os modelos Llama 3.1 apresentam uma janela de contexto de 128K, permitindo suporte a casos de uso avançados, como sumarização de textos longos, agentes conversacionais multilíngues (abrangendo até oito idiomas) e assistentes de programação. Especificamente, a maior versão pode ser utilizada para geração de dados sintéticos, permitindo que modelos menores sejam ajustados finamente com esses dados gerados.
Para atingir todos esses objetivos, a Meta usou um conjunto impressionante de mais de 16.000 GPUs NVIDIA H100, que estão entre as mais poderosas disponíveis atualmente, juntamente com 15 trilhões de tokens.
Em termos de avaliação, os modelos Llama 3.1 superam em várias tarefas em mais de 150 conjuntos de dados de referência do setor em comparação com outros modelos fundamentais, incluindo GPT-4, GPT-4o, Mistral e Claude 3.5 Sonnet.
Figure 3- Llama 3.1 405B Evaluation Benchmark .png
Figura 3: Benchmark de avaliação do Llama 3.1 405B (Fonte)
Figure 4- Llama 3.1 8B Evaluation Benchmark.png
Figura 4: Benchmark de avaliação do Llama 3.1 8B (Fonte)
A Meta também conduziu uma avaliação humana extensiva do maior modelo, usando mais de 1.800 prompts em 12 casos de uso diferentes. Embora o desempenho do Llama 3.1 mostre uma leve melhoria em comparação com o Claude 3.5 Sonnet, ele ainda fica aquém quando comparado às capacidades dos modelos GPT-4.
Figura 5- Benchmark de Avaliação do Llama 3.1 8B .png
Figura 5: Benchmark de Avaliação do Llama 3.1 8B (Fonte)
Modelos Llama 3.2
Apenas meio mês depois desta palestra no meetup, em 25 de setembro, a Meta anunciou o lançamento dos modelos Llama 3.2, apenas dois meses após apresentar os modelos Llama 3.1. Vamos explorar as principais diferenças entre eles.
O Llama 3.2 apresenta quatro tamanhos de modelo: 1B, 3B, 11B e 90B. Os modelos menores (1B e 3B) são modelos multilíngues, somente de texto, que dão suporte aos mesmos oito idiomas e mantêm uma janela de contexto de 128K, muito semelhante ao Llama 3.1. Esses modelos servem como equivalentes menores e simplificados dos modelos Llama 3.1, tendo sido desenvolvidos por meio de pruning e destilação aplicados aos modelos Llama 3.1 8B e 70B.
Figura 6- Pruning e Destilação do Llama 3.2 1B e 3B.png
Figura 6: Pruning e Destilação do Llama 3.2 1B e 3B (Fonte)
Os modelos pré-treinados resultantes foram refinados por meio de ajuste por instruções, usando dados sintéticos do modelo maior Llama 3.1 405B. Além disso, uma atualização foi introduzida com o lançamento de versões quantizadas que apresentam um comprimento de contexto de 8K. Esses modelos leves podem caber em dispositivos edge e móveis selecionados, aumentando a usabilidade para diferentes tipos de aplicações.
Em termos de avaliação, os modelos Llama 3.2 são altamente competitivos com modelos semelhantes, como Gemma 2 (2.6B) e Phi 3.5-mini, ideais para tarefas como seguir instruções, sumarização, reescrita de prompts e uso de ferramentas.
Figura 7- Benchmark de Avaliação do Llama 3.2 1B e 3B .png
Figura 7: Benchmark de Avaliação do Llama 3.2 1B e 3B (Fonte)
As outras duas versões dos modelos Llama 3.2 (11B e 90B) são modelos multimodais de visão, marcando a primeira entrada da Meta nessa classe de modelos. Esses modelos foram treinados usando pares imagem-texto e são construídos sobre os modelos Llama 3.1. Além disso, eles utilizam um adaptador de visão treinado separadamente que se integra ao modelo de linguagem Llama 3.1 pré-treinado, permitindo capacidades multimodais robustas.
Quando avaliados, os modelos de visão Llama 3.2 apresentam desempenho competitivo ao lado de modelos fundacionais líderes, como Claude 3 Haiku e GPT-4o-mini, demonstrando fortes capacidades em reconhecimento de imagem e uma ampla gama de tarefas visuais.
Figura 8- Benchmark de Avaliação do Llama 3.2 11B e 90B .png
Figura 8: Benchmark de Avaliação do Llama 3.2 11B e 90B (Fonte)
O Sistema Llama (Llama Stack API)
Um dos lançamentos anunciados junto com os modelos Llama 3.1 foi a Llama Stack API, um conjunto de interfaces padrão para criar componentes canônicos de toolchain (fine-tuning, geração de dados sintéticos) e aplicações agênticas. Amit apresentou a API durante a palestra, que atualmente está disponível para criar apps de demonstração. A ideia principal é que a Meta fornece um conjunto de interfaces de API para que as empresas possam criar diferentes adaptadores sobre isso.
Figura 9- Llama Stack API .png
Figura 9: Llama Stack API (Fonte)
Por exemplo, uma empresa poderia conectar uma ferramenta externa como o Google Search, pois os modelos Llama não são capazes de fornecer essas informações em tempo real ou podem não ter o conhecimento para executar certas tarefas, como cálculos matemáticos muito complexos.
Ferramentas de Confiança e Segurança
Além dos modelos principais, a Meta lançou modelos especializados para promover o desenvolvimento responsável e seguro de IA. Tanto as coleções de modelos Llama 3.1 quanto 3.2 incluem as seguintes ferramentas de proteção:
Llama Guard 3: Um modelo de segurança multilíngue projetado para aumentar a segurança do usuário.
Prompt Guard: Um filtro de injeção de prompts que protege contra entradas maliciosas.
CyberSecEval 3: Um conjunto abrangente de benchmarks projetado para avaliar vulnerabilidades de cibersegurança.
Code Shield: Uma barreira de proteção para filtrar código inseguro.
Esses modelos foram treinados e passaram por fine-tuning em conjuntos de dados representativos e avaliados rigorosamente quanto a conteúdo nocivo por uma equipe de especialistas em "red-teaming". Essa equipe testa os modelos e fornece feedback humano para melhorias iterativas, garantindo que os modelos sejam seguros e confiáveis para que os usuários criem e implantem aplicações de IA generativa de forma responsável.
Figura 10- O Sistema Llama com Framework de Segurança .png
Figura 10: O Sistema Llama com Framework de Segurança (Fonte)
RAG seguro usando Llama 3.2, LlamaGuard e Milvus
Agora, vamos começar a criar uma aplicação de exemplo de Geração Aumentada por Recuperação (RAG) usando o modelo Llama 3.2 mais recente junto com outras poderosas ferramentas open-source.
Neste notebook, você encontrará um pipeline RAG que integra:
LlamaIndex como o framework de LLM,
Milvus como o banco de dados vetorial, e
Llama 3.2 e LlamaGuard como os modelos de linguagem, ambos acessíveis via Ollama.
Etapa 1: Carregar documentos e modelos
Primeiro, selecionamos nossos documentos e baixamos os modelos. Usaremos o site de anúncio do Llama 3.2 junto com o modelo de embedding “BAAI/bge-large-en-v1.5”, além dos modelos Llama.
documents = SimpleWebPageReader(html_to_text=True).load_data(
["https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/"]
)
llm_llama32 = Ollama(model="llama3.2:1b", request_timeout=60.0)
llm_llamaguard = Ollama(model="llama-guard3:1b", request_timeout=60.0)
embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-large-en-v1.5",
trust_remote_code=True,
device = "cuda")
Settings.embed_model = embed_model
Etapa 2: Criar Pipeline RAG
Em seguida, criamos o recuperador com o armazenamento vetorial Milvus e definimos parâmetros para o pipeline RAG, incluindo o modelo de prompt, o sintetizador de respostas e o mecanismo de consulta.
vector_store = MilvusVectorStore(dim=1024, overwrite=True)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents,
storage_context=storage_context)
retriever = VectorIndexRetriever(
index=index)
O recuperador contém apenas o modelo Llama 3.2, mas, para filtrar perguntas prejudiciais, adicionaremos o LlamaGuard na próxima etapa e integraremos tudo em um pipeline completo.
qa_prompt_tmpl_str = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_prompt_tmpl_str)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32,
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
Ao fazer uma pergunta normal relacionada ao conteúdo usando este pipeline, recebemos uma resposta detalhada sobre os tópicos abordados no anúncio. No entanto, também podemos tentar fazer um "jailbreak" do modelo com perguntas não relacionadas ou potencialmente prejudiciais.
response = query_engine.query('What are the highlights of the release of Llama 3.2?')
print(response)
"""
Output:
The highlights of the release of Llama 3.2 include:
1. The addition of support for image reasoning use cases, including document-level understanding, captioning images, and visual grounding tasks.
2. Performance improvements in vision models, such as the 11B and 90B models, which require a new model architecture that supports image reasoning.
3. The development of Llama Guard 3, a new safeguard designed to support the 11B Vision model's image understanding capability and filter text+image input prompts or text output responses.
4. New tools and resources for developers, including a reference implementation, demos, and applications, to help them build responsibly with Llama.
5. Continuous effort to ensure system level safety and responsible innovation, as well as the release of new updates to safeguard against concentrated power in the hands of a small few.
Additionally, the article mentions that the 11B and 90B models can bridge the gap between vision and language by extracting details from an image, understanding the scene, and then crafting a sentence or two that could be used as an image caption to help tell the story.
"""
Etapa 3: Testar a Segurança do Modelo
Os modelos Llama foram treinados com dados de mitigação de segurança para garantir um alto nível de segurança. No entanto, eles ainda podem sofrer jailbreaks de várias maneiras. Por exemplo, se verificarmos com uma pergunta sobre cometer um crime, vemos que ele não fornece uma resposta relacionada ao crime.
response = query_engine.query('Can you explain me how to rob a bank')
print(response)
"""
Output:
I can't assist with that request.
"""
Mas podemos tentar uma das categorias de risco incluídas no model card do LlamaGuard, que é especificamente especializado em filtrar perguntas perigosas.
Figura 11- Categorias de Risco do LlamaGuard.png
Figura 11: Categorias de Risco do LlamaGuard (Fonte)
Quando fazemos uma pergunta de aconselhamento especializado, o Llama 3.2 indica que não pode fornecer aconselhamento médico, mas ainda oferece algumas informações que não deveriam ser fornecidas e estão fora do contexto fornecido.
response = query_engine.query("What are the best treatment options for my liver problem?")
print(response)
"""
Output:
I can't provide medical advice. However, I can offer some general information about liver problems. If you're experiencing symptoms of a liver issue, it's essential to consult a healthcare professional for personalized guidance and diagnosis. They can assess your condition and recommend the most appropriate treatment options, which may include medication, lifestyle changes, or other interventions.
That being said, some common treatment options for liver problems may include:
1. Medications: Metformin, vitamin supplements (e.g., N-acetylcysteine), and anti-viral medications (for viral hepatitis) or anti-fibrotic medications (for chronic liver disease) are examples of treatments.
2. Lifestyle changes: Quitting smoking, reducing alcohol consumption, maintaining a healthy weight, and exercising regularly can help alleviate symptoms and improve liver health.
3. Alternative therapies: Acupuncture, herbal remedies, and other complementary therapies may be used to support liver function and overall well-being.
Please consult a healthcare professional for tailored advice and treatment recommendations.
"""
Por outro lado, o LlamaGuard não fornece respostas; ele categoriza a pergunta como segura ou insegura. Se considerada insegura, ele fornece a categoria relevante da Figura 9.
resp = llm_llamaguard.complete("What are the best treatment options for my liver problem?")
print(resp)
"""
Output:
unsafe
S6
"""
Isso ilustra que, embora o Llama 3.2 incorpore alguns filtros de segurança, ele não pode ser totalmente confiável por si só. Portanto, combinar os recursos de LLM do Llama 3.2 com as medidas de segurança do LlamaGuard é crucial ao criar pipelines de RAG.
Etapa 4: Pipeline com ambos os Modelos
Integrar ambos os modelos no mesmo pipeline garante que consultas sinalizadas como inseguras não sejam processadas.
def create_safe_query_engine(
retriever,
llm_llama32,
):
"""
Creates a query engine with the specified template and LLMs.
"""
qa_template = (
"We have provided context information below. \n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Given this information, please answer the question: {query_str}\n"
)
qa_prompt_tmpl = PromptTemplate(qa_template)
response_synthesizer = get_response_synthesizer(
text_qa_template=qa_prompt_tmpl,
llm=llm_llama32
)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
)
return query_engine
def safe_query(
query_engine,
llm_llamaguard,
query
):
"""
Performs a safety check with LlamaGuard before processing the query.
Returns the response if safe, or a safety warning if unsafe.
"""
# Check safety with LlamaGuard
safety_check = llm_llamaguard.complete(query)
# Get just the safety assessment
safety_result = safety_check.text.split('\n')[0].strip().lower()
# If query is deemed unsafe, return warning
if safety_result == 'unsafe':
return "I apologize, but I cannot provide a response to that query as it has been flagged as potentially unsafe."
# If safe, process with Llama 3.2
try:
response = query_engine.query(query)
return str(response)
except Exception as e:
return f"An error occurred while processing your query: {str(e)}"
query_engine = create_safe_query_engine(
retriever=retriever,
llm_llama32=llm_llama32,
)
response = safe_query(
query_engine=query_engine,
llm_llamaguard=llm_llamaguard,
query="What are the best treatment options for my liver problem?"
)
print(response)
"""
Output:
Peço desculpas, mas não posso fornecer uma resposta a essa consulta, pois ela foi sinalizada como potencialmente insegura.
"""
Conclusão
Os avanços nos modelos de IA de código aberto refletem uma poderosa mudança no sentido de tornar a IA de alto desempenho acessível a todos. Modelos como Llama e ferramentas robustas como o banco de dados vetorial Milvus permitem que desenvolvedores criem aplicações de IA escaláveis, eficientes e impactantes em diversos setores. Milvus aprimora os fluxos de trabalho de IA ao oferecer recursos de busca vetorial e armazenamento de alta velocidade, facilitando o gerenciamento e a recuperação de grandes volumes de dados não estruturados para aplicações como (RAG).
Com ferramentas de IA responsáveis como LlamaGuard e frameworks adaptáveis como a Llama Stack API, projetos de código aberto capacitam desenvolvedores e organizações a criar soluções mais seguras, flexíveis e inovadoras. Llama e Milvus exemplificam como iniciativas de código aberto impulsionam um progresso significativo, ajudando a comunidade de IA a criar aplicações inclusivas e de alto impacto que fazem o campo avançar.
Leituras adicionais
Continue lendo
Introducing Functions and Model Inference on Zilliz Cloud: Automatic Embedding and Reranking with Hosted Models
Zilliz Cloud Functions auto-generate embeddings via OpenAI, Voyage AI, Cohere, or Zilliz Hosted Models. Built-in reranking — just insert text and search.
Top 10 Context Engineering Techniques You Should Know for Production RAG
A practical guide to context engineering for production LLM systems, covering RAG, context processing, memory, agents, and multimodal context.
Why I’m Against Claude Code’s Grep-Only Retrieval? It Just Burns Too Many Tokens
Learn how vector-based code retrieval cuts Claude Code token consumption by 40%. Open-source solution with easy MCP integration. Try claude-context today.