Monkey patching (fonctionnalité expérimentale)

Le monkey patching permet de remplacer des composants du modèle de manière globale sans modifier le code du modèle d’origine. Une fois enregistrés, les correctifs sont appliqués automatiquement lors du chargement de n’importe quel modèle via from_pretrained() ou ~PreTrainedModel.from_config. Cela vous permet de restructurer les modèles pour répondre à des exigences spécifiques, telles que la compatibilité avec la quantification, d’appliquer des optimisations ou d’expérimenter avec des variantes architecturales.

Le monkey patching doit être utilisé en dernier recours lorsque vous devez modifier la disposition et la structure d'un module et/ou de ses poids. Pour de nombreux besoins de personnalisation et d'optimisation, essayez plutôt d'utiliser l'interface Attention, l'interface Experts ou le registre Kernels. N'utilisez le monkey patching que lorsque des modifications structurelles sont nécessaires et ne peuvent pas être obtenues par de simples implémentations personnalisées de forward (par exemple, pour la compatibilité avec une bibliothèque de quantification, la fusion de couches ou des expérimentations architecturales).

Démarrage rapide

Voici un exemple simple montrant comment remplacer un composant de modèle :

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

Fonctionnement

Les correctifs de singe fonctionnent selon un processus en deux étapes :

Inscription : appelez register_patch_mapping pour ajouter des correspondances à un registre global.
Application : les correctifs sont appliqués automatiquement lors de l'initialisation du modèle :
- from_pretrained / from_config : les correctifs sont appliqués automatiquement via un gestionnaire de contexte interne. Aucune action supplémentaire n'est requise !
- Construction manuelle (par exemple, Model(config)) : vous devez utiliser manuellement le gestionnaire de contexte apply_patches.

Une fois les correctifs enregistrés, ils persistent et affectent tous les chargements de modèles ultérieurs jusqu’à ce que vous les effaciez à l’aide de clear_patch_mapping.

Limitations importantes :

Seules les classes des modules de modélisation de transformers peuvent être modifiées (par exemple, LlamaAttention, LlamaMLP).
Les clés de correspondance peuvent être des noms de classes exacts ou des motifs d'expressions régulières (voir Correspondance de motifs ci-dessous).

Enregistrement global

Utilisez register_patch_mapping pour enregistrer les correspondances de manière globale :

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

Correspondance de motifs

Vous pouvez utiliser des expressions régulières pour correspondre à plusieurs classes avec un seul motif :

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

Important : les correspondances exactes ont la priorité sur les motifs. Si vous enregistrez à la fois "LlamaAttention" et ".*Attention", les classes nommées LlamaAttention utiliseront le remplacement par correspondance exacte, tandis que les autres classes correspondantes utiliseront le remplacement par correspondance de motif.

