Monkey patching (función experimental)

El *monkey patching* permite reemplazar componentes del modelo de forma global sin modificar el código original del modelo. Una vez registrados, los parches se aplican automáticamente al cargar cualquier modelo con from_pretrained() o ~PreTrainedModel.from_config. Esto le permite reestructurar modelos para requisitos específicos, como la compatibilidad con cuantización, aplicar optimizaciones o experimentar con variantes arquitectónicas.

El monkey patching debe usarse como último recurso cuando se necesita cambiar el diseño y la estructura de un módulo y/o de sus pesos. Para muchas necesidades de personalización y optimización, intente usar la interfaz de Atención, la interfaz de Expertos o el registro de Kernels en su lugar. Solo use monkey patching cuando se requieran cambios estructurales que no puedan lograrse únicamente mediante implementaciones personalizadas de forward (por ejemplo, para compatibilidad con bibliotecas de cuantización, fusión de capas o experimentos arquitectónicos).

Inicio rápido

A continuación se muestra un ejemplo sencillo que ilustra cómo reemplazar un componente de un modelo:

from transformers import AutoModelForCausalLM
from transformers.models.llama.modeling_llama import LlamaAttention
from transformers.monkey_patching import register_patch_mapping


# Define your replacement class (must inherit from nn.Module)
class CustomLlamaAttention(LlamaAttention):
    def forward(self, *args, **kwargs):
        # Your custom implementation
        print("Using custom attention!")
        return super().forward(*args, **kwargs)


# Register the patch globally (only applies to transformers modeling modules)
register_patch_mapping(mapping={"LlamaAttention": CustomLlamaAttention})

# Load a model - the patch is automatically applied during initialization
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")

# All LlamaAttention layers in the model are now CustomLlamaAttention instances
print(type(model.model.layers[0].self_attn))  # <class '__main__.CustomLlamaAttention'>

Cómo funciona

Los parches de mono funcionan mediante un proceso de dos pasos:

Registro: Llama a register_patch_mapping para añadir mapeos a un registro global.
Aplicación: Los parches se aplican automáticamente durante la inicialización del modelo:
- from_pretrained / from_config: Los parches se aplican automáticamente mediante un gestor de contexto interno. ¡No se requiere ninguna acción adicional!
- Construcción manual (p. ej., Model(config)): debes usar manualmente el gestor de contexto apply_patches.

Una vez que los parches se registran, persisten y afectan todas las cargas de modelos posteriores hasta que los elimines con clear_patch_mapping.

Limitaciones importantes:

Solo se permite aplicar parches a clases de los módulos de modelado de transformers (p. ej., LlamaAttention, LlamaMLP).
Las claves de la correspondencia pueden ser nombres de clase exactos o patrones de expresiones regulares (consulte Correspondencia de patrones a continuación).

Registro global

Use register_patch_mapping para registrar mapeos de forma global:

from transformers.monkey_patching import register_patch_mapping

# Register a single patch
register_patch_mapping(
    mapping={"Qwen2MoeExperts": SequentialExperts}
)

# Register multiple patches at once
register_patch_mapping(
    mapping={
        "Qwen2MoeExperts": SequentialExperts,
        "Qwen2MoeAttention": CustomAttention,
    },
    # Overwrite existing patches if they exist
    overwrite=True,
)

Coincidencia de patrones

Puede usar expresiones regulares para coincidir con varias clases mediante un único patrón:

from transformers.monkey_patching import register_patch_mapping

# Match all classes containing "Attention"
register_patch_mapping(
    mapping={".*Attention": CustomAttention}
)

# More examples
register_patch_mapping(
    mapping={
        ".*MoeExperts$": CustomExperts,           # Ends with "MoeExperts"
        "^Llama\\d+Attention$": CustomAttention,  # Llama2Attention, Llama3Attention, etc.
    }
)

Importante: Las coincidencias exactas tienen prioridad sobre los patrones. Si registras tanto "LlamaAttention" como ".*Attention", las clases llamadas LlamaAttention usarán la sustitución de coincidencia exacta, mientras que las demás clases coincidentes usarán la sustitución por patrón.

