Usando Llamafiles para simplificar a execução do LLM

Introdução

Executar grandes modelos de linguagem sempre foi um processo tedioso. É necessário baixar um conjunto de software de terceiros para carregar esses LLMs ou baixar Python e criar um ambiente baixando várias bibliotecas Pytorch e HuggingFace. Se estiver adotando a abordagem Pythonic, é necessário passar pelo processo de escrever o código para baixar e executar o modelo. Este guia abordará uma abordagem mais fácil para executar esses LLMs.

Objetivos de aprendizagem

• Entenda os desafios da execução tradicional do LLM
• Compreenda o conceito inovador de Llamafiles
• Aprenda a baixar e executar seus próprios executáveis ​​do Llamafile com facilidade
• Aprendendo a criar Llamfiles a partir de LLMs quantizados
• Identifique as limitações desta abordagem

Este artigo foi publicado como parte do Blogatona de Ciência de Dados.

Problemas com grandes modelos de linguagem

Os Large Language Models (LLMs) revolucionaram a forma como interagimos com computadores, gerando texto, traduzindo idiomas, escrevendo diversos tipos de conteúdo criativo e até mesmo respondendo às suas perguntas de forma informativa. No entanto, executar esses modelos poderosos em seu computador costuma ser um desafio.

Para executar os LLMs, temos que baixar o Python e muitas dependências de IA e, além disso, ainda temos que escrever o código para baixá-los e executá-los. Mesmo ao instalar UIs prontas para uso para modelos de linguagem grande, isso envolve muitas configurações, que podem facilmente dar errado. Instalá-los e executá-los como um executável não foi um processo simples.

O que são arquivos Llama?

Llamafiles são criados para funcionar facilmente com modelos populares de linguagem grande de código aberto. Estes são executáveis ​​de arquivo único. É como baixar um LLM e executá-lo como um executável. Não há necessidade de instalação inicial de bibliotecas. Tudo isso foi possível graças ao llama.cpp e à cosmopolita libc, que faz com que os LLMs rodem em diferentes sistemas operacionais.

O llama.cpp foi desenvolvido por Georgi Gerganov para executar grandes modelos de linguagem no formato quantizado para que possam ser executados em uma CPU. O llama.cpp é uma biblioteca C que nos permite executar LLMs quantizados em hardware de consumo. Por outro lado, a cosmopolita libc é outra biblioteca C que constrói um binário que pode rodar em qualquer sistema operacional (Windows, Mac, Ubuntu) sem a necessidade de um intérprete. Portanto, o Llamafile é construído sobre essas bibliotecas, o que permite criar LLMs executáveis ​​de arquivo único

Os modelos disponíveis estão no formato quantizado GGUF. GGUF é um formato de arquivo para modelos de linguagem grande desenvolvido por Georgi Gerganov, o criador do llama.cpp. O GGUF é um formato para armazenar, compartilhar e carregar modelos de linguagem grande de maneira eficaz e eficiente em CPUs e GPUs. O GGUF usa uma técnica de quantização para compactar os modelos de seu ponto flutuante original de 16 bits para um formato inteiro de 4 ou 8 bits. Os pesos deste modelo quantizado podem ser armazenados neste formato GGUF

Isso torna mais simples a execução de modelos de 7 bilhões de parâmetros em um computador com VRAM de 16 GB. Podemos executar os modelos de linguagem grande sem a necessidade de uma GPU (embora o Llamafile até nos permita executar os LLMs em uma GPU). No momento, os arquivos lhama de modelos populares de linguagem grande de código aberto, como LlaVa, Mistral e WizardCoder, estão prontamente disponíveis para download e execução

Executáveis ​​One Shot

Nesta seção, baixaremos e tentaremos executar um LlaVa Llamafile multimodal. Aqui não trabalharemos com GPU e rodaremos o modelo em CPU. Vá para o repositório oficial do Llamafile GitHub clicando em SUA PARTICIPAÇÃO FAZ A DIFERENÇA e baixando o modelo LlaVa 1.5.

Baixe o modelo

A imagem acima mostra todos os modelos disponíveis com seus nomes, tamanhos e links para download. O LlaVa 1.5 tem cerca de 4 GB e é um multimodelo poderoso que pode compreender imagens. O modelo baixado é um modelo de 7 bilhões de parâmetros quantizado em 4 bits. Após baixar o modelo, acesse a pasta onde ele foi baixado.

