TinyLlama 1.1B – O tamanho não importa

Introdução

No cenário de rápido crescimento da inteligência artificial e do aprendizado de máquina, o TinyLlama 1.1B surge como um desenvolvimento digno de nota. Numa era em que as restrições computacionais representam desafios para a execução de modelos mais complexos, o TinyLlama se destaca por desafiar as expectativas. Ele mostra o desempenho notável dos modelos compactos.

Este artigo tem como objetivo fornecer uma análise do TinyLlama 1.1B, um modelo compacto de linguagem grande. Iremos nos aprofundar em seus aspectos principais, como a forma como foi treinado em benchmarks de desempenho e implementação prática usando a plataforma Hugging Face. Iremos até executar esse modelo no Google Colab gratuito e testar suas habilidades matemáticas e de raciocínio.

Objetivos de aprendizagem

• Obtenha uma compreensão abrangente do TinyLlama 1.1B
• Explore o intrincado processo de treinamento pelo qual o modelo passou
• Analise o desempenho e os resultados do benchmark para avaliar sua eficácia
• Aprenda as etapas práticas para implementar o TinyLlama 1.1B usando exemplos de codificação

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

O que é o TinyLlama 1.1B?

TinyLlama 1.1B, parte do projeto Llama mais amplo, é uma prova dos avanços na modelagem de linguagem. É um modelo com 1.1 bilhão de parâmetros, treinado em impressionantes 3 trilhões de tokens, o que o coloca em uma posição única no cenário da IA. Ao contrário de seus equivalentes maiores, o TinyLlama 1.1B foi projetado para ser mais eficiente e gerenciável, tornando-o uma boa escolha para aplicações com recursos computacionais limitados.

Este modelo de código aberto democratiza o acesso à tecnologia de IA de última geração, permitindo que muitos desenvolvedores e pesquisadores explorem e inovem no campo do processamento de linguagem natural. É um modelo conhecido pela sua capacidade de equilibrar o desempenho com o consumo de recursos, uma consideração crítica nos diversos ambientes computacionais de hoje.

Processo de treinamento do TinyLlama 1.1B

O processo de treinamento do TinyLlama 1.1B é fascinante, assim como o próprio modelo. O treinamento do TinyLlama ocorreu apenas durante 90 dias, treinado nas 16 GPUs A100-40G. O pré-treinamento foi feito em 3 trilhões de tokens, e a equipe TinyLlama publicou o modelo intermediário entre cada meio trilhão. 

Quanto aos dados, Slimpajama e Starcoderdata foram obtidos com um conjunto de dados combinado de 950 bilhões de tokens. A proporção linguagem natural-código foi mantida em 7:3, ou seja, 70% dos dados eram linguagem natural e 30% eram código. Assim, para atingir a marca de 3 trilhões de tokens para ajuste fino, o TinyLlama passou por 3 épocas de treinamento para este conjunto de dados. 

Existe até uma versão de chat do TinyLlama chamada TinyLlama-Chat lançada. Inicialmente, esse modelo passou por ajustes no conjunto de dados UltraChat, que contém diversas conversas sintéticas geradas pelo ChatGPT. Esta etapa foi crucial para fazer o modelo lidar com diferentes contextos e estilos de conversação.

Um refinamento adicional foi alcançado usando o DPOTrainer no conjunto de dados UltraFeedback. Esta fase de treinamento se concentrou no alinhamento das respostas do modelo para se alinhar aos padrões de conversação semelhantes aos humanos. O resultado é um modelo que não apenas capta informações sobre diferentes tópicos, mas também interage de forma natural e envolvente.

Você também pode ler: Primeiros passos com LlaMA 2: um guia para iniciantes

Resultados de desempenho e benchmark