Les motifs d'expressions régulières peuvent casser silencieusement les modèles. Un motif large comme ".*Attention" correspondra à toutes les classes dont le nom contient « Attention » — y compris les classes conteneurs qui enveloppent l'attention que vous souhaitez réellement remplacer. Par exemple, BERT possède trois classes liées à l'attention : BertSelfAttention et BertCrossAttention (les implémentations internes de l'attention) et BertAttention (un module externe qui contient l'une de ces classes internes). Appliquer un correctif aux trois avec la même couche d'attention personnalisée produit un modèle cassé, car le module externe BertAttention n'enveloppe plus l'interne — il est lui-même une de ces classes, ce qui supprime des sous-modules attendus comme self et output. Privilégiez des motifs restreints (par ex. ".*SelfAttention$") ou des noms de classes exacts pour éviter les correspondances non intentionnelles.

Pour désenregistrer des correctifs, utilisez 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"])

Pour effacer tous les correctifs enregistrés, utilisez clear_patch_mapping :

from transformers.monkey_patching import clear_patch_mapping

clear_patch_mapping()

Pour afficher les patches actuellement enregistrés, utilisez get_patch_mapping :

from transformers.monkey_patching import get_patch_mapping

current_patches = get_patch_mapping()
print(current_patches)

Construction manuelle du modèle

Le gestionnaire de contexte apply_patches n’est nécessaire que lorsque vous construisez des modèles manuellement (par exemple, Model(config)) sans utiliser from_pretrained ou 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

Notes importantes

Gestion des poids : le monkey patching ne remplace que les classes, pas les poids. Si la classe patchée possède une disposition des poids différente, vous devrez gérer les conversions de poids séparément pour garantir la compatibilité avec les poids pré-entraînés. Consultez l'exemple complet ci-dessous pour voir comment combiner les monkey patches avec les mappings de conversion de poids.
Effet global : Les correctifs enregistrés via register_patch_mapping sont appliqués globalement à tous les modèles chargés après l'enregistrement. Utilisez toujours clear_patch_mapping pour effectuer le nettoyage une fois terminé, en particulier dans les tests, les notebooks ou les applications à longue durée.
Validation des classes : l’API valide automatiquement que les classes de remplacement sont des sous-classes de nn.Module. Si vous transmettez une classe invalide, un message d’erreur clair s’affiche.
Sécurité des threads : toutes les opérations de patch sont sûres pour les threads. Vous pouvez enregistrer, désenregistrer et appliquer des patches en toute sécurité depuis plusieurs threads.
Comportement de correspondance : lors de l'utilisation de noms de classes exacts, ceux-ci doivent correspondre exactement aux noms de classes d'origine tels qu'ils apparaissent dans le code source du modèle (sensible à la casse). Lors de l'utilisation de motifs regex, ils sont comparés aux noms de classes à l'aide de re.search().

Dépannage

Mon correctif n’est pas appliqué

Vérifier le nom de classe ou le motif : Assurez-vous que le nom de classe ou le motif dans votre correspondance est correct :

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

Vérifier l'enregistrement : utilisez get_patch_mapping pour confirmer que votre correspondance est enregistrée :

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

Vérifier la source du modèle : trouvez le nom exact de la classe dans la source du modèle :

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

Comment savoir si mon correctif fonctionne ?

Inspectez le modèle chargé pour vérifier le correctif :

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

Erreurs de non-correspondance de la forme des poids

Si votre classe modifiée possède des formes de poids différentes, enregistrez une conversion de poids :

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

Nettoyage des correctifs

Pensez toujours à nettoyer les correctifs une fois terminé afin d'éviter d'affecter d'autres parties du code :

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

Exemple complet

Voici un exemple complet montrant comment restructurer à la fois les modules d’experts et d’attention dans un modèle Mixture-of-Experts (qwen2_moe) pour assurer la compatibilité avec l’optimisation et la quantification. Cela illustre :

Création de classes de remplacement personnalisées qui maintiennent la même interface
Enregistrement de correctifs de singe pour plusieurs composants
Gestion des conversions de poids pour la nouvelle structure

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

Enregistrement et rejouage du routage des experts MoE

Les flux de travail d’entraînement Mixture-of-Experts tels que le RLHF nécessitent d’enregistrer les experts vers lesquels chaque jeton a été routé pendant la génération, puis de rejouer ce routage exact lors d’un passage avant d’entraînement distinct. Vous pouvez construire ce processus de bout en bout à l’aide des mécanismes existants de monkey patching et de capture des sorties — aucune modification des fichiers de modélisation n’est requise.

Le motif comporte trois éléments :

Une sous-classe de routeur rejouable pouvant éventuellement lire des indices d'experts forcés depuis un attribut d'instance.
Un context manager qui définit ces attributs sur chaque routeur avant un passage avant, puis les efface ensuite.
Une entrée dans le registre de capture de sortie du modèle, de sorte que output_<name>=True expose les indices via le chemin standard @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 conserve les indices d’experts exacts et recalcule les scores de routage avec les poids du routeur actuels, de sorte que les gradients traversent les paramètres en cours d’exécution tandis que la sélection des experts reste fixe. Il s’agit du contrat minimal de replay utilisé par l’entraînement MoE de type Megatron.

Interopérabilité avec vLLM

La fonctionnalité enable_return_routed_experts=True de vLLM remplit CompletionOutput.routed_experts avec un tableau (seq_len, num_layers, top_k) de type np.int32. Convertissez-le en liste par couche, comme l’attend ce motif, avec une seule expression :

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 même recette s’applique aux autres familles MoE — sous-classez le *TopKRouter de la famille, respectez le contrat de retour d’origine (généralement (router_logits, router_scores, router_indices)) et enregistrez le correctif. Consultez la classe de routeur de chaque modèle pour obtenir la signature exacte.

Référence de l'API

transformers.monkey_patching.register_patch_mapping

< source >

( mapping: dictoverwrite: bool = False )

Paramètres

mapping (Dict[str, type[nn.Module]]) — Correspondance entre les noms de classes d'origine (ou les motifs regex) et les classes de remplacement. Prend en charge :
- Noms de classes exacts : "Qwen2MoeExperts" → CustomExperts
- Motifs d'expressions régulières : ".*Attention" correspond à LlamaAttention, MistralAttention, etc., ou "^Llama\d+Attention$" correspond à Llama2Attention, Llama3Attention, etc.
Les correspondances exactes ont la priorité sur les motifs. Les motifs sont appariés à l'aide de re.search(), ils peuvent donc correspondre n'importe où dans le nom de la classe, à moins d'utiliser des ancrages (^ pour le début, $ pour la fin).
overwrite (bool, facultatif, valeur par défaut False) — Indique s'il faut écraser les correspondances existantes pour les noms de classes déjà enregistrés.

Enregistrez les correspondances de correctifs pour activer le correctif automatique lors de la création du modèle à l'aide de from_pretrained, from_config ou dans le gestionnaire de contexte apply_patches.

Utilisez cette fonction pour enregistrer des substitutions de classes qui seront appliquées automatiquement lors du chargement de n'importe quel modèle. Cela est utile pour la compatibilité avec les bibliothèques de quantification, les optimisations structurelles et les expérimentations architecturales. Le mappage est global, peut s'étendre avec plusieurs appels et peut être entièrement effacé.

Exemple :

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

Note : Pour les conversions de poids, utilisez ~transformers.register_checkpoint_conversion_mapping à la place.

transformers.monkey_patching.unregister_patch_mapping

< source >

( keys: list )

Paramètres

keys (List[str]) — Liste des clés de correspondance (noms de classes ou motifs regex) à supprimer de la correspondance de patch (par ex. ["Qwen2MoeExperts"] ou [".*Attention"]).

Désenregistrer les correspondances de patch pour désactiver le patchage automatique.

Cette opération supprime les correspondances spécifiées du registre global, empêchant ainsi leur application lors du chargement du modèle. Vous devez fournir exactement le même nom ou le même motif qui a été utilisé lors de l'enregistrement.

Exemple :

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 >

( )

Effacer toutes les correspondances de patch enregistrées.

Cette opération supprime toutes les correspondances enregistrées du registre global.

Exemple :

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

Retourne

Dict[str, type[nn.Module]]

Dictionnaire associant des noms de classes ou des motifs aux classes de remplacement.

Obtenir toutes les correspondances de patch enregistrées.

transformers.monkey_patching.apply_patches

< source >

( )

Gestionnaire de contexte pour appliquer les correctifs de singe enregistrés dans un bloc de code.

Ceci remplace temporairement les classes d'origine par leurs substituts enregistrés pendant l'exécution du bloc, puis restaure les classes d'origine par la suite.

Exemple :

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