# Modelos de linguagem pequenos: explicação

> O que torna pequeno um modelo de linguagem, o que significam parâmetros e parâmetros efetivos, porque é que os modelos pequenos cabem nos telemóveis e que capacidades sacrificam.

Source: https://ailoot.ai/blog/pt-pt/small-language-models-explained/
Canonical: https://ailoot.ai/blog/pt-pt/small-language-models-explained/
Language: pt-PT
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-100072
Revision: sha256-43b22dda5694f76aeb6cd7384684fd83766b94de59e132616a27ff5648a93d9b


## O que é um modelo de linguagem pequeno?

Um modelo de linguagem pequeno (SLM) é um modelo de linguagem suficientemente compacto para funcionar em equipamento do dia a dia, como um telemóvel ou um portátil, em vez de num centro de dados. Não existe um limite acordado: os modelos com alguns milhares de milhões de parâmetros ou menos são normalmente considerados pequenos, e um estudo de 2024 utiliza um intervalo de 100 milhões a 5 mil milhões.

Os modelos de linguagem pequenos e grandes funcionam da mesma forma. Ambos são redes neuronais, quase sempre transformadores, treinados para prever o token de texto seguinte, e ambos são adaptados após o pré-treino para seguirem instruções; o estudo referido acima analisa transformadores exclusivamente com descodificador deste tipo. A diferença está na escala. Um modelo adequado a um telemóvel tem alguns milhares de milhões de parâmetros, enquanto os modelos de ponta na nuvem são muito maiores, pelo que um modelo pequeno contém menos conhecimento e tem menor capacidade de raciocínio (ver «Em que aspetos ficam aquém os modelos pequenos?»). Os modelos pequenos são o que torna prática a IA no próprio dispositivo.

A dimensão não é o único fator que influencia a qualidade. Por isso, a qualidade de um modelo pequeno depende tanto do seu treino como da sua dimensão. Pode aprender com um modelo maior através de destilação, em que é treinado para reproduzir as respostas do modelo maior, e beneficia de dados cuidadosamente selecionados: o phi-1, um modelo de código com 1,3 mil milhões de parâmetros, treinado sobretudo com dados de «qualidade de manual», obteve 50,6% pass@1 no benchmark de programação HumanEval.

## O que significam «parâmetros» e «parâmetros efetivos»?

Os parâmetros são os valores que um modelo aprende durante o treino, e a sua contagem é a medida habitual da dimensão do modelo: «1.7B» em Qwen3 1.7B significa cerca de 1,7 mil milhões. «Parâmetros efetivos», o «E» nos nomes Gemma 4 E2B e E4B da Google, conta os parâmetros com que o modelo efetua cálculos e exclui as grandes tabelas de embeddings, das quais apenas consulta valores.

A maioria dos parâmetros está nas matrizes de pesos das camadas de atenção e de feed-forward de um transformador, pelas quais passa cada token. Um bloco separado, os embeddings, mapeia cada token do vocabulário para um vetor e, num modelo pequeno, pode representar uma parte significativa do total. A tabela de embeddings do Qwen3 1.7B tem 151 936 linhas (o vocabulário configurado, preenchido para além das 151 669 entradas do tokenizador) com 2 048 dimensões, o que corresponde a cerca de 311 milhões de parâmetros de embeddings. Este valor é consistente com o cartão do modelo, que indica 1,7 mil milhões de parâmetros no total e 1,4 mil milhões fora dos embeddings 7. Os estudos de escalabilidade contam frequentemente apenas os parâmetros que não são de embeddings.

A série E do Gemma 4 leva esta ideia mais longe. O cartão do modelo da Google explica que «o “E” em E2B e E4B significa parâmetros “efetivos”»: os modelos usam embeddings por camada (PLE), que dão «a cada camada de descodificador o seu próprio pequeno embedding para cada token», e «estas tabelas de embeddings são grandes, mas só são usadas para consultas rápidas, razão pela qual a contagem de parâmetros efetivos é muito inferior à contagem total» 8. O cartão indica 2,3 mil milhões de parâmetros efetivos e 5,1 mil milhões com embeddings para o Gemma 4 E2B; para o E4B, indica 4,5 mil milhões efetivos e 8 mil milhões com embeddings.

Esta distinção é importante num telemóvel porque as consultas precisam de memória, mas exigem poucos cálculos, e o ambiente de execução pode manter as tabelas no armazenamento. «Efetivos» também é diferente de «ativos»: o Gemma 4 26B A4B é um modelo de mistura de especialistas com 25,2 mil milhões de parâmetros, dos quais 3,8 mil milhões estão ativos durante a inferência 8.

## Porque é que os modelos pequenos cabem nos telemóveis?