A avaliação do desempenho do TinyLlama 1.1B revela sua capacidade de fornecer respostas de alta qualidade rapidamente. A sua formação dotou-o da capacidade de atender aplicações multilingues, uma característica importante no nosso mundo globalizado. Apesar de seu tamanho menor, o TinyLlama 1.1B ainda está alcançando seus equivalentes maiores em termos de qualidade e velocidade de resposta, tornando-o uma ferramenta potente em diferentes aplicações de IA.

Os benchmarks do TinyLlama 1.1B, embora menos extensos do que aqueles para modelos maiores, ainda demonstram sua proficiência no tratamento de tarefas linguísticas complexas. A sua capacidade de gerar respostas coerentes e contextualmente relevantes em vários idiomas é particularmente impressionante. O modelo foi testado em diferentes benchmarks como HellaSwag, WinoGrande, ARC, MMLU e outros. A pontuação média combinada foi de 52.99. Isto é muito melhor do que o outro modelo de 1 bilhão de parâmetros, ou seja, o Pythia 1B, que alcançou uma pontuação média de 48.3. A tabela mostra as pontuações individuais de cada benchmark

TinyLlama – Primeiros passos

Aqui, nesta seção, iremos baixar a versão quantizada do TinyLlama Chat e executá-la no Google Colab. Antes de baixar o modelo, temos que baixar e instalar os seguintes pacotes Python

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 

• A CMAKE_ARGS=”-DLLAMA_CUBLAS=ligado” e FORCE_CMAKE=1, permitirá que o llama_cpp_python utilize a GPU Nvidia disponível na versão gratuita do Colab.
• Então instalamos o lhama_cpp_python pacote através do pip3
• Nós até baixamos o abraçandoface-hub, com o qual baixaremos o Chat quantizado do TinyLlama 1.1B

Para testar o modelo TinyLlama 1.1B Chat, precisamos primeiro baixar a versão quantizada dele. Para baixá-lo, executaremos o seguinte código

from huggingface_hub import hf_hub_download

# specifying the model name
model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
# specifying the type of quantization of the model
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# download the model by specifying the model name and quantized model name
model_path = hf_hub_download(model_name, filename=model_file)

Aqui o abraço_face_hub A biblioteca cuidará do processo de download do modelo quantizado. Para isso, importamos o hf_hub_download que leva os seguintes parâmetros:

• nome_modelo: Para esta variável passamos o modelo que desejamos baixar. Aqui desejamos baixar o modelo TinyLlama 1.1B Chat GGUF.
• arquivo_modelo: Aqui especificamos o tipo de modelo quantizado que queremos baixar. Aqui faremos o download da versão quantizada de 8 bits do TinyLlama 1.1B Chat.
• Por fim, passamos esses parâmetros para o hf_hub_download, que recebe esses parâmetros e baixa o modelo especificado. Após o download, ele retorna o caminho onde o modelo foi baixado.
• Este caminho retornado está sendo salvo no caminho_modelo variável.

Agora, podemos carregar este modelo através do lhama_cpp_python biblioteca. O código para carregar o modelo será como o abaixo.

from llama_cpp import Llama
llm = Llama(
    model_path=model_path,
    n_ctx=512,  # the number of i/p tokens the model can take
    n_threads=8, # the number of threads to use
    n_gpu_layers=40# how many layers of the model to offload to the GPU
)

Nós importamos o lhama classe da lhama_cpp, que leva os seguintes parâmetros

• caminho_modelo: Esta variável leva o caminho onde nosso modelo está armazenado. Obtivemos o caminho da etapa anterior, que forneceremos aqui
• n_ctx: Aqui, fornecemos o comprimento do contexto para o modelo. Por enquanto, estamos fornecendo 512 tokens como comprimento do contexto
• n_threads: Aqui mencionamos o número de threads a serem usados ​​pelo lhama classe
• n_gpu_layers: Especificamos isso se tivermos uma GPU em execução, o que fazemos no caso do Colab gratuito. Para isso, passamos 40, o que implica que queremos descarregar todo o modelo na GPU e não queremos que nenhuma parte dele rode na RAM do sistema
• Finalmente, criamos um objeto a partir deste lhama class e dê para a variável llm