Los patrones de expresiones regulares pueden romper modelos de forma silenciosa. Un patrón amplio como ".*Attention" coincidirá con cada clase cuyo nombre contenga “Attention”, incluidas las clases contenedora que envuelven la atención que realmente se desea reemplazar. Por ejemplo, BERT tiene tres clases relacionadas con la atención: BertSelfAttention y BertCrossAttention (las implementaciones internas de atención) y BertAttention (un módulo externo que contiene una de esas clases internas). Si se parchean las tres con la misma capa de atención personalizada, se obtiene un modelo roto, porque el módulo externo BertAttention ya no envuelve al interno: es él mismo, lo que elimina submódulos esperados como self y output. Se recomienda usar patrones estrechos (p. ej., ".*SelfAttention$") o nombres de clase exactos para evitar coincidencias no deseadas.

Para desregistrar parches, use unregister_patch_mapping:

from transformers.monkey_patching import unregister_patch_mapping

# Unregister a single patch (use exact name or pattern from registration)
unregister_patch_mapping(keys=["Qwen2MoeExperts"])

# Unregister multiple patches at once
unregister_patch_mapping(keys=["Qwen2MoeExperts", "Qwen2MoeAttention"])

# Unregister a pattern
unregister_patch_mapping(keys=[".*Attention"])

Para borrar todos los parches registrados, use clear_patch_mapping:

from transformers.monkey_patching import clear_patch_mapping

clear_patch_mapping()

Para ver los parches registrados actualmente, use get_patch_mapping:

from transformers.monkey_patching import get_patch_mapping

current_patches = get_patch_mapping()
print(current_patches)

Construcción manual de modelos

El gestor de contexto apply_patches solo es necesario cuando se construyen modelos manualmente (p. ej., Model(config)) sin utilizar from_pretrained ni from_config:

from transformers import LlamaModel, LlamaConfig
from transformers.monkey_patching import register_patch_mapping, apply_patches

# Register patch globally
register_patch_mapping(mapping={"LlamaAttention": CustomAttention})

# For manual construction, you need the context manager
with apply_patches():
    model = LlamaModel(LlamaConfig())  # Uses CustomAttention

# Without the context manager, manual construction uses original classes
model = LlamaModel(LlamaConfig())  # Uses LlamaAttention

# But from_pretrained and from_config will always apply registered patches
model = LlamaModel.from_pretrained("meta-llama/Llama-3.2-1B")  # Uses CustomAttention

Notas importantes

Gestión de pesos: El monkey patching solo reemplaza clases, no pesos. Si la clase parcheada tiene una distribución de pesos diferente, deberá gestionar las conversiones de pesos por separado para garantizar la compatibilidad con los pesos preentrenados. Consulte el Ejemplo completo a continuación para ver cómo combinar monkey patches con mapeos de conversión de pesos.
Efecto global: Los parches registrados con register_patch_mapping se aplican de forma global a todos los modelos cargados después del registro. Utilice siempre clear_patch_mapping para limpiar al terminar, especialmente en pruebas, cuadernos o aplicaciones de larga duración.
Validación de clases: la API valida automáticamente que las clases de reemplazo sean subclases de nn.Module. Si pasas una clase no válida, recibirás un mensaje de error claro.
Seguridad de subprocesos: Todas las operaciones de parcheo son seguras para subprocesos. Puede registrar, desregistrar y aplicar parches de forma segura desde varios subprocesos.
Comportamiento de coincidencia: Al usar nombres de clase exactos, deben coincidir exactamente con los nombres de clase originales tal como aparecen en el código fuente del modelo (distingue entre mayúsculas y minúsculas). Al usar patrones de expresión regular, se comparan con los nombres de clase mediante re.search().

Solución de problemas

Mi parche no se está aplicando

Comprobar el nombre de la clase o el patrón: Asegúrate de que el nombre de la clase o el patrón en tu mapeo sea correcto:

# For exact names - must match exactly (case-sensitive)
register_patch_mapping(mapping={"LlamaAttention": CustomAttention})

# For patterns - use valid regex
register_patch_mapping(mapping={".*Attention": CustomAttention})

Verificar el registro: Utilice get_patch_mapping para confirmar que su mapeo está registrado:

print(get_patch_mapping())
# Shows all registered mappings: {'LlamaAttention': <class 'CustomAttention'>, '.*MLP': <class 'CustomMLP'>}

