Como executar o Llama 3 localmente: Um guia completo

A execução de grandes modelos de linguagem (LLMs), como o Llama 3, localmente se tornou um divisor de águas no mundo da IA. Com plataformas como a Hugging Face promovendo a implantação local, os usuários agora podem desfrutar de experiências ininterruptas e privadas com seus modelos.

Neste blog, saberemos por que devemos executar LLMs como o Llama 3 localmente e como acessá-los usando o GPT4ALL e o Ollama. Além disso, você aprenderá a servir modelos, a integrar o Llama 3 ao seu espaço de trabalho e, por fim, a usá-lo para desenvolver o aplicativo de IA. Não o usaremos apenas como um chatbot, mas também para aprimorar nosso fluxo de trabalho e criar projetos com ele.

Por que administrar a Llama 3 localmente?

Executar o Llama 3 localmente pode parecer assustador devido aos altos requisitos de RAM, GPU e capacidade de processamento. No entanto, os avanços em estruturas e otimização de modelos tornaram isso mais acessível do que nunca. Veja por que você deve considerar essa possibilidade:

• Acesso ininterrupto: Você não precisará se preocupar com limites de tarifas, tempo de inatividade e interrupções inesperadas do serviço.
• Desempenho aprimorado: A geração de respostas é rápida, sem atrasos ou latências. Mesmo em laptops de nível médio, você obtém velocidades de cerca de 50 tokens por segundo.
• Segurança aprimorada: Você tem controle total sobre as entradas usadas para ajustar o modelo, e os dados permanecem localmente no seu dispositivo.
• Redução de custos: Em vez de pagar altas taxas para acessar as APIs ou assinar o chatbot on-line, você pode usar o Llama 3 gratuitamente.
• Personalização e flexibilidade: Você pode personalizar os modelos usando hiperparâmetros, adicionar stop tokes e alterar configurações avançadas.
• Recursos off-line: Depois de fazer o download do modelo, você não precisa de uma conexão com a Internet para usá-lo.
• Propriedade: Você tem total propriedade e controle sobre o modelo, seus dados e seus resultados.

Leia nosso artigo, Os prós e contras de usar modelos de linguagem grandes (LLMs) na nuvem versus modelos de linguagem grandes (LLMs) na nuvem. Executando LLMs localmente, para saber mais sobre se o uso de LLMs localmente é adequado para você.

Usando o Llama 3 com o GPT4ALL

O GPT4ALL é um software de código aberto que permite que você execute modelos de linguagem grandes e populares em seu computador local, mesmo sem uma GPU. Ele é fácil de usar, o que o torna acessível a pessoas com formação não técnica.

Começaremos fazendo o download e a instalação do GPT4ALL no Windows, acessando a página oficial de download.

Depois de instalar o aplicativo, inicie-o e clique no botão "Downloads" para abrir o menu de modelos. Lá, você pode rolar a tela para baixo e selecionar o modelo "Llama 3 Instruct" e, em seguida, clicar no botão "Download".

Depois que o download for concluído, feche a guia e selecione o modelo Llama 3 Instruct clicando no menu suspenso "Choose a model" (Escolha um modelo).

Digite um prompt e comece a usá-lo como o ChatGPT. O sistema tem o kit de ferramentas CUDA instalado, portanto, ele usa a GPU para gerar uma resposta mais rápida.

Usando o Llama 3 com o Ollama

Agora, vamos tentar a maneira mais fácil de usar o Llama 3 localmente, baixando e instalando o Ollama.

O Ollama é uma ferramenta avançada que permite que você use LLMs localmente. Ele é rápido e vem com muitos recursos.

Depois de instalar o Ollama em seu sistema, abra o terminal/PowerShell e digite o comando.

ollama run llama3

Observação: O download do arquivo de modelo e a inicialização do chatbot no terminal levarão alguns minutos.

Escreva prompts ou comece a fazer perguntas, e o Ollama gerará a resposta dentro do seu terminal. A resposta do bate-papo é super rápida e você pode continuar fazendo perguntas de acompanhamento para se aprofundar no assunto.

