# Llama3

```python
import torch

import transformers

model_id = "meta-llama/Meta-Llama-3-8B"

pipeline = transformers.pipeline("text-generation", model=model_id, model_kwargs={"dtype": torch.bfloat16}, device_map="auto")
pipeline("Hey how are you doing today?")
```

## Visão geral

O modelo [Llama3](https://huggingface.co/papers/2407.21783) foi proposto em [Introducing Meta Llama 3: The most capable openly available LLM to date](https://ai.meta.com/blog/meta-llama-3/) pela equipe de IA da Meta.

O resumo do post no blog é o seguinte:

*Hoje, estamos animados em compartilhar os dois primeiros modelos da próxima geração do Llama, o Meta Llama 3, disponíveis para uso amplo. Este lançamento apresenta modelos de linguagem pré-treinados e ajustados por instrução com 8B e 70B parâmetros, capazes de suportar uma ampla variedade de casos de uso. Esta nova geração do Llama demonstra desempenho de estado da arte em uma ampla gama de benchmarks do setor e oferece novas capacidades, incluindo raciocínio aprimorado. Acreditamos que estes são os melhores modelos de código aberto de sua classe, ponto final. Em apoio à nossa abordagem aberta de longa data, estamos colocando o Llama 3 nas mãos da comunidade. Queremos impulsionar a próxima onda de inovação em IA em toda a pilha — de aplicativos a ferramentas de desenvolvimento, avaliações, otimizações de inferência e muito mais. Mal podemos esperar para ver o que vocês vão construir e aguardamos ansiosos pelos seus comentários.*

Confira todos os checkpoints dos modelos Llama3 [aqui](https://huggingface.co/models?search=llama3). O código original dos autores pode ser encontrado [aqui](https://github.com/meta-llama/llama3).

## Dicas de uso

Os modelos `Llama3` foram treinados usando `bfloat16`, mas a inferência original usa `float16`. Os checkpoints enviados no Hub usam `dtype = 'float16'`, que será usado pela API `AutoModel` para converter os checkpoints de `torch.float32` para `torch.float16`.

O `dtype` dos pesos online é, em grande parte, irrelevante, a menos que você esteja usando `dtype="auto"` ao inicializar um modelo com `model = AutoModelForCausalLM.from_pretrained("path", dtype = "auto")`. A razão é que o modelo será primeiro baixado (usando o `dtype` dos checkpoints online), em seguida será convertido para o `dtype` padrão do `torch` (tornando-se `torch.float32`, device_map="auto") e, por fim, se houver um `dtype` ou `torch_dtype` fornecido na configuração, ele será utilizado.

Treinar o modelo em `float16` não é recomendado e é conhecido por produzir `nan`; portanto, o modelo deve ser treinado em `bfloat16`.

Dicas:

- Os pesos dos modelos Llama3 podem ser obtidos preenchendo [este formulário](https://ai.meta.com/resources/models-and-libraries/llama-downloads/)
- A arquitetura é exatamente a mesma do Llama2.
- O tokenizer é um modelo BPE baseado em [tiktoken](https://github.com/openai/tiktoken) (em oposição ao baseado na implementação sentencepiece para Llama2). A principal diferença é que ele ignora as regras de mesclagem BPE quando um token de entrada faz parte do vocabulário. Isso significa que, se não existir nenhuma mesclagem para produzir `"hugging"`, em vez de ter as menores unidades, como `["hug","ging"]` formando 2 tokens, se `"hugging"` fizer parte do vocabulário, ele será automaticamente retornado como um token.
- O modelo original usa `pad_id = -1`, o que significa que não há token de padding. Não podemos usar a mesma lógica; certifique-se de adicionar um token de padding usando `tokenizer.add_special_tokens({"pad_token":"<pad>"})` e redimensione o embedding de tokens de acordo. Você também deve definir o `model.config.pad_token_id`. A camada `embed_tokens` do modelo é inicializada com `self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.config.padding_idx)`, o que garante que a codificação do token de padding resulte em zeros, portanto, é recomendável passá-lo durante a inicialização.
- O checkpoint original pode ser convertido usando o [script de conversão](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/convert_llama_weights_to_hf.py). O script pode ser chamado com o seguinte comando (exemplo):

    ```bash
    python src/transformers/models/llama/convert_llama_weights_to_hf.py \
        --input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path --llama_version 3
    ```

- Após a conversão, o modelo e o tokenizador podem ser carregados por meio de:

    ```python
    from transformers import AutoModelForCausalLM, AutoTokenizer

    tokenizer = AutoTokenizer.from_pretrained("/output/path")
    model = AutoModelForCausalLM.from_pretrained("/output/path", device_map="auto")
    ```

    Observe que a execução do script requer RAM de CPU suficiente para hospedar o modelo inteiro em precisão float16 (mesmo que as versões maiores venham em vários checkpoints, cada um contém uma parte de cada peso do modelo, portanto, precisamos carregá-los todos na RAM). Para o modelo de 75B, são necessários 145GB de RAM.

- Ao usar Flash Attention 2 via `attn_implementation="flash_attention_2"`, não passe `dtype` para o método de classe `from_pretrained` e use treinamento com Precisão Mista Automática. Ao usar `Trainer`, basta especificar `fp16` ou `bf16` como `True`. Caso contrário, verifique se está usando `torch.autocast`. Isso é necessário porque o Flash Attention suporta apenas os tipos de dados `fp16` e `bf16`.

## Recursos

Uma grande quantidade de recursos interessantes já está disponível na página de documentação do [Llama2](./llama2), convidando os contribuidores a adicionar novos recursos curados para o Llama3 aqui! 🤗