Comprobar el origen del modelo: Busca el nombre exacto de la clase en el código fuente del modelo:

from transformers.models.llama import modeling_llama
print(dir(modeling_llama))  # Look for the class name

¿Cómo sé si mi parche está funcionando?

Inspecciona el modelo cargado para verificar el parche:

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")

# Check the type of a specific module
print(type(model.model.layers[0].self_attn))  # Should show your custom class

# Or iterate through all modules
for name, module in model.named_modules():
    if 'attention' in name.lower():
        print(f"{name}: {type(module)}")

Errores de incompatibilidad de forma de pesos

Si su clase parcheada tiene formas de pesos diferentes, registre una conversión de pesos:

from transformers.conversion_mapping import register_checkpoint_conversion_mapping, WeightConverter
from transformers.monkey_patching import register_patch_mapping

register_patch_mapping(
    mapping={
        "LlamaAttention": LlamaFusedAttention,
    }
)

register_checkpoint_conversion_mapping(
    model_type_or_class_name="llama",
    mapping=[
        WeightConverter(
            source_patterns=["q_proj", "k_proj", "v_proj"],
            target_patterns=["qkv_proj"],
            operations=[
                Concatenate(dim=0),
            ],
        )
    ],
    overwrite=True,
)

Limpieza de parches

Siempre limpia los parches cuando termines para evitar afectar a otro código:

from transformers.monkey_patching import register_patch_mapping, clear_patch_mapping

try:
    register_patch_mapping(mapping={"LlamaAttention": CustomAttention})
    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
    # ... use model ...
finally:
    clear_patch_mapping()  # Always clean up

Ejemplo completo

A continuación se muestra un ejemplo completo que ilustra cómo reestructurar tanto los módulos de expertos como los de atención en un modelo Mixture-of-Experts (qwen2_moe) para optimizarlo y garantizar su compatibilidad con la cuantización. Esto demuestra:

Creación de clases de reemplazo personalizadas que mantienen la misma interfaz
Registro de parches de mono para múltiples componentes
Gestión de las conversiones de pesos para la nueva estructura

from typing import Unpack

import torch
import torch.nn as nn

from transformers import AutoModelForCausalLM, Concatenate, WeightConverter
from transformers.activations import ACT2FN
from transformers.cache_utils import Cache
from transformers.conversion_mapping import register_checkpoint_conversion_mapping
from transformers.integrations.sdpa_attention import sdpa_attention_forward
from transformers.models.qwen2_moe.modeling_qwen2_moe import apply_rotary_pos_emb
from transformers.monkey_patching import register_patch_mapping
from transformers.utils.generic import TransformersKwargs


class MoeMLP(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.num_experts = config.num_experts
        self.hidden_size = config.hidden_size
        self.intermediate_size = config.moe_intermediate_size
        self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
        self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)
        self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)
        self.act_fn = ACT2FN[config.hidden_act]

    def forward(self, x):
        down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
        return down_proj


# Adapted from the original Qwen2MoeExperts
class ModuleListExperts(nn.ModuleList):
    def __init__(self, config):
        super().__init__()
        self.config = config
        self.num_experts = config.num_experts
        for _ in range(self.num_experts):
            self.append(MoeMLP(config))

    def forward(
        self, hidden_states: torch.Tensor, top_k_index: torch.Tensor, top_k_weights: torch.Tensor
    ) -> torch.Tensor:
        final_hidden_states = torch.zeros_like(hidden_states)
        with torch.no_grad():
            expert_mask = torch.nn.functional.one_hot(top_k_index, num_classes=self.num_experts)
            expert_mask = expert_mask.permute(2, 1, 0)

        for expert_idx in range(self.num_experts):
            top_k_pos, token_idx = torch.where(expert_mask[expert_idx])
            current_state = hidden_states[token_idx]
            current_hidden_states = self[expert_idx](current_state)
            current_hidden_states = current_hidden_states * top_k_weights[token_idx, top_k_pos, None]
            final_hidden_states.index_add_(0, token_idx, current_hidden_states.to(final_hidden_states.dtype))
        return final_hidden_states