A execução deste código carregará o modelo quantizado do TinyLlama 1.1B Chat na GPU e definirá o comprimento de contexto apropriado. Agora é hora de realizar algumas inferências sobre este modelo. Para isso, trabalhamos com o código abaixo

output = llm(
  "<|im_start|>usernWho are you?<|im_end|>n<|im_start|>assistantn", # User Prompt
  max_tokens=512,  # Number of output tokens generated
  stop=["</s>"],   # Token which tells the LLM to stop
)
print(output['choices'][0]['text']) # Model generated text

Para inferir o modelo, passamos os seguintes parâmetros para o LLM:

• modelo de prompt/chat: Este é o modelo de prompt necessário para conversar com a modelo. O modelo mencionado acima(ou seja , ) é aquele que funciona para o modelo TinyLlama 1.1B Chat. No template, a frase após o Usuário é o Prompt do Usuário, e a geração será gerada após o Assistente.
• max_tokens: Para esta variável, passamos um valor que define o número máximo de tokens que um Modelo de Linguagem Grande pode gerar quando um Prompt é fornecido. Por enquanto, estamos limitando a 512 tokens.
• Pare: Para esta variável, passamos o token de parada. O token de parada informa ao modelo de linguagem grande para parar de gerar mais tokens. Para o bate-papo TinyLlama 1.1B, o token de parada é

O texto gerado é armazenado na variável de saída quando executamos isso. O resultado é gerado em um formato semelhante à chamada da API OpenAI. Portanto, podemos acessar a geração por meio da instrução print fornecida, semelhante à forma como acessamos a geração a partir das respostas do OpenAI. A saída gerada pode ser vista abaixo

Para um modelo deste tamanho, sua resposta gerada é excelente. Isto é inesperado em um modelo deste tamanho; a gramática e o tom parecem perfeitamente corretos e não há sinais de repetição de frases. Vamos tentar testar as capacidades de raciocínio do modelo

