# Fundamentos do chat

Modelos de chat são modelos conversacionais aos quais você pode enviar uma mensagem e receber uma resposta. A maioria dos modelos de linguagem a partir de meados de 2023 são modelos de chat e podem ser chamados de modelos "instruct" ou "instruction-tuned". Modelos que não suportam chat são frequentemente chamados de modelos "base" ou "pretrained".

Modelos maiores e mais recentes são geralmente mais capazes, mas modelos especializados em determinados domínios (texto médico, jurídico, idiomas não ingleses, etc.) podem frequentemente superar esses modelos maiores. Experimente rankings como [OpenLLM](https://hf.co/spaces/HuggingFaceH4/open_llm_leaderboard) e [LMSys Chatbot Arena](https://chat.lmsys.org/?leaderboard) para ajudá-lo a identificar o melhor modelo para o seu caso de uso.

Este guia mostra como carregar rapidamente modelos de chat no Transformers pela linha de comando, como construir e formatar uma conversa e como conversar usando o [TextGenerationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextGenerationPipeline).

## CLI de chat

Depois de [instalar o Transformers](./installation), você pode conversar com um modelo diretamente pela linha de comando. O comando abaixo inicia uma sessão interativa com um modelo, com alguns comandos básicos listados no início da sessão.

> Para os comandos a seguir, verifique se [`transformers serve` está em execução](./serve-cli/serving).

```bash
transformers chat Qwen/Qwen2.5-0.5B-Instruct
```

    

Você pode iniciar o CLI com flags `generate` arbitrárias, no formato `arg_1=value_1 arg_2=value_2 ...`

```bash
transformers chat Qwen/Qwen2.5-0.5B-Instruct do_sample=False max_new_tokens=10
```

Para obter a lista completa de opções, execute o comando abaixo.

```bash
transformers chat -h
```

O chat é implementado sobre a [AutoClass](./model_doc/auto), utilizando ferramentas de [text generation](./llm_tutorial) e [chat](./chat_templating). Ele usa o CLI `transformers serve` por baixo dos panos ([docs](./serve-cli/serving)).

## TextGenerationPipeline

[TextGenerationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextGenerationPipeline) é uma classe de alto nível para geração de texto com um "modo de chat". O modo de chat é ativado quando um modelo conversacional é detectado e o prompt de chat está [corretamente formatado](./llm_tutorial#prompt-format).

Modelos de chat aceitam uma lista de mensagens (o histórico do chat) como entrada. Cada mensagem é um dicionário com as chaves `role` e `content`. Para iniciar o chat, adicione uma única mensagem de `user`. Você também pode incluir opcionalmente uma mensagem de `system` para dar diretrizes ao modelo sobre como se comportar.

```py
chat = [
    {"role": "system", "content": "You are a helpful science assistant."},
    {"role": "user", "content": "Hey, can you explain gravity to me?"}
]
```

Crie o [TextGenerationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextGenerationPipeline) e passe `chat` para ele. Para modelos grandes, definir [device_map="auto"](./models#big-model-inference) ajuda a carregar o modelo mais rapidamente e o posiciona automaticamente no dispositivo mais rápido disponível.

```py
import torch
from transformers import pipeline

pipeline = pipeline(task="text-generation", model="HuggingFaceTB/SmolLM2-1.7B-Instruct", dtype="auto", device_map="auto")
response = pipeline(chat, max_new_tokens=512)
print(response[0]["generated_text"][-1]["content"])
```

Se isso funcionar com sucesso, você deve ver uma resposta do modelo! Se quiser continuar a conversa, é necessário atualizar o histórico do chat com a resposta do modelo. Você pode fazer isso adicionando o texto a `chat` (usando o papel `assistant`) ou lendo `response[0]["generated_text"]`, que contém o histórico completo do chat, incluindo a resposta mais recente.

Depois de obter a resposta do modelo, você pode continuar a conversa adicionando uma nova mensagem de `user` ao histórico do chat.

```py
chat = response[0]["generated_text"]
chat.append(
    {"role": "user", "content": "Woah! But can it be reconciled with quantum mechanics?"}
)
response = pipeline(chat, max_new_tokens=512)
print(response[0]["generated_text"][-1]["content"])
```

Ao repetir esse processo, você pode continuar a conversa por quanto tempo quiser, pelo menos até o modelo esgotar a janela de contexto ou até a memória acabar.

## Desempenho e uso de memória

Os Transformers carregam modelos em precisão `float32` por padrão, e, para um modelo de 8B, isso requer cerca de 32 GB de memória! Use o argumento `torch_dtype="auto"`, que geralmente usa `bfloat16` para modelos treinados com essa precisão, para reduzir o uso de memória.

> [!TIP]
> Consulte a documentação de [Quantization](./quantization/overview) para obter mais informações sobre os diferentes backends de quantização disponíveis.

Para reduzir ainda mais o uso de memória, você pode quantizar o modelo para 8 bits ou 4 bits com [bitsandbytes](https://hf.co/docs/bitsandbytes/index). Crie um [BitsAndBytesConfig](/docs/transformers/main/pt/main_classes/quantization#transformers.BitsAndBytesConfig) com as configurações de quantização desejadas e passe-o para o parâmetro `model_kwargs` dos pipelines. O exemplo abaixo quantiza um modelo para 8 bits.

```py
from transformers import pipeline, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)
pipeline = pipeline(task="text-generation", model="meta-llama/Meta-Llama-3-8B-Instruct", device_map="auto", model_kwargs={"quantization_config": quantization_config})
```

Em geral, o tamanho do modelo e o desempenho estão diretamente correlacionados. Modelos maiores são mais lentos, além de exigirem mais memória, pois cada parâmetro ativo precisa ser lido da memória para cada token gerado. Isso é um gargalo para a geração de texto em LLMs, e as principais opções para melhorar a velocidade de geração são quantizar um modelo ou usar hardware com maior largura de banda de memória. Adicionar mais poder de computação não ajuda de forma significativa.

Você também pode tentar técnicas como [decodificação especulativa](./assisted_decoding#speculative-decoding), em que um modelo menor gera tokens candidatos que são verificados pelo modelo maior. Se os tokens candidatos estiverem corretos, o modelo maior pode gerar mais de um token por vez. Isso alivia significativamente o gargalo de largura de banda e melhora a velocidade de geração.

> [!TIP]
Modelos Mixture-of-Expert (MoE), como [Mixtral](./model_doc/mixtral), [Qwen2MoE](./model_doc/qwen2_moe) e [GPT-OSS](./model_doc/gpt_oss), possuem muitos parâmetros, mas apenas "ativam" uma pequena fração deles para gerar cada token. Como resultado, os modelos MoE geralmente têm requisitos de largura de banda de memória muito menores e podem ser mais rápidos do que um LLM regular do mesmo tamanho. No entanto, técnicas como speculative decoding são ineficazes com modelos MoE, pois mais parâmetros são ativados a cada novo token especulado.