Para sair do chatbot, basta digitar /bye .

Além desses dois softwares, você pode consultar o site Run LLMs Locally: 7 Simple Methods guia para você explorar aplicativos e estruturas adicionais.

Atendendo à Llama 3 localmente

A execução de um servidor local permite que você integre o Llama 3 a outros aplicativos e crie seu próprio aplicativo para tarefas específicas.

Inicie o servidor de inferência de modelo local digitando o seguinte comando no terminal.

ollama serve

Para verificar se o servidor está funcionando corretamente, vá até a bandeja do sistema, localize o ícone do Ollama e clique com o botão direito do mouse para visualizar os registros.

Isso o levará à pasta Ollama, onde você poderá abrir o arquivo `server.log` para visualizar informações sobre solicitações do servidor por meio de APIs e informações do servidor com registros de data e hora.

Acesso à API usando CURL

Você pode simplesmente acessar o servidor de inferência usando o comando CURL.

Basta fornecer o nome do modelo e o prompt e certificar-se de que o streaming esteja desativado para que você receba a mensagem completa.

curl http://localhost:11434/api/chat -d '{
  "model": "llama3",
  "messages": [
    { "role": "user", "content": "What are God Particles?" }
  ],
  "stream": false
}'

O comando CURL é nativo do Linux, mas você também pode usá-lo no Windows PowerShell, conforme mostrado abaixo.

Acessando a API usando o pacote Python

Você também pode instalar o pacote Ollama Python usando o PIP para acessar o servidor de inferência.

pip install ollama

O acesso à API em Python permite que você crie aplicativos e ferramentas com tecnologia de IA, e é muito fácil de usar.

Basta que você forneça às funções `ollama.chat` o nome do modelo e a mensagem, e ele gerará a resposta.

Observação: No argumento da mensagem, você também pode adicionar um prompt do sistema e um prompt do assistente para adicionar o contexto.

import ollama

response = ollama.chat(
    model="llama3",
    messages=[
        {
            "role": "user",
            "content": "Tell me an interesting fact about elephants",
        },
    ],
)
print(response["message"]["content"])

O pacote Ollama Python também fornece recursos como chamadas assíncronas e streaming, que permitem o gerenciamento eficaz das solicitações de API e aumentam a velocidade percebida do modelo.

Semelhante à API OpenAI, você pode criar uma função de bate-papo assíncrona e, em seguida, escrever código de streaming usando a função assíncrona, permitindo interações eficientes e rápidas com o modelo.

import asyncio
from ollama import AsyncClient

async def chat():
    """
    Stream a chat from Llama using the AsyncClient.
    """
    message = {
        "role": "user",
        "content": "Tell me an interesting fact about elephants"
    }
    async for part in await AsyncClient().chat(
        model="llama3", messages=[message], stream=True
    ):
        print(part["message"]["content"], end="", flush=True)


asyncio.run(chat())

Como você pode ver, o modelo exibe os tokens à medida que eles são gerados.

Você também pode usar a API do Python para criar o modelo personalizado, converter texto em embeddings e tratar erros. Você também pode copiar, excluir, puxar e empurrar os modelos.

Integração do Llama 3 no VSCode

Além de usar o Ollama como um chatbot ou para gerar respostas, você pode integrá-lo ao VSCode e usar o Llama 3 para recursos como autocompletar, sugestões de código com reconhecimento de contexto, escrita de código, geração de docstrings, teste de unidade e muito mais.

1. Primeiro, temos que inicializar o servidor de inferência Ollama digitando o seguinte comando no terminal.

ollama serve

2. Acesse as extensões do VSCode, procure a ferramenta "CodeGPT" e instale-a. O CodeGPT permite que você conecte qualquer provedor de modelo usando a chave da API.

3. Configure o CodeGPT clicando no ícone de bate-papo do CodeGPT no painel esquerdo. Altere o provedor do modelo para Ollama e selecione o modelo llama3:8b. Você não precisa fornecer uma chave de API, pois estamos executando-a localmente.