Os pesos de um modelo ocupam aproximadamente o número de parâmetros multiplicado pelos bits armazenados por parâmetro e dividido por oito. Com 4 bits, 1,7 mil milhões de parâmetros precisam de cerca de 0,85 GB, deixando espaço para o Android e outras aplicações num telemóvel com 4 GB de RAM.

A contagem de parâmetros e a precisão são os dois fatores principais. A Figura 1 apresenta as contas para o Qwen3 1.7B, desde a representação de vírgula flutuante de 32 bits até um ficheiro de modelo de 4 bits.

<figure id="la-fit">
<ol>
<li><strong>Armazenados como valores de vírgula flutuante de 32 bits, 1,7 mil milhões de parâmetros ocupam 6,8 GB.</strong></li>
<li><strong>Com 16 bits, ocupam 3,4 GB.</strong></li>
<li><strong>Com 8 bits, ocupam 1,7 GB.</strong> Cada redução para metade do número de bits por peso reduz para metade a memória necessária para os pesos.</li>
<li><strong>Com 4 bits, ocupam cerca de 0,85 GB.</strong> Meio byte por peso é o que torna prático utilizar um modelo deste tamanho num telemóvel com 4 GB de memória.</li>
<li><strong>Um ficheiro de modelo de 4 bits pode ser maior do que os pesos em bruto.</strong> As escalas de bloco e outros dados armazenados aumentam a sua dimensão.</li>
</ol>
<figcaption>Figura 1. Memória necessária para guardar os pesos do Qwen3 1.7B em gigabytes decimais. As barras azuis são calculadas como parâmetros × bits ÷ 8 para 1,7 mil milhões de parâmetros e contabilizam apenas os pesos; um modelo em execução também precisa de memória para a cache de chaves e valores e para o ambiente de execução. A barra laranja representa o ficheiro do modelo transferido.</figcaption>
</figure>

| Precisão | Bits por parâmetro | Memória aproximada para os pesos |
|---|---:|---:|
| Vírgula flutuante de 32 bits | 32 | 6,8 GB |
| Vírgula flutuante de 16 bits | 16 | 3,4 GB |
| Inteiro de 8 bits | 8 | 1,7 GB |
| Inteiro de 4 bits | 4 | 0,85 GB |

Por esta razão, os modelos adequados a telemóveis combinam alguns milhares de milhões de parâmetros com pesos de 4 bits ou de precisão mista; a quantização reduz o armazenamento necessário para os pesos.

Os pesos não representam toda a memória ocupada. Um modelo em execução também precisa de memória para a cache de chaves e valores, que cresce com o comprimento da janela de contexto, e para o próprio ambiente de execução. A velocidade segue a mesma lógica: cada novo token exige que os pesos do modelo sejam lidos da memória, pelo que menos pesos e pesos menores significam respostas mais rápidas no mesmo telemóvel.

## Em que tarefas se destacam os modelos pequenos?

Os modelos pequenos são bons em tarefas em que a informação necessária está no pedido ou faz parte do conhecimento comum: reformular, resumir, redigir, explicar e responder com base em passagens fornecidas. Como funcionam no próprio dispositivo, também podem responder sem ligação à rede e sem enviar o pedido para um servidor.

O cartão do modelo da Google descreve a família Gemma 4 como «adequada para raciocínio, fluxos de trabalho com agentes, programação e compreensão multimodal»; os modelos E2B e E4B aceitam texto, imagens e áudio 8. Estas são as descrições e os benchmarks dos próprios programadores; a qualidade com que uma tarefa específica funciona num telemóvel específico continua a precisar de ser testada.

Fornecer o texto certo ajuda quando um modelo pequeno não sabe algo. A geração aumentada por recuperação acrescenta passagens obtidas no momento da pergunta, para que o modelo trabalhe com fontes em vez de depender da memória. Os modelos pequenos também são previsíveis de executar: não há custos de servidor por pergunta, filas de espera nem dependência de uma ligação depois da transferência.

## Em que aspetos ficam aquém os modelos pequenos?

Os modelos pequenos contêm menos conhecimento, são menos capazes de raciocínio longo ou com várias etapas e lidam pior com contextos longos do que os modelos maiores; como todos os modelos de linguagem, podem afirmar coisas falsas com fluência.

Este padrão também se observa dentro de uma única família. Segundo o cartão do modelo da Google, o Gemma 4 E2B obtém 60,0% no benchmark de conhecimento e raciocínio MMLU Pro e o E4B obtém 69,4%, em comparação com 85,2% para o modelo Gemma 4 de 31 mil milhões de parâmetros. No GPQA Diamond, um conjunto de perguntas de ciências ao nível de pós-graduação, as pontuações são 43,4%, 58,6% e 84,3% 8. Estes são resultados da Google para os seus modelos.