# Adapted from the original Qwen2MoeAttention
class FusedQKVAttention(nn.Module):
    def __init__(self, config, layer_idx: int):
        super().__init__()
        self.config = config
        self.layer_idx = layer_idx
        self.head_dim = getattr(config, "head_dim", config.hidden_size // config.num_attention_heads)
        self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
        self.scaling = self.head_dim**-0.5
        self.attention_dropout = config.attention_dropout
        self.is_causal = True

        self.qkv_proj = nn.Linear(config.hidden_size, 3 * config.num_attention_heads * self.head_dim, bias=True)
        self.o_proj = nn.Linear(config.num_attention_heads * self.head_dim, config.hidden_size, bias=False)

        if self.config.layer_types[layer_idx] == "sliding_attention":
            self.sliding_window = config.sliding_window

    def forward(
        self,
        hidden_states: torch.Tensor,
        position_embeddings: tuple[torch.Tensor, torch.Tensor] | None = None,
        attention_mask: torch.Tensor | None = None,
        past_key_values: Cache | None = None,
        **kwargs: Unpack[TransformersKwargs],
    ) -> tuple[torch.Tensor, torch.Tensor]:
        input_shape = hidden_states.shape[:-1]
        hidden_shape = (*input_shape, -1, self.head_dim)

        query_states, key_states, value_states = self.qkv_proj(hidden_states).chunk(3, dim=-1)

        query_states = query_states.view(hidden_shape).transpose(1, 2)
        key_states = key_states.view(hidden_shape).transpose(1, 2)
        value_states = value_states.view(hidden_shape).transpose(1, 2)

        cos, sin = position_embeddings
        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)

        if past_key_values is not None:
            key_states, value_states = past_key_values.update(key_states, value_states, self.layer_idx)

        attn_output, attn_weights = sdpa_attention_forward(
            self,
            query_states,
            key_states,
            value_states,
            attention_mask,
            dropout=0.0 if not self.training else self.attention_dropout,
            scaling=self.scaling,
            **kwargs,
        )

        attn_output = attn_output.reshape(*input_shape, -1).contiguous()
        attn_output = self.o_proj(attn_output)
        return attn_output, attn_weights


# Registering monkey patches for the new attention and experts modules.
register_patch_mapping(
    mapping={
        "Qwen2MoeExperts": ModuleListExperts,
        "Qwen2MoeAttention": FusedQKVAttention,
    }
)

# Registering weight conversion mappings adapted for the new modules. This registration will:
# - Override the original conversion mapping for qwen2_moe which concatenated the experts into a single parameter format.
# - Concatenate the q_proj, k_proj, v_proj weights/biases into a single qkv_proj weight/bias for the new fused attention module.
register_checkpoint_conversion_mapping(
    model_type_or_class_name="qwen2_moe",
    mapping=[
        WeightConverter(
            source_patterns=["q_proj", "k_proj", "v_proj"],
            target_patterns=["qkv_proj"],
            operations=[Concatenate(dim=0)],
        ),
    ],
    overwrite=True,
)

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-MoE-A2.7B")

Grabación y reproducción del enrutamiento de expertos en MoE

Los flujos de trabajo de entrenamiento de Mixture-of-Experts, como RLHF, necesitan registrar a qué expertos se enrutó cada token durante la generación y, a continuación, reproducir esa enrutación exacta en una pasada de entrenamiento independiente. Puedes construir esto de extremo a extremo con el mecanismo existente de monkey patching y captura de salidas, sin necesidad de modificar los archivos de modelado.

El patrón tiene tres partes:

Un subclase de router reproducible que puede leer opcionalmente índices de expertos forzados desde un atributo de instancia.
Un context manager que establece esos atributos en cada router antes de una pasada hacia adelante y los limpia después.
Una entrada en el registro de captura de salidas del modelo para que output_<name>=True exponga los índices a través de la ruta estándar @capture_outputs.

from contextlib import contextmanager

import torch
import torch.nn.functional as F

from transformers import Qwen3MoeConfig, Qwen3MoeForCausalLM
from transformers.models.qwen3_moe.modeling_qwen3_moe import Qwen3MoeTopKRouter
from transformers.monkey_patching import apply_patches, register_patch_mapping
from transformers.utils.output_capturing import _CAN_RECORD_REGISTRY, OutputRecorder