Em seguida, abra o CMD, navegue até a pasta onde este modelo foi baixado, digite o nome do arquivo que baixamos e pressione Enter.

llava-v1.5-7b-q4.llamafile

Para usuários de Mac e Linux

Para Mac e Linux, por padrão, a permissão de execução está desativada para este arquivo. Portanto, temos que fornecer a permissão de execução para o arquivo lhama, o que podemos fazer executando o comando abaixo.

chmod +x llava-v1.5-7b-q4.llamafile

Isto é para ativar a permissão de execução para o arquivo llava-v1.5-7b-q4.llama. Além disso, adicione “./” antes do nome do arquivo para executá-lo no Mac e Linux. Depois de pressionar a palavra-chave enter, o modelo será enviado para a RAM do sistema e mostrará a seguinte saída.

Em seguida, o navegador irá aparecer e o modelo estará rodando na URL http://127.0.0.1:8080/

A imagem acima mostra o prompt padrão, nome de usuário, nome LLM, modelo de prompt e modelo de histórico de bate-papo. Eles podem ser configurados, mas por enquanto iremos com os valores padrão.

Abaixo, podemos ainda verificar os hiperparâmetros configuráveis ​​​​do LLM como Top P, Top K, Temperatura e outros. Mesmo estes, vamos deixá-los ser o padrão por enquanto. Agora vamos digitar algo e clicar em enviar.

Na foto acima podemos ver que digitamos uma mensagem e até recebemos uma resposta. Abaixo disso, podemos verificar que estamos obtendo cerca de 6 tokens por segundo, o que é um bom token/segundo, considerando que estamos rodando inteiramente na CPU. Desta vez, vamos tentar com uma imagem.

Embora não esteja 100% certo, o modelo quase conseguiu acertar a maioria das coisas na imagem. Agora vamos conversar por vários turnos com o LlaVa para testar se ele se lembra do histórico de bate-papo.

Na foto acima, podemos ver que o LlaVa LLM conseguiu manter bem a conversa. Poderia absorver o histórico da conversa e então gerar as respostas. Embora a última resposta gerada não seja totalmente verdadeira, ela reuniu a conversa anterior para gerá-la. Dessa forma, podemos baixar um arquivo lhama e apenas executá-lo como um software e trabalhar com os modelos baixados.

Criando arquivos Llama

Vimos uma demonstração do Llamafile que já estava presente no GitHub oficial. Muitas vezes, não queremos trabalhar com estes modelos. Em vez disso, desejamos criar executáveis ​​de arquivo único de nossos modelos de linguagem grande. Nesta seção, passaremos pelo processo de criação de executáveis ​​de arquivo único, ou seja, arquivos lhama a partir de LLMs quantizados.

Selecione um LLM

Começaremos primeiro selecionando um modelo de linguagem grande. Para esta demonstração, selecionaremos uma versão quantizada do TinyLlama. Aqui, estaremos baixando o modelo GGUF quantizado de 8 bits do TinyLlama (você pode clicar SUA PARTICIPAÇÃO FAZ A DIFERENÇA para ir ao HuggingFace e baixar o modelo)

Baixe o arquivo Llama mais recente

O zip do llamafile mais recente do link oficial do GitHub pode ser baixado. Além disso, baixe o zip e extraia o arquivo zip. A versão atual deste artigo é lhama file-0.6. Após a extração da lhama, a pasta bin com a pasta file conterá os arquivos como na imagem abaixo.

Agora mova o modelo quantizado de 8 bits do TinyLlama baixado para esta pasta bin. Para criar os executáveis ​​de arquivo único, precisamos criar um arquivo .args na pasta bin do llamafile. A este arquivo, precisamos adicionar o seguinte conteúdo:

-m
tinyllama-1.1b-chat-v0.3.Q8_0.gguf
--host
0.0.0.0
...

• A primeira linha indica o sinalizador -m. Isso informa ao lhamafile que estamos carregando os pesos de um modelo.
• Na segunda linha, especificamos o nome do modelo que baixamos, que está presente no mesmo diretório onde está o arquivo .args, ou seja, a pasta bin do arquivo lhama.
• Na terceira linha, adicionamos o sinalizador host, indicando que executamos o arquivo executável e queremos hospedá-lo em um servidor web.
• Por fim, na última linha, mencionamos o endereço onde queremos hospedar, que mapeia para localhost. Seguidos por isso estão os três pontos, que especificam que podemos passar argumentos para nosso arquivo de lhama assim que ele for criado.
• Adicione essas linhas ao arquivo .args e salve-o.

