Todo sobre Gemma: novedades de Gemma 3

30 DE ABRIL DE 2025

Ju-yeong Ji Sr. Technical Consultant Gen AI – AI Studio

Ravin Kumar Senior Research Engineer Google DeepMind

En las entradas anteriores de la serie “Todo sobre Gemma”, proporcionamos una descripción detallada de las arquitecturas de la familia de modelos Gemma. Aquí encontrarás enlaces a cada publicación:

Todo sobre Gemma: una descripción general de las arquitecturas de la familia de modelos de Gemma

Todo sobre Gemma: novedades de Gemma 2

Todo sobre Gemma: arquitectura RecurrentGemma

Todo sobre Gemma: arquitectura PaliGemma

En esta entrada, analizaremos el último modelo, Gemma 3. Comencemos.

Gemma 3

Un cambio importante con respecto a las versiones anteriores es la nueva compatibilidad de Gemma 3 con las capacidades de lenguaje-visión. Quienes conozcan la arquitectura PaliGemma pueden reconocer un codificador SigLIP que se utiliza en Gemma 3, aunque se adaptó para esta implementación específica.

Estos son los parámetros principales de los nuevos modelos.

Veamos las diferencias y mejoras clave de Gemma 3.

Principales diferencias

Si bien la arquitectura de Gemma 3 hereda aspectos de sus predecesoras, también presenta nuevas modificaciones que se describen a continuación.

Compatibilidad con lenguaje-visión

Una de las principales mejoras de Gemma 3 es su nueva capacidad de comprensión de lenguaje-visión. Los modelos 4B, 12B y 27B utilizan un codificador de visión SigLIP personalizado, que le permite al modelo interpretar las entradas visuales.

El codificador de visión funciona con imágenes cuadradas fijas de 896x896. Para procesar las imágenes con diferentes relaciones de aspecto o resoluciones altas, se utiliza un algoritmo “Pan&Scan”. Durante este proceso, se recorta adaptativamente la imagen, se cambia el tamaño de cada recorte a 896x896 y, luego, se la codifica. Si bien este método mejora el rendimiento, en particular cuando la información detallada es crítica, produce una mayor sobrecarga computacional durante la inferencia.

Además, Gemma 3 trata las imágenes como una secuencia de “tokens blandos” compactos producidos por MultiModalProjector. Esta técnica reduce en gran medida los recursos de inferencia necesarios para el procesamiento de imágenes, ya que representa datos visuales con un número fijo de 256 vectores.

Antes de continuar, es posible que te preguntes: “¿Cuándo debo usar Gemma 3, en lugar de PaliGemma 2?”.

La fortaleza de PaliGemma 2 está en funciones que no se encuentran en Gemma 3, como la segmentación de imágenes y la detección de objetos. Sin embargo, Gemma 3 integró y amplió la tecnología de PaliGemma, y ofrece chat de varios turnos y un sólido rendimiento de cero disparos para procesar varias tareas de visión en forma directa.

Para tomar una decisión final, también debes considerar tus recursos computacionales disponibles y la importancia de funciones avanzadas, como un contexto más extenso o soporte multilingüe, para las que Gemma 3 ofrece mejoras notables.

Cambios en la arquitectura para una memoria más eficaz

Se modificó la arquitectura para reducir el uso de memoria caché KV, que tiende a aumentar con los contextos más extensos.

Atención intercalada 5 a 1

La arquitectura del modelo actualizado se compone de bloques de intercalados repetidos, cada uno con 5 capas de atención local con una ventana deslizante de 1024, y 1 capa de atención global. Este diseño permite que el modelo capture las dependencias de corto y largo alcance, lo que produce respuestas más precisas y contextualmente relevantes.

^Nota:^{Gemma 1 se basó únicamente en la atención global, mientras que Gemma 2 introdujo un enfoque híbrido que alternaba entre capas de atención local y global. Gemma 3 integra 5 capas de atención local dedicadas, lo que permite obtener respuestas que son más precisas y contextualmente apropiadas.}

Gemma 3 local and global attention layers depicted in a table, compared to Gemma 1 and Gemma 2

Sin limitaciones

Tanto Gemma 2 como Gemma 3 utilizan la atención de consultas agrupadas (GQA) con normalización posterior y previa con RMSNorm. Sin embargo, Gemma 3 obtiene una mayor precisión y velocidades de procesamiento más rápidas al adoptar la norma QK en lugar del mecanismo de limitación de Gemma 2.

Contexto más extenso

Como resultado de los cambios en la arquitectura que analizamos anteriormente, Gemma 3 utiliza la atención intercalada para reducir los requisitos de memoria, lo que permite ofrecer compatibilidad con contextos más extensos. De esta manera, se pueden analizar documentos y conversaciones más largos sin perder el contexto. Específicamente, puede manejar 32,000 tokens con el modelo 1B y 128,000 tokens con modelos más grandes.

^Nota:^{La ventana de contexto de 128,000 tokens permite que el modelo procese una cantidad de texto tan larga como una novela estándar (alrededor de 80,000 palabras). Este tamaño de ventana es de aproximadamente 96,000 palabras, 198 páginas, 500 imágenes o más de 8 minutos de video a 1 fps.}

Codificador y procesamiento de visión

Gemma 3 solo utiliza la atención bidireccional con entradas de imágenes.

La atención normal (también conocida como atención unidireccional) es como leer. Imagina que lees un libro. Entiendes cada palabra teniendo en cuenta las palabras anteriores. Así es como funciona la atención típica en los modelos de lenguaje. Es secuencial y mira hacia atrás para crear contexto.