class ReplayableQwen3MoeTopKRouter(Qwen3MoeTopKRouter):
    _forced_indices: torch.Tensor | None = None

    def forward(self, hidden_states):
        hidden_states = hidden_states.reshape(-1, self.hidden_dim)
        router_logits = F.linear(hidden_states, self.weight)
        router_logits = F.softmax(router_logits, dtype=torch.float, dim=-1)

        if self._forced_indices is not None:
            router_indices = self._forced_indices.to(router_logits.device).long()
            # Megatron-style replay: preserve expert path, recompute current scores
            router_top_value = router_logits.gather(-1, router_indices)
        else:
            router_top_value, router_indices = torch.topk(router_logits, self.top_k, dim=-1)

        if self.norm_topk_prob:
            router_top_value = router_top_value / router_top_value.sum(dim=-1, keepdim=True)
        return router_logits, router_top_value.to(router_logits.dtype), router_indices


@contextmanager
def replay_moe_routing(model, selected_experts_per_layer):
    routers = [m for m in model.modules() if isinstance(m, ReplayableQwen3MoeTopKRouter)]
    if len(routers) != len(selected_experts_per_layer):
        raise ValueError(f"Got {len(routers)} routers but {len(selected_experts_per_layer)} tensors")
    for r, t in zip(routers, selected_experts_per_layer):
        r._forced_indices = t
    try:
        yield
    finally:
        for r in routers:
            r._forced_indices = None


# Swap the router class and construct the model
register_patch_mapping({"Qwen3MoeTopKRouter": ReplayableQwen3MoeTopKRouter})
with apply_patches():
    model = Qwen3MoeForCausalLM(Qwen3MoeConfig(...)).eval()

# Expose `output_selected_experts=True` on the base model by adding an OutputRecorder
# at runtime. Index 2 of the router's tuple output is the expert indices.
inner = model.model
existing = _CAN_RECORD_REGISTRY.get(str(inner.__class__), {}) or {}
_CAN_RECORD_REGISTRY[str(inner.__class__)] = {
    **existing,
    "selected_experts": OutputRecorder(ReplayableQwen3MoeTopKRouter, index=2),
}

# Record
captured = inner(input_ids=input_ids, output_selected_experts=True)
selected_experts = captured.selected_experts  # tuple of (num_tokens, top_k) LongTensors

# Replay — same expert path regardless of current router weights
with replay_moe_routing(inner, list(selected_experts)):
    outputs = inner(input_ids=input_ids)

Replay conserva los índices exactos de los expertos y recalcula las puntuaciones de enrutamiento con los pesos actuales del router, de modo que los gradientes fluyan a través de los parámetros en vivo mientras la selección de expertos permanece fija. Este es el contrato mínimo de replay utilizado en el entrenamiento de MoE estilo Megatron.

Interoperabilidad con vLLM

La opción enable_return_routed_experts=True de vLLM rellena CompletionOutput.routed_experts como un array (seq_len, num_layers, top_k) de np.int32. Conviértelo a la lista por capa que espera este patrón con una sola expresión:

selected = [
    torch.from_numpy(routed_experts[:, layer, :].copy()).long()
    for layer in range(routed_experts.shape[1])
]
with replay_moe_routing(model, selected):
    loss = model(input_ids=input_ids, labels=labels).loss

La misma receta se aplica a otras familias de MoE: subclasea la clase *TopKRouter de la familia, ajusta el contrato de retorno original (típicamente (router_logits, router_scores, router_indices)) y registra el parche. Consulta la clase de router de cada modelo para conocer la firma exacta.

Referencia de la API

transformers.monkey_patching.register_patch_mapping

< source >

( mapping: dictoverwrite: bool = False )

Parámetros

mapping (Dict[str, type[nn.Module]]) — Mapeo de nombres de clases originales (o patrones de expresiones regulares) a clases de reemplazo. Admite:
- Nombres exactos de las clases: "Qwen2MoeExperts" → CustomExperts
- Patrones de expresiones regulares: ".*Attention" coincide con LlamaAttention, MistralAttention, etc., o "^Llama\d+Attention$" coincide con Llama2Attention, Llama3Attention, etc.
Las coincidencias exactas tienen prioridad sobre los patrones. Los patrones se comparan mediante re.search(), por lo que pueden coincidir en cualquier parte del nombre de la clase, a menos que se usen anclas (^ para el inicio, $ para el final).
overwrite (bool, opcional, valor predeterminado False) — Indica si se deben sobrescribir los mapeos existentes para los nombres de clases que ya están registrados.