Para usuários do Windows

Agora, a próxima etapa é para os usuários do Windows. Se estivermos trabalhando no Windows, precisávamos ter instalado o Linux via WSL. Caso contrário, clique SUA PARTICIPAÇÃO FAZ A DIFERENÇA para seguir as etapas de instalação do Linux por meio do WSL. No Mac e no Linux, nenhuma etapa adicional é necessária. Agora abra a pasta bin da pasta llamafile no terminal (se estiver trabalhando no Windows, abra este diretório no WSL) e digite os seguintes comandos.

cp llamafile tinyllama-1.1b-chat-v0.3.Q8_0.llamafile

Aqui, estamos criando um novo arquivo chamado tinyllama-1.1b-chat-v0.3.Q3_0.llamafile; ou seja, estamos criando um arquivo com a extensão .llamafile e movendo o arquivo llamafile para esse novo arquivo. Agora, em seguida, digitaremos o próximo comando.

./zipalign -j0 tinyllama-1.1b-chat-v0.3.Q8_0.llamafile tinyllama-1.1b-chat-v0.3.Q8_0.gguf .args

Aqui trabalhamos com o arquivo zipalign que veio quando baixamos o llamafile zip do GitHub. Trabalhamos com este comando para criar o arquivo lhama para nosso TinyLlama quantizado. Para este comando zipalign, passamos o arquivo tinyllama-1.1b-chat-v0.3.Q8_0.llama que criamos na etapa anterior e, em seguida, passamos o arquivo tinyllama-1.1b-chat-v0.3.Q8_0.llama modelo que temos na pasta bin e finalmente passamos o arquivo .args que criamos anteriormente.

Isso finalmente produzirá nosso arquivo executável tinyllama-1.1b-chat-v0.3.Q8_0.llamafile. Para garantir que estamos na mesma página, a pasta bin agora contém os seguintes arquivos.

Agora podemos executar o arquivo tinyllama-1.1b-chat-v0.3.Q8_0.llama da mesma forma que fizemos antes. No Windows, você pode até renomear o arquivo .llama para .exe e executá-lo clicando duas vezes nele.

Servidor compatível com OpenAI

Esta seção examinará como servir LLMs por meio do Llamfile. Percebemos que quando executamos o arquivo lhama, o navegador se abre e podemos interagir com o LLM através da WebUI. Isso é basicamente o que chamamos de hospedagem do Modelo de Linguagem Grande.

Uma vez executado o Llamafile, podemos interagir com o respectivo LLM como um endpoint porque o modelo está sendo servido no host local na PORTA 8080. O servidor segue o protocolo OpenAI API, ou seja, semelhante ao OpenAI GPT Endpoint, tornando assim é fácil alternar entre o modelo OpenAI GPT e o LLM rodando com Llamafile.