4. Escreva o prompt para gerar o código Python e, em seguida, clique no botão "Insert the code" (Inserir o código) para transferir o código para seu arquivo Python. Você também pode escrever instruções de acompanhamento para melhorar o código.

5. Além do assistente de codificação, você pode usar o CodeGPT para entender o código, refatorá-lo, documentá-lo, gerar o teste de unidade e resolver os problemas.

Se você quiser se sentir como um profissional em Python, consulte o guia Configurando o VSCode para Python para saber mais sobre o recurso principal do VSCode e personalizá-lo de acordo com suas necessidades.

Desenvolvimento de um aplicativo de IA localmente

Nesta seção, desenvolveremos um aplicativo com tecnologia de IA que lê arquivos docx de uma pasta designada, converte-os em embeddings e os armazena em um repositório de vetores.

Depois disso, usaremos uma pesquisa de similaridade para recuperar significados relevantes e fornecer respostas contextuais às suas perguntas.

Esse aplicativo permitirá que você compreenda rapidamente a essência dos livros e se aprofunde no desenvolvimento dos personagens.

Configuração

Primeiro, instalaremos todos os pacotes Python necessários para carregar os documentos, o armazenamento de vetores e as estruturas LLM.

pip install unstructured[docx] langchain langchainhub langchain_community langchain-chroma

Em seguida, inicie o servidor de inferência Ollama.

ollama serve

Carregando os documentos

É uma prática recomendada desenvolver e testar seu código no Jupyter Notebook antes de criar o aplicativo.

Carregaremos todos os arquivos docx da pasta usando o endereço DirectoryLoader.

from langchain_community.document_loaders import DirectoryLoader

loader = DirectoryLoader("C:/Users/abida/Desktop/Books", glob="**/*.docx")
books = loader.load()
len(books)

4

Você pode criar seu próprio chatbot com reconhecimento de contexto seguindo o tutorial, Chatbot Development with ChatGPT & LangChain: Uma abordagem com reconhecimento de contexto.

Dividir o texto

Não é possível alimentar o modelo com um livro inteiro, pois isso excederia sua janela de contexto. Para superar essa limitação, precisamos dividir o texto em partes menores e mais gerenciáveis que se encaixem confortavelmente na janela de contexto do modelo.

No nosso caso, converteremos todos os quatro livros em um tamanho de bloco de 500 caracteres.

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(books)

Embeddings de Ollama e armazenamento de vetores Chroma

Usaremos o Langchain para converter o texto em incorporação e armazená-lo no banco de dados do Chroma.

Estamos usando o modelo Ollama Llama 3 como um modelo de incorporação.

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings

vectorstore = Chroma.from_documents(
    documents=all_splits,
    embedding=OllamaEmbeddings(model="llama3", show_progress=True),
    persist_directory="./chroma_db",
)

OllamaEmbeddings: 100%|██████████| 23/23 [01:00<00:00,  2.63s/it]

Vamos testar nosso banco de dados de vetores realizando algumas pesquisas de similaridade.

question = "Who is Zahra?"
docs = vectorstore.similarity_search(question)
docs

Obtivemos quatro resultados que são semelhantes à pergunta.

Você pode se aprofundar no mundo do banco de dados vetorial e do Chroma DB lendo o tutorial . Aprenda a usar o Chroma DB: Um guia passo a passo.

Criação de cadeias de Langchain para o sistema de recuperação de perguntas e respostas

Para criar um sistema adequado de recuperação de perguntas e respostas, usaremos cadeias Langchain e começaremos a adicionar os módulos.

Em nossa cadeia de perguntas e respostas, vamos

1. Use o armazenamento de vetores como retriever e formate os resultados.
2. Depois disso, forneceremos o prompt do RAG. Você pode extrair isso facilmente do Langchain Hub.
3. Em seguida, forneceremos a função de inferência Ollama Llama 3.
4. No final, analisaremos os resultados apenas para exibir a resposta.

Simplificando, antes de passá-la pelo modelo Llama 3, sua pergunta será contextualizada usando a pesquisa de similaridade e o prompt RAG.

from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

llm = Ollama(model="llama3")

retriever = vectorstore.as_retriever()


def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)


