# MiniMaxH3ImageTransformer2DModel

Un modelo Diffusion Transformer para la generación y edición de imágenes, introducido en [MiniMax-H3-Image](https://huggingface.co/MiniMaxAI/MiniMax-H3-Image) por MiniMax.

Es el [MiniMaxH3Transformer3DModel](/docs/diffusers/v0.43.0/es/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel) sin su flujo de audio: una única pila de bloques procesa **una secuencia 1-D empaquetada** que contiene la condición de texto, las filas de las imágenes de referencia y las filas de la imagen generada. Construir el diseño empaquetado es responsabilidad del llamador, por lo que la firma de forward recibe el diseño por separado de los latentes: la cuadrícula de posiciones `(t, h, w)`, las etiquetas de modalidad por fila, los índices de timestep por fila y los dos tensores de índice que dirigen a las filas de imagen y texto. [MiniMaxH3ImageBlocks](/docs/diffusers/v0.43.0/es/api/pipelines/minimax_h3_image#diffusers.MiniMaxH3ImageBlocks) construye todo ello.

El checkpoint se destila a seis pasos de muestreo mediante Parallel Decoding Distillation (PDD), que mantiene una cabeza de salida por paso. Por lo tanto, `forward` toma `pdd_step_index`, el paso que se está ejecutando, y proyecta con la cabeza de ese paso.

```python
import torch
from diffusers import MiniMaxH3ImageTransformer2DModel

transformer = MiniMaxH3ImageTransformer2DModel.from_pretrained(
    "MiniMaxAI/MiniMax-H3-Image", subfolder="transformer_diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
```

El checkpoint es de precisión mixta: la proyección de entrada de parches, el MLP de paso de tiempo y las cabezas de salida son float32, mientras que la pila de bloques es bfloat16. `from_pretrained` mantiene ese diseño a través de `_keep_in_fp32_modules`, por lo que debe pasar `dtype=torch.bfloat16` y dejar que coloque los módulos float32, en lugar de convertir el modelo con `.to(torch.bfloat16)` después.

## MiniMaxH3ImageTransformer2DModel[[diffusers.MiniMaxH3ImageTransformer2DModel]]

#### diffusers.MiniMaxH3ImageTransformer2DModel[[diffusers.MiniMaxH3ImageTransformer2DModel]]

```python
diffusers.MiniMaxH3ImageTransformer2DModel(num_attention_heads: int = 56, attention_head_dim: int = 128, hidden_size: int = 5376, num_layers: int = 50, num_refiner_layers: int = 2, ffn_dim: int = 14336, in_channels: int = 24, patch_size: tuple[int, int, int] = (1, 2, 2), text_dim: int = 5120, freq_dim: int = 256, time_embed_hidden_dim: int = 5376, time_embed_dim: int = 2688, rope_freq_dim: int = 16, rope_theta: float = 10000.0, norm_eps: float = 1e-05, qk_norm_eps: float = 1e-05, final_norm_eps: float = 1e-05, num_pdd_heads: int = 6)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_minimax_h3_image.py#L365)

**Parámetros:**

num_attention_heads (`int`, por defecto `56`) : El número de cabezas a utilizar para la atención multi-cabeza.

attention_head_dim (`int`, por defecto `128`) : El número de canales en cada cabeza de atención. Tenga en cuenta que `num_attention_heads * attention_head_dim` es *mayor* que `hidden_size`.

hidden_size (`int`, por defecto `5376`) : El número de canales de la secuencia empaquetada (el flujo residual).

num_layers (`int`, por defecto `50`) : El número de bloques de transformer.

num_refiner_layers (`int`, por defecto `2`) : El número de bloques de refinamiento de tokens aplicados al flujo de texto proyectado.

ffn_dim (`int`, por defecto `14336`) : La dimensión interna de las capas de retroalimentación SwiGLU.

in_channels (`int`, por defecto `24`) : El número de canales de los latentes de la imagen.

patch_size (`tuple[int, int, int]`, por defecto `(1, 2, 2)`) : El parche `(t, h, w)` utilizado para empaquetar los latentes en filas.

text_dim (`int`, por defecto `5120`) : El número de canales de la condición de texto producida por el codificador de texto.

freq_dim (`int`, por defecto `256`) : La dimensión de la incrustación sinusoidal del paso de tiempo. Los pasos de tiempo se consumen sin escalar en `[0, 1]`.

time_embed_hidden_dim (`int`, por defecto `5376`) : La dimensión interna del MLP de paso temporal.

time_embed_dim (`int`, por defecto `2688`) : La dimensión de salida del MLP de timestep, es decir, la entrada de cada proyección AdaLN.

rope_freq_dim (`int`, por defecto `16`) : El número de frecuencias rotatorias por eje. Los ejes `(t, h, w)` comparten un búfer `inv_freq` de esta longitud y `2 * 3 * rope_freq_dim` de los canales de `attention_head_dim` se rotan.

rope_theta (`float`, por defecto `10000.0`) : La base del programa de frecuiones rotatorias desde el que se calcula el búfer `rope.inv_freq`.

norm_eps (`float`, por defecto `1e-5`) : Epsilon de las normas pre-atención y pre-feed-forward.

qk_norm_eps (`float`, por defecto `1e-5`) : Epsilon de las normas de consulta/clave por cabeza.

final_norm_eps (`float`, por defecto `1e-5`) : Epsilon de la normalización de la salida del refinador de tokens y de `norm_out`.

num_pdd_heads (`int`, por defecto `6`) : El número de pasos de muestreo a los que se destiló el checkpoint, cada uno con su propia cabeza de salida.

Un modelo Transformer para la generación y edición de imágenes, introducido en MiniMax-H3-Image.

Es el transformer MiniMax-H3 sin su flujo de audio: una única pila de bloques procesa **una secuencia 1-D empaquetada** que contiene la condición de texto, las filas de las imágenes de referencia y las filas de la imagen generada. La atención es autoatención completa sobre esa secuencia; no hay atención cruzada. El checkpoint se destila a un número fijo de pasos de muestreo mediante Parallel Decoding Distillation (PDD), que mantiene una cabeza de salida por paso, por lo que `forward` recibe el índice del paso que se está ejecutando.

El llamador es responsable de construir el empaquetado: aplicar patchify a los latentes, ordenar las filas y generar la cuadrícula de posiciones `(t, h, w)`, las etiquetas de modalidad por fila y los índices de timestep por fila. La secuencia no lleva relleno, por lo que la atención se ejecuta sin enmascarar sobre un solo documento y todos los backends de atención permanecen disponibles.

El eje de lote es un eje de replicación pura: los argumentos estructurales (`timestep`, `timestep_indices`, `token_tags`, `position_ids` y los dos tensores de índice) describen una única disposición empaquetada que comparten todos los elementos del lote.

#### forward[[diffusers.MiniMaxH3ImageTransformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: Tensor, timestep_indices: Tensor, token_tags: Tensor, position_ids: Tensor, image_indices: Tensor, text_indices: Tensor, pdd_step_index: int, return_dict: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_minimax_h3_image.py#L545)

**Parámetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, num_image_tokens, in_channels * prod(patch_size))`) : Filas latentes en parches: las filas de las imágenes de referencia y las filas de la imagen generada, ordenadas según aparecen en la secuencia empaquetada, es decir, coincidiendo con `image_indices`.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, num_text_tokens, text_dim)`) : Condicionamiento de texto, ordenado para que coincida con `text_indices`.

timestep (`torch.Tensor` de forma `(num_timesteps,)`) : Los valores de *pasos de tiempo* distintos presentes en la secuencia empaquetada, en `[0, 1]` y sin escalar. Una sola pasada hacia adelante sirve filas en diferentes niveles de ruido (filas generadas, filas de referencia).

timestep_indices (`torch.Tensor` de forma `(seq_len,)`) : Para cada fila de la secuencia empaquetada, el índice de su paso de tiempo en `timestep`.

token_tags (`torch.Tensor` de forma `(seq_len,)`) : Para cada fila de la secuencia empaquetada, su modalidad: `0` imagen, `1` texto.

position_ids (`torch.Tensor` de forma `(seq_len, 3)`) : Las coordenadas rotatorias `(t, h, w)` de cada fila de la secuencia empaquetada.

image_indices (`torch.Tensor` de forma `(num_image_tokens,)`) : Posiciones de las filas de la imagen en la secuencia empaquetada.

text_indices (`torch.Tensor` de forma `(num_text_tokens,)`) : Posiciones de las filas de texto en la secuencia empaquetada.

pdd_step_index (`int`) : El paso de muestreo, que selecciona la cabeza de salida.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [Transformer2DModelOutput](/docs/diffusers/v0.43.0/es/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) en lugar de una tupla simple.

**Devuelve:** [Transformer2DModelOutput](/docs/diffusers/v0.43.0/es/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) o `tuple`

La velocidad de cada fila de imagen, de forma `(batch_size, num_image_tokens, in_channels * prod(patch_size))`, en el orden de filas de `image_indices`.