Aqui, executaremos o arquivo de lhama TinyLlama criado anteriormente. Agora, isso deve estar rodando no localhost 8080. Vamos agora testá-lo através da própria API OpenAI em Python

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8080/v1", 
    api_key = "sk-no-key-required"
)
completion = client.chat.completions.create(
    model="TinyLlama",
    messages=[
        {"role": "system", "content": "You are a usefull AI 
        Assistant who helps answering user questions"},
        {"role": "user", "content": "Distance between earth to moon?"}
    ]
)
print(completion.choices[0].message.content)

• Aqui trabalhamos com a biblioteca OpenAI. Mas em vez de especificar o endpoint OpenAI, especificamos a URL onde nosso TinyLlama está hospedado e fornecemos o “sk-no-token obrigatório” para api_key
• Então, o cliente se conectará ao nosso endpoint TinyLlama
• Agora, da mesma forma que trabalhamos com o OpenAI, podemos usar o código para conversar com nosso TinyLlama.
• Para isso, trabalhamos com o conclusões classe do OpenAI. Nós criamos novos conclusões com o .criar() objeto e passe os detalhes como o nome do modelo e as mensagens.
• As mensagens têm a forma de uma lista de dicionários, onde temos a função, que pode ser sistema, usuário ou assistente, e temos o conteúdo.
• Finalmente, podemos recuperar as informações geradas por meio da instrução print acima.

A saída acima pode ser vista abaixo.

Dessa forma, podemos aproveitar os llamafiles e substituir facilmente a API OpenAI pelo llamafile que escolhemos para executar.

Limitações dos arquivos de lama

Embora revolucionários, os lhamafiles ainda estão em desenvolvimento. Algumas limitações incluem:

• Seleção limitada de modelos: Atualmente, nem todos os LLMs estão disponíveis na forma de arquivos lhama. A seleção atual de Llamafiles pré-construídos ainda está crescendo. Atualmente, os Llamafiles estão disponíveis para Llama 2, LlaVa, Mistral e Wizard Coder.
• Requisitos de hardware: A execução de LLMs, mesmo através de Llamafiles, ainda requer muitos recursos computacionais. Embora sejam mais fáceis de executar do que os métodos tradicionais, computadores mais antigos ou menos potentes podem precisar de ajuda para executá-los sem problemas.
• Preocupações com segurança: Baixar e executar executáveis ​​de fontes não confiáveis ​​traz riscos inerentes. Portanto, deve haver uma plataforma confiável onde possamos baixar esses arquivos de lhama.

Llamafiles contra o resto

Antes do Llamafiles, havia diferentes maneiras de executar modelos de linguagem grandes. Uma delas foi através do lhama_cpp_python. Esta é a versão Python de llama.cpp que nos permite executar modelos de linguagem grande quantizados em hardware de consumo, como laptops e desktops. Mas para executá-lo, devemos baixar e instalar Python e até bibliotecas de aprendizado profundo como torch, huggingface, transformers e muito mais. E depois disso, envolveu escrever muitas linhas de código para executar o modelo.

Mesmo assim, às vezes, podemos enfrentar problemas devido a problemas de dependência (ou seja, algumas bibliotecas possuem versões inferiores ou superiores ao necessário). E há também o Transformadores C biblioteca que nos permite executar LLMs quantizados. Mesmo isso requer o mesmo processo que discutimos para llama_cpp_python

E então, há Ollama. Ollama tem tido grande sucesso na comunidade de IA por sua facilidade de uso para carregar e executar facilmente modelos de linguagem grandes, especialmente os quantizados. Ollama é uma espécie de TUI (Terminal User Interface) para LLMs. A única diferença entre o Ollama e o Llamafile é a capacidade de compartilhamento. Ou seja, se quiser, posso compartilhar meu arquivo model.llama com qualquer pessoa e eles podem executá-lo sem baixar nenhum software adicional. Mas no caso do Ollama, preciso compartilhar o arquivo model.gguf, que a outra pessoa só pode executar quando instalar o software Ollama ou por meio das bibliotecas Python acima.

Em relação aos recursos, todos eles requerem a mesma quantidade de recursos porque todos esses métodos utilizam o llama.cpp abaixo para executar os modelos quantizados. É apenas uma questão de facilidade de uso onde há diferenças entre eles.

Conclusão

Llamafiles marcam um passo crucial para tornar os LLMs prontamente executáveis. Sua facilidade de uso e portabilidade abrem um mundo de possibilidades para desenvolvedores, pesquisadores e usuários casuais. Embora existam limitações, o potencial dos llamafiles para democratizar o acesso ao LLM é aparente. Quer você seja um desenvolvedor experiente ou um novato curioso, Llamafiles abre possibilidades interessantes para explorar o mundo dos LLMs. Neste guia, demos uma olhada em como baixar Llamafiles e até mesmo como criar nossos próprios Llamafiles com nossos modelos quantizados . Até demos uma olhada no servidor compatível com OpenAI que é criado ao executar Llamafiles.

Principais lições

• Llamafiles são executáveis ​​de arquivo único que tornam a execução de modelos de linguagem grandes (LLMs) mais fácil e mais prontamente disponível.
• Eles eliminam a necessidade de instalações e configurações complexas, permitindo que os usuários baixem e executem LLMs diretamente, sem requisitos de Python ou GPU.
• Os Llamafiles estão agora disponíveis para uma seleção limitada de LLMs de código aberto, incluindo LlaVa, Mistral e WizardCoder.
• Embora convenientes, os Llamafiles ainda apresentam limitações, como requisitos de hardware e questões de segurança associadas ao download de executáveis ​​de fontes não confiáveis.
• Apesar dessas limitações, o Llamafiles representa um passo importante para democratizar o acesso ao LLM para desenvolvedores, pesquisadores e até mesmo usuários casuais.

Perguntas Frequentes

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor.

Relacionado

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://www.analyticsvidhya.com/blog/2024/01/using-llamafiles-to-simplify-llm-execution/