Por su parte, la atención bidireccional es como ver un rompecabezas. Piensa en una imagen como un rompecabezas. Los “tokens de imagen” son como las piezas individuales. Por lo tanto, cada pieza “mira” y se conecta con todas las demás piezas de la imagen, independientemente de su posición. Considera la imagen completa a la vez, no solo una secuencia. Se obtiene una comprensión completa porque cada parte está relacionada con todas las demás partes.

Entonces, ¿por qué no usar siempre la atención bidireccional? Si ver todo el contexto suena mejor, no siempre se usa para el texto. Es necesario tener en cuenta la tarea:

Comprensión (sirve la atención bidireccional)
Para las tareas en las que tenemos todo el texto y necesitamos comprenderlo profundamente (como en modelos como BERT), la atención bidireccional es excelente.

Predicción (es mejor la atención unidireccional)
Cuando la tarea es predecir la siguiente palabra o generar texto, un enfoque unidireccional (autorregresivo) es más natural. Predecir lo que viene a continuación es inherentemente secuencial. También suele ser más eficaz desde el punto de vista computacional.

La diferencia clave es que el enfoque bidireccional se utiliza cuando el modelo no está creando una secuencia.

En la siguiente visualización, se muestra el mecanismo de atención de 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>¿Qué es esto?<end_of_turn>\n<start_of_turn>model\nEs una imagen de un gato.<end_of_turn>")

Python

Resultado:

También puedes ver la diferencia entre este mecanismo de atención y el de PaliGemma. Para proporcionar contexto para esta comparación, PaliGemma opera recibiendo una o más imágenes, junto con una descripción de tarea basada en texto (el mensaje o prefijo), y posteriormente genera una predicción como una cadena de texto (la respuesta o sufijo) de manera autorregresiva.

Código:

visualizer = AttentionMaskVisualizer("google/paligemma2-3b-mix-224")
visualizer("<img> caption en", suffix="un gato en una playa.")

Python

Resultado:

Attention mechanism in PaliGemma : Output

Nuevo tokenizador

Gemma 3 mejoró las capacidades multilingües gracias a una combinación de datos revisada y una mayor cantidad de datos multilingües (tanto monolingües como paralelos).

Gemma 3 también presenta un tokenizador mejorado. El tamaño del vocabulario ahora es de 262,000, pero se usa el mismo tokenizador SentencePiece. Para evitar errores, utiliza el nuevo tokenizador con Gemma 3. Se trata del mismo tokenizador que usa Gemini, que es más equilibrado para los idiomas que no son el inglés.

Gemma 3 27B

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)
  )
)

Python

^Nota: ^{Técnicamente, las incrustaciones posicionales giratorias (RoPE) están dentro de la atención de producto escalar (SDPA), pero en este diagrama hicimos una simplificación. Consulta} ^{el código}^{para conocer los detalles precisos de la arquitectura.}

Gemma 3 1B

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)
)

Python

Este modelo 1B de solo texto se optimizó específicamente para uso en dispositivos, lo que hace que la IA avanzada sea accesible en sistemas móviles e integrados. Esto afecta en gran medida la accesibilidad, la privacidad y el rendimiento, ya que las aplicaciones impulsadas por IA ahora pueden funcionar de manera eficaz incluso con una conectividad de red limitada o nula.

Principales descubrimientos

Nuestro informe técnico proporciona amplios detalles, pero aquí hay un breve resumen de los principales hallazgos de Gemma 3:

Rendimiento superior en los mismos tamaños:
los modelos Gemma 3 logran un rendimiento superior en comparación con Gemma 2 en ambas versiones preentrenadas y ajustadas según la instrucción en varias comparativas. Es el mejor modelo que cabe en una GPU o TPU host comercial. El modelo de Gemma 27B TI se reconoció como uno de los 10 mejores modelos en LM Arena a partir del 12 de abril de 2025, con lo que superó a modelos de código abierto mucho más grandes y obtuvo una puntuación Elo bastante más alta que Gemma 2.

Reducción de memoria caché KV:
los cambios en la arquitectura de Gemma 3 reducen de manera eficaz la sobrecarga de memoria caché KV durante la inferencia con contexto extenso, en comparación con los mecanismos de atención solo global utilizados en Gemma 1 y la relación local/global 1:1 utilizada en Gemma 2.

Procesamiento eficaz de contexto extenso:
los modelos de Gemma 3 pueden generalizar en un contexto de 128,000 tokens después del cambio de escala de RoPE durante el entrenamiento previo. Aumentamos la frecuencia base de RoPE de 10k a 1M en las capas globales de autoatención y mantenemos la frecuencia de las capas locales en 10k.

Mejor capacidad multilingüe:
Gemma 3 utiliza el mismo tokenizador que Gemini, que es más equilibrado para los idiomas que no son el inglés. También revisamos la combinación de datos previos al entrenamiento y el proceso posterior a este para mejorar las capacidades multilingües.

Impacto de la resolución del codificador de visión:
los codificadores de visión de mayor resolución generan un mejor rendimiento en las tareas de visión. El método Pan & Scan mejora aún más el rendimiento en tareas que involucran relaciones de aspecto no cuadradas, imágenes de alta resolución y lectura de texto en imágenes.

Resumen

Analizamos la arquitectura de Gemma 3 y destacamos las nuevas funciones que la diferencian de las versiones anteriores. Estas opciones de arquitectura permiten que Gemma 3 tenga un mejor rendimiento en una serie más amplia de tareas, incluidas las habilidades multilingües mejoradas e interacción con imágenes, al tiempo que allana el camino para futuros modelos de lenguaje multimodal más capaces y amigables con los recursos, adecuados para hardware estándar.

Creemos que las innovaciones de Gemma 3 permitirán a los investigadores y desarrolladores crear la próxima generación de modelos de lenguaje multimodal eficaces y potentes.

¡Gracias por leer!