rag_prompt = hub.pull("rlm/rag-prompt")
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

Você pode criar um aplicativo semelhante usando o LLamaIndex. Para fazer isso, siga o endereço LlamaIndex: Uma estrutura de dados para os aplicativos baseados em modelos de linguagem grandes (LLMs) tutorial.

Teste da cadeia de recuperação de Q&A

Faça perguntas relevantes sobre os livros para entender mais sobre a história.

question = "What is the story of the 'Gené is Missing' book?"
qa_chain.invoke(question)

Como podemos ver, o uso de livros como contexto fornece uma resposta precisa.

'Based on the provided context, "Gené is Missing" appears to be a mystery novel that revolves around uncovering the truth about Gené\'s life and potential involvement in murders. The story follows different perspectives, including Simon trying to prove his innocence, flashbacks of Gené\'s past, and detective Jacob investigating the case.'

Vamos agora fazer uma pergunta sobre o personagem.

question = "Who is Arslan?"
qa_chain.invoke(question)

Foi gerada uma resposta precisa.

'Arslan is Zahra\'s brother\'s best friend. He is someone that Zahra visits in the book "A Boy with Honest Dreams" by Abid Ali Awan to gather information about Ali.'

Criação do aplicativo de IA

Para criar um aplicativo de IA completo que seja executado sem problemas no seu terminal, combinaremos todo o código das seções anteriores em um único arquivo Python.

code AI_app.py

Além disso, aprimoraremos o código para habilitar a consulta interativa, permitindo que você faça perguntas ao aplicativo repetidamente até encerrar explicitamente a sessão digitando 'exit'.

from langchain_chroma import Chroma
from langchain_community.embeddings import OllamaEmbeddings
from langchain import hub
from langchain_community.llms import Ollama
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# loading the vectorstore
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=OllamaEmbeddings(model="llama3"))

# loading the Llama3 model
llm = Ollama(model="llama3")

# using the vectorstore as the retriever
retriever = vectorstore.as_retriever()

# formating the docs
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# loading the QA chain from langchain hub
rag_prompt = hub.pull("rlm/rag-prompt")

# creating the QA chain
qa_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# running the QA chain in a loop until the user types "exit"
while True:
    question = input("Question: ")
    if question.lower() == "exit":
        break
    answer = qa_chain.invoke(question)

    print(f"\nAnswer: {answer}\n")

Execute o aplicativo escrevendo `Python` e o nome do arquivo no terminal.

python AI_app.py

Isso é legal. Criamos nosso próprio aplicativo RAG AI localmente com poucas linhas de código.

Todo o código-fonte deste tutorial está disponível no repositório do GitHub kingabzpro/using-llama3-locally. Dê uma olhada e lembre-se de marcar com uma estrela o repositório.

Conclusão

A capacidade de executar o Llama 3 localmente e criar aplicativos não teria sido possível sem os esforços incansáveis da comunidade de código aberto de IA. Essa comunidade de pessoas dedicadas trabalha dia e noite para tornar a IA acessível a todos, permitindo que aproveitemos o poder desses modelos e criemos nossos próprios sistemas.

Com isso, podemos garantir a privacidade e a segurança dos dados e, ao mesmo tempo, evitar taxas de assinatura ou de API. Se você quiser fazer parte desse ecossistema, contribua com o projeto, divulgue-o e também faça doações.

Neste tutorial, aprendemos a usar o Llama 3 localmente em um laptop. Também aprendemos sobre o servidor de inferência e como podemos usá-lo para integrar o Llama 3 ao VSCode.

Por fim, criamos o sistema de recuperação de perguntas e respostas usando Langchain, Chroma e Ollama. Os dados nunca saíram do sistema local, e você nem precisou pagar um único dólar para construí-lo. Além dos aplicativos mais simples, você pode criar sistemas complexos usando as mesmas ferramentas que usamos neste tutorial.

A próxima etapa natural da sua jornada de aprendizado é seguir o programa de habilidades Developing Large Language Models. Você aprenderá sobre aprendizagem profunda, arquitetura de transformadores, como ajustar LLMs e LLMOps.