output = llm(
  "<|im_start|>usernIf all students who study hard get good grades, 
  and John got good grades, can we conclude that John studied hard?
  <|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernHow fast can a snake fly?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Até agora tudo bem. Pelos exemplos que vimos, o modelo gera boas respostas. Mas isto pode não ser verdade em todos os casos porque apenas o testamos num número limitado de questões. Vamos até testar o modelo em suas capacidades de raciocínio matemático

output = llm(
  "<|im_start|>usernJohn is twice as old as Sarah, and Sarah is three years 
  older than Mary. If Mary is 10 years old, how old is John?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernWhat is the missing number in this pattern: 
  1, 4, 9, 16, __, 36?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

A partir dos exemplos que vimos, fica claro que o TinyLlamaChat tem um desempenho extremamente ruim ao responder questões simples de aptidão em matemática. Isso é esperado porque o modelo não foi pré-treinado em nenhum conjunto de dados matemáticos. A qualidade da geração pode ser melhorada ajustando-a no conjunto de dados matemáticos

No que diz respeito ao ajuste fino, o TinyLlama é a escolha certa para aqueles que estão restritos a hardware limitado e desejam ajustar modelos de linguagem grandes em seu conjunto de dados específico

Casos de uso e aplicativos potenciais

Dado o tamanho compacto TinyLlama, que possui 1.1 bilhão de parâmetros, suas aplicações são adequadas principalmente para ambientes onde modelos maiores podem não ser tão viáveis ​​devido a limitações de hardware ou maior eficiência. Aqui estão alguns casos de uso específicos levando em consideração seu tamanho:

Aplicações Móveis: O tamanho menor do TinyLlama o torna uma boa escolha para integração em aplicativos móveis onde o processamento no dispositivo é necessário. Isso inclui aplicativos de tradução de idiomas, recursos de assistente pessoal e chatbots que podem operar com eficiência em smartphones.

Sistemas embarcados em dispositivos IoT: No campo da Internet das Coisas (IoT), os recursos computacionais são frequentemente limitados; O TinyLlama pode ser usado para adicionar recursos inteligentes de processamento de linguagem a diferentes equipamentos, como assistentes domésticos inteligentes, tecnologia vestível e outros equipamentos conectados.

Computação de borda: Para aplicações que se beneficiam do processamento de dados mais próximo da fonte, em vez de em um ambiente de nuvem centralizado, o TinyLlama pode ser empregado de forma eficaz. Isso inclui processamento de linguagem em tempo real em sistemas automotivos, equipamentos de fabricação e outros dispositivos de ponta.

Pesquisa de linguagem com poucos recursos: Devido ao seu tamanho menor e menores requisitos computacionais, o TinyLlama pode ser uma ferramenta valiosa na pesquisa linguística, especialmente para idiomas com poucos recursos, onde o treinamento de modelos em grande escala não é viável.

Ferramentas educacionais: Em ambientes educacionais, especialmente aqueles com acesso limitado a recursos computacionais de ponta, o TinyLlama pode ser usado para desenvolver aplicativos de aprendizagem de idiomas, ferramentas educacionais interativas e outros recursos de aprendizagem.

Geração de conteúdo para pequenas empresas: Pequenas empresas com recursos limitados podem usar o TinyLlama para gerar conteúdo, como descrições de produtos, textos de marketing e correspondência de clientes, sem a necessidade de grande poder de computação.

Prototipagem e Experimentação: Desenvolvedores e pesquisadores que desejam experimentar modelos de linguagem, mas não têm acesso a recursos computacionais de alta potência, podem usar o TinyLlama para prototipar e desenvolver novos aplicativos de PNL.

Análise de dados eficiente: O TinyLlama pode ser usado para análise de texto e extração de dados em cenários onde é necessário um processamento rápido e eficiente, como análise de feedback de clientes, respostas de pesquisas ou interações em mídias sociais.

Conclusão

TinyLlama 1.1B é uma prova dos avanços no campo da IA ​​e do processamento de linguagem natural. Seu desenvolvimento e ampla disponibilidade são vitais para a criação de modelos de linguagem de inferência mais eficientes, pequenos e rápidos. Ao equilibrar uma pegada de parâmetro menor com desempenho robusto, o TinyLlama 1.1B atende à necessidade crítica de modelos poderosos e práticos para uma ampla gama de aplicações. Sua capacidade de compreender e gerar linguagem de maneira semelhante à humana, ao mesmo tempo em que é leve o suficiente para diferentes ambientes de computação, torna-o uma escolha ideal para pessoas que lutam para executar grandes modelos de linguagem em suas máquinas. O modelo pode ser facilmente ajustado em um conjunto de dados e treinado com recursos computacionais limitados. 

As principais conclusões deste artigo incluem

• Projetado para ser eficiente, o TinyLlama 1.1B está disponível para um público mais amplo, incluindo aqueles com recursos computacionais limitados, tornando-o adequado para diversas aplicações.
• O modelo passou por um extenso processo de treinamento, incluindo treinamento em 3 trilhões de tokens durante 90 dias usando 16 GPUs A100-40G.
• Apesar de seu tamanho menor, o TinyLlama 1.1B oferece respostas contextualmente relevantes e de alta qualidade em vários idiomas, o que o torna um modelo a ser considerado.
• É uma boa escolha para aplicações móveis, equipamentos IoT, ferramentas educacionais e muito mais. Seu tamanho compacto e eficiência permitem amplas aplicações.
• Os seus requisitos computacionais mais baixos tornam-no numa ferramenta valiosa na investigação linguística, especialmente para línguas com poucos recursos.
• O modelo é uma boa escolha para quem está experimentando modelos de linguagem ou desenvolvendo novos aplicativos de PNL, principalmente em ambientes com poder computacional limitado.

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/tinyllama-1-1b-size-doesnt-matter/