Registre los mapeos de parches para habilitar el parcheo automático durante la creación del modelo mediante from_pretrained, from_config o dentro del administrador de contexto apply_patches.

Utilice esto para registrar reemplazos de clases que se aplicarán automáticamente al cargar cualquier modelo. Esto es útil para la compatibilidad con bibliotecas de cuantización, optimizaciones estructurales y experimentación arquitectónica. El mapeo es global, puede crecer con múltiples llamadas y puede limpiarse por completo.

Ejemplo:

from transformers import AutoModelForCausalLM
from transformers.monkey_patching import register_patch_mapping

# Define custom expert implementation
class SequentialExperts(nn.Module):
    ...

# Register exact class name
register_patch_mapping(
    mapping={"Qwen2MoeExperts": SequentialExperts}
)

# Register with regex pattern to match multiple classes
register_patch_mapping(
    mapping={".*Attention": CustomAttention}  # Matches LlamaAttention, MistralAttention, etc.
)

# Match specific model versions
register_patch_mapping(
    mapping={"^Llama\d+Attention$": CustomLlamaAttention}  # Matches Llama2Attention, Llama3Attention
)

# The patch will be automatically applied during loading
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")

Nota: Para las conversiones de pesos, usa ~transformers.register_checkpoint_conversion_mapping en su lugar.

transformers.monkey_patching.unregister_patch_mapping

< source >

( keys: list )

Parámetros

keys (List[str]) — Lista de claves de mapeo (nombres de clase o patrones regex) que se eliminarán del mapeo de parches (p. ej., ["Qwen2MoeExperts"] o [".*Attention"]).

Desregistre los mapeos de parches para deshabilitar el parcheo automático.

Esto elimina los mapeos especificados del registro global, impidiendo que se apliquen durante la carga del modelo. Debe proporcionar el mismo nombre o patrón exacto que se utilizó durante el registro.

Ejemplo:

from transformers import AutoModelForCausalLM
from transformers.monkey_patching import register_patch_mapping, unregister_patch_mapping

# Register a patch
register_patch_mapping(
    mapping={"Qwen2MoeExperts": CustomExperts}
)

# Unregister the patch
unregister_patch_mapping(["Qwen2MoeExperts"])

# The patch will no longer be applied during loading
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen1.5-MoE-A2.7B")

transformers.monkey_patching.clear_patch_mapping

< source >

( )

Borrar todos los mapeos de parche registrados.

Esto elimina todos los mapeos registrados del registro global.

Ejemplo:

from transformers.monkey_patching import register_patch_mapping, clear_patch_mapping

# Register some patches
register_patch_mapping(
    mapping={"Qwen2MoeExperts": CustomExperts}
)

# Clear all patches
clear_patch_mapping()

transformers.monkey_patching.get_patch_mapping

< source >

( ) → Dict[str, type[nn.Module]]

Devuelve

Dict[str, type[nn.Module]]

Diccionario que mapea nombres de clases o patrones a clases de reemplazo.

Obtenga todos los mapeos de parche registrados.

transformers.monkey_patching.apply_patches

< source >

( )

Gestor de contexto para aplicar los parches de mono registrados dentro de un bloque de código.

Esto reemplaza temporalmente las clases originales por sus sustitutos registrados durante la ejecución del bloque y restaura las clases originales después.

Ejemplo:

from transformers import Qwen2MoeModel, Qwen2MoeConfig
from transformers.monkey_patching import register_patch_mapping, apply_patches

# Register a patch
register_patch_mapping(
    mapping={"Qwen2MoeExperts": CustomExperts}
)

# Apply patches within the context
with apply_patches():
    # The model will use CustomExperts instead of Qwen2MoeExperts
    model = Qwen2MoeModel(Qwen2MoeConfig())

# Outside the context, original classes are restored
# The model will use Qwen2MoeExperts again
model = Qwen2MoeModel(Qwen2MoeConfig())

Update on GitHub