Os modelos pequenos também podem ficar presos a repetir-se. O cartão do modelo Qwen alerta que a descodificação gulosa «pode levar à degradação do desempenho e a repetições intermináveis» 7.

## Porque é que os modelos pequenos copiam a estrutura das instruções?

Os modelos pequenos tendem a imitar a forma de um pedido, além de seguirem o seu conteúdo, pelo que uma instrução de sistema longa e estruturada pode fazer com que essa estrutura apareça em todas as respostas.

Um pedido que instruía o modelo a «começar pela resposta direta e depois apresentar detalhes úteis» produziu respostas com rótulos a negrito: «Resposta direta:» e «Detalhes úteis:». A instrução pretendia dar orientações sobre o conteúdo; o modelo tratou-a como um modelo a seguir.

## Como funcionam os modos de raciocínio nos modelos pequenos?

Um modo de raciocínio faz com que o modelo escreva os passos intermédios do seu raciocínio antes da resposta final, usando mais tempo e tokens para obter resultados mais cuidadosos em problemas com várias etapas. Tanto o Qwen3 como o Gemma 4 oferecem esta opção como um interruptor no mesmo modelo, em vez de a disponibilizarem num modelo de raciocínio separado.

A ideia tem origem na solicitação de cadeias de raciocínio. Os modelos pequenos mais recentes são treinados para raciocinar; no caso do Qwen3, isso acontece em parte através da aprendizagem a partir dos seus modelos maiores.

O interruptor faz parte do pedido. O Qwen3 1.7B raciocina por predefinição e escreve o seu raciocínio dentro de um bloco `<think>…</think>`; os programadores desativam o raciocínio através da definição `enable_thinking`, e os utilizadores podem acrescentar `/think` ou `/no_think` a uma mensagem para alterar o modo de um turno para o seguinte 7. O Gemma 4 ativa o raciocínio quando a sua instrução de sistema começa com o token `<|think|>` 8.

O raciocínio consome tempo e contexto, porque os tokens de raciocínio fazem parte da saída do modelo e ocupam espaço na respetiva janela. Se o modelo estiver configurado para o expor, o raciocínio aparece antes da resposta, mas o comportamento depende do modelo e da aplicação.

## Como se comparam o Qwen3 1.7B, o Gemma 4 E2B e o Gemma 4 E4B?

Os três modelos diferem em dimensão, tipos de entrada e comprimento do contexto. O Qwen3 1.7B tem 1,7 mil milhões de parâmetros e só aceita texto; a Google indica 2,3 e 4,5 mil milhões de parâmetros efetivos para o Gemma 4 E2B e o E4B, respetivamente, e ambos aceitam texto, imagens e áudio. Os três são distribuídos ao abrigo da licença Apache 2.0.

|  | Qwen3 1.7B | Gemma 4 E2B | Gemma 4 E4B |
|---|---|---|---|
| Programador | Alibaba (equipa Qwen) | Google DeepMind | Google DeepMind |
| Parâmetros | 1.7B, dos quais 1.4B fora dos embeddings | 2.3B efetivos, 5.1B com embeddings | 4.5B efetivos, 8B com embeddings |
| Camadas | 28 | 35 | 42 |
| Comprimento do contexto | 32 768 tokens | 128K tokens | 128K tokens |
| Entrada | Texto | Texto, imagem, áudio | Texto, imagem, áudio |
| Modo de raciocínio | Sim, ativado por predefinição | Sim | Sim |
| Licença | Apache 2.0 | Apache 2.0 | Apache 2.0 |

Tabela 1. Especificações publicadas nos cartões dos modelos Qwen3-1.7B da Qwen e Gemma 4 da Google, consultados em 5 de outubro de 2026 7 8.



## Referências

7. Qwen. «Qwen3-1.7B». Cartão do modelo e configuração, Hugging Face. Consultado em 5 de outubro de 2026. [huggingface.co/Qwen/Qwen3-1.7B](https://huggingface.co/Qwen/Qwen3-1.7B)
8. Google DeepMind. «Cartão do modelo Gemma 4». Google AI for Developers. Consultado em 5 de outubro de 2026. [ai.google.dev/gemma/docs/core/model_card_4](https://ai.google.dev/gemma/docs/core/model_card_4)

## Ponha este guia em prática com a Ailoot

Ligue modelos de IA às suas aplicações, agentes e automatizações através de uma única API da Ailoot. Escolha o modelo adequado à sua tarefa e siga a [documentação da Ailoot](https://ailoot.ai/docs/) para começar.

## Ailoot · A empresa e a sua carteira de projetos

A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.
