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:
En esta entrada, analizaremos el último modelo, Gemma 3. Comencemos.
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.
Si bien la arquitectura de Gemma 3 hereda aspectos de sus predecesoras, también presenta nuevas modificaciones que se describen a continuació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.
Se modificó la arquitectura para reducir el uso de memoria caché KV, que tiende a aumentar con los contextos más extensos.
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.
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.
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.
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:
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>")
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.")
Resultado:
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.
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)
)
)
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.
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 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.
Nuestro informe técnico proporciona amplios detalles, pero aquí hay un breve resumen de los principales hallazgos de Gemma 3:
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!