As postagens anteriores da série "Explicação sobre o Gemma" forneceram uma visão geral detalhada das arquiteturas da família de modelos Gemma. Estes são os links de cada uma das postagens:
Nesta postagem, você vai explorar o modelo mais recente, o Gemma 3. Vamos lá!
Uma mudança importante em relação às versões anteriores é o novo suporte do Gemma 3 a recursos de visão-linguagem. Aqueles familiarizados com a arquitetura do PaliGemma poderão reconhecer um codificador SigLIP utilizado no Gemma 3, embora ele tenha sido adaptado para esta implementação específica.
Veja aqui os principais parâmetros dos novos modelos.
Vamos explorar as principais diferenças e melhorias do Gemma 3.
Embora a arquitetura do Gemma 3 herde aspectos de seus antecessores, ela também traz novas modificações, que são descritas abaixo.
Uma grande melhoria do Gemma 3 é sua nova capacidade de compreensão de visão-linguagem. Os modelos 4B, 12B e 27B empregam um codificador de visão SigLIP personalizado, que permite a um modelo interpretar entradas visuais.
O codificador de visão opera em imagens quadradas fixas de 896 x 896. Para tratar imagens com diferentes proporções ou altas resoluções, é empregado um algoritmo "Pan & Scan". Isso envolve recortar a imagem de forma adaptativa, redimensionar cada recorte para 896 x 896 e, em seguida, codificá-la. Embora esse método melhore o desempenho, especialmente quando informações detalhadas são críticas, ele leva ao aumento do overhead computacional durante a inferência.
Além disso, o Gemma 3 trata as imagens como uma sequência de "soft tokens" compactos produzidos pelo MultiModalProjector. Essa técnica reduz significativamente os recursos de inferência necessários para o processamento de imagens, representando dados visuais com um número fixo de 256 vetores.
Antes de prosseguir, você pode se perguntar: "Quando devo usar Gemma 3 ou o PaliGemma 2?"
O ponto forte do PaliGemma 2 está em recursos não encontrados no Gemma 3, como segmentação de imagens e detecção de objetos. No entanto, o Gemma 3 integrou e estendeu a tecnologia do PaliGemma, oferecendo chat com várias voltas e um sólido desempenho em zero-shot para lidar diretamente com várias tarefas de visão.
Sua decisão final também deve considerar os recursos computacionais disponíveis e a importância de recursos avançados, como contexto mais longo ou suporte multilíngue, nos quais o Gemma 3 oferece aprimoramentos notáveis.
A arquitetura foi modificada para reduzir o uso da memória do cache KV, que tende a aumentar com o contexto longo.
A arquitetura de modelo atualizada é composta por blocos de intercalação repetidos, cada um contendo cinco camadas de atenção local com uma janela deslizante de 1024 e uma camada de atenção global. Esse design permite que o modelo capture dependências de curto e longo alcance, levando a respostas mais precisas e contextualmente relevantes.
Observação: O Gemma 1 dependia exclusivamente da atenção global, ao passo que o Gemma 2 introduziu uma abordagem híbrida, alternando entre as camadas de atenção local e global. O Gemma 3 integra cinco camadas de atenção local dedicada, resultando em respostas mais precisas e contextualmente apropriadas.
Tanto o Gemma 2 quanto o Gemma 3 utilizam a atenção de consulta agrupada (GQA, na sigla em inglês) com pós-normalização e pré-normalização com RMSNorm. No entanto, o Gemma 3 ganha acurácia aprimorada e velocidades de processamento mais altas ao adotar a norma QK em vez do mecanismo de sofcapping do Gemma 2.
Como resultado das mudanças arquitetônicas discutidas acima, o Gemma 3 utiliza a atenção intercalada para diminuir os requisitos de memória, permitindo o suporte a um comprimento de contexto estendido. Isso permite a análise de documentos e conversas mais longos sem perda de contexto. Especificamente, ele é capaz de lidar com 32 mil tokens para o modelo 1B e 128 mil tokens para modelos maiores.
Observação: a janela de contexto de 128 mil tokens permite que o modelo processe uma quantidade de texto tão longa quanto um romance típico (cerca de 80 mil palavras). Esse tamanho de janela é de aproximadamente 96 mil palavras, 198 páginas, 500 imagens ou mais de 8 minutos de vídeo a 1 quadro por segundo.
O Gemma 3 só usa a atenção bidirecional com entradas de imagem.
A atenção normal (também conhecida como atenção unidirecional) é como a leitura. Imagine ler um livro. Você entende cada palavra considerando as palavras que vieram antes dela. É assim que funciona a atenção típica em modelos de linguagem. Ela é sequencial e olha para trás para construir o contexto.
Por outro lado, a atenção bidirecional é como olhar para um quebra-cabeça. Pense em uma imagem como um quebra-cabeça e nos "tokens da imagem" como as peças individuais desse quebra-cabeça. Isso significa que cada peça "olha para" e se conecta a todas as outras peças da imagem, independentemente de sua posição. A atenção bidirecional considera toda a imagem de uma só vez, e não apenas uma sequência. Isso permite uma compreensão total, porque cada uma das peças está relacionada a todas as outras.
Mas por que não usar sempre a atenção bidirecional? Embora isso pareça melhor (quando se olha para todo o contexto), ela nem sempre é usada para texto. Tudo tem a ver com a tarefa:
A principal diferença é que a abordagem bidirecional é usada quando o modelo não está criando uma sequência.
A visualização a seguir ilustra o mecanismo de atenção no Gemma 3.
Código:
from transformers.utils.attention_visualizer import AttentionMaskVisualizer
visualizer = AttentionMaskVisualizer("google/gemma-3-4b-it")
visualizer("<start_of_turn>user\n<img>What is this?<end_of_turn>\n<start_of_turn>model\nIt's an image of a cat.<end_of_turn>")
Saída:
Você também pode ver como esse mecanismo de atenção difere do PaliGemma. Para fornecer contexto para essa comparação, o PaliGemma opera recebendo uma ou mais imagens juntamente com uma descrição da tarefa baseada em texto (o prompt ou prefixo) e, subsequentemente, gera sua previsão como uma string de texto (a resposta ou o sufixo) de maneira autorregressiva.
Código:
visualizer = AttentionMaskVisualizer("google/paligemma2-3b-mix-224")
visualizer("<img> caption en", suffix="a cat standing on a beach.")
Saída
O Gemma 3 melhorou os recursos multilíngues devido a uma mistura de dados reformulada com uma quantidade maior de dados multilíngues (tanto monolíngues quanto paralelos).
O Gemma 3 também introduz um tokenizador aprimorado. O tamanho do vocabulário passou para 262 mil, mas usa o mesmo tokenizador SentencePiece. Para evitar erros, use o novo tokenizador com o Gemma 3. Esse é o mesmo tokenizador do Gemini, que é mais equilibrado para idiomas diferentes do inglês.
Gemma3ForConditionalGeneration(
(vision_tower): SiglipVisionModel(
(vision_model): SiglipVisionTransformer(
(embeddings): SiglipVisionEmbeddings(
(patch_embedding): Conv2d(3, 1152, kernel_size=(14, 14), stride=(14, 14), padding=valid)
(position_embedding): Embedding(4096, 1152)
)
(encoder): SiglipEncoder(
(layers): ModuleList(
(0-26): 27 x SiglipEncoderLayer(
(self_attn): SiglipSdpaAttention(
(k_proj): Linear(in_features=1152, out_features=1152, bias=True)
(v_proj): Linear(in_features=1152, out_features=1152, bias=True)
(q_proj): Linear(in_features=1152, out_features=1152, bias=True)
(out_proj): Linear(in_features=1152, out_features=1152, bias=True)
)
(layer_norm1): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
(mlp): SiglipMLP(
(activation_fn): PytorchGELUTanh()
(fc1): Linear(in_features=1152, out_features=4304, bias=True)
(fc2): Linear(in_features=4304, out_features=1152, bias=True)
)
(layer_norm2): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
)
)
)
(post_layernorm): LayerNorm((1152,), eps=1e-06, elementwise_affine=True)
)
)
(multi_modal_projector): Gemma3MultiModalProjector(
(mm_soft_emb_norm): Gemma3RMSNorm((1152,), eps=1e-06)
(avg_pool): AvgPool2d(kernel_size=4, stride=4, padding=0)
)
(language_model): Gemma3ForCausalLM(
(model): Gemma3TextModel(
(embed_tokens): Gemma3TextScaledWordEmbedding(262208, 5376, padding_idx=0)
(layers): ModuleList(
(0-61): 62 x Gemma3DecoderLayer(
(self_attn): Gemma3Attention(
(q_proj): Linear(in_features=5376, out_features=4096, bias=False)
(k_proj): Linear(in_features=5376, out_features=2048, bias=False)
(v_proj): Linear(in_features=5376, out_features=2048, bias=False)
(o_proj): Linear(in_features=4096, out_features=5376, bias=False)
(q_norm): Gemma3RMSNorm((128,), eps=1e-06)
(k_norm): Gemma3RMSNorm((128,), eps=1e-06)
)
(mlp): Gemma3MLP(
(gate_proj): Linear(in_features=5376, out_features=21504, bias=False)
(up_proj): Linear(in_features=5376, out_features=21504, bias=False)
(down_proj): Linear(in_features=21504, out_features=5376, bias=False)
(act_fn): PytorchGELUTanh()
)
(input_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
(post_attention_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
(pre_feedforward_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
(post_feedforward_layernorm): Gemma3RMSNorm((5376,), eps=1e-06)
)
)
(norm): Gemma3RMSNorm((5376,), eps=1e-06)
(rotary_emb): Gemma3RotaryEmbedding()
(rotary_emb_local): Gemma3RotaryEmbedding()
)
(lm_head): Linear(in_features=5376, out_features=262208, bias=False)
)
)
Observação: tecnicamente, o Rotary Positional Embedding (RoPE) está dentro da atenção dot-product ajustada (SDPA, na sigla em inglês), mas simplificamos isso neste diagrama. Consulte o código para ver os detalhes arquitetônicos.
Gemma3ForCausalLM(
(model): Gemma3TextModel(
(embed_tokens): Gemma3TextScaledWordEmbedding(262144, 1152, padding_idx=0)
(layers): ModuleList(
(0-25): 26 x Gemma3DecoderLayer(
(self_attn): Gemma3Attention(
(q_proj): Linear(in_features=1152, out_features=1024, bias=False)
(k_proj): Linear(in_features=1152, out_features=256, bias=False)
(v_proj): Linear(in_features=1152, out_features=256, bias=False)
(o_proj): Linear(in_features=1024, out_features=1152, bias=False)
(q_norm): Gemma3RMSNorm((256,), eps=1e-06)
(k_norm): Gemma3RMSNorm((256,), eps=1e-06)
)
(mlp): Gemma3MLP(
(gate_proj): Linear(in_features=1152, out_features=6912, bias=False)
(up_proj): Linear(in_features=1152, out_features=6912, bias=False)
(down_proj): Linear(in_features=6912, out_features=1152, bias=False)
(act_fn): PytorchGELUTanh()
)
(input_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
(post_attention_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
(pre_feedforward_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
(post_feedforward_layernorm): Gemma3RMSNorm((1152,), eps=1e-06)
)
)
(norm): Gemma3RMSNorm((1152,), eps=1e-06)
(rotary_emb): Gemma3RotaryEmbedding()
(rotary_emb_local): Gemma3RotaryEmbedding()
)
(lm_head): Linear(in_features=1152, out_features=262144, bias=False)
)
Este modelo 1B somente de texto é especificamente otimizado para uso no dispositivo, tornando a IA avançada acessível em sistemas incorporados e para dispositivos móveis. Isso afeta significativamente a acessibilidade, a privacidade e o desempenho, pois os aplicativos habilitados por IA agora podem funcionar com eficiência, mesmo com conectividade de rede limitada ou inexistente.
Nosso relatório técnico fornece mais detalhes, mas este é um breve resumo das principais conclusões sobre o Gemma 3:
Exploramos a arquitetura do Gemma 3, destacando os novos recursos que o diferenciam das versões anteriores. Essas escolhas arquitetônicas permitem que o Gemma 3 tenha um desempenho melhor em um conjunto mais amplo de tarefas, incluindo habilidades multilíngues e interação com imagens aprimoradas e, ao mesmo tempo, abrindo o caminho para modelos de linguagem multimodais futuros mais capacitados e que utilizam menos recursos, adequados para hardware padrão.
Acreditamos que as inovações do Gemma 3 capacitarão pesquisadores e desenvolvedores a criar a próxima geração de modelos de linguagem multimodais eficientes e poderosos.
Agradecemos a leitura!
Achieve real-time interaction: Build with the Live API
Modelos Gemma 3 QAT: IA de última geração para GPUs de consumidor final
Uso do JSON no BigQuery para pipelines do Dataflow do MongoDB otimizados
Usability and safety updates to Google Auth Platform
Apresentamos o TxGemma: modelos abertos para melhorar o desenvolvimento terapêutico
Prepare-se para o Google I/O: programação revelada