Monkey patching (fitur eksperimental)

Monkey patching memungkinkan Anda mengganti komponen model secara global tanpa memodifikasi kode model asli. Setelah didaftarkan, patch akan diterapkan secara otomatis saat memuat model apa pun dengan from_pretrained() atau ~PreTrainedModel.from_config. Hal ini memungkinkan Anda untuk menstruktur ulang model untuk kebutuhan spesifik seperti kompatibilitas kuantisasi, menerapkan optimasi, atau bereksperimen dengan varian arsitektur.

Monkey patching sebaiknya digunakan sebagai upaya terakhir ketika Anda perlu mengubah tata letak dan struktur sebuah modul dan/atau bobotnya. Untuk banyak kebutuhan kustomisasi dan optimasi, cobalah menggunakan Attention interface, Experts interface, atau Kernels registry sebagai gantinya. Gunakan monkey patching hanya ketika Anda memerlukan perubahan struktural yang tidak dapat dicapai hanya melalui implementasi forward kustom (misalnya, untuk kompatibilitas library kuantisasi, fusing layer, atau eksperimen arsitektural).

Mulai cepat

Berikut adalah contoh sederhana yang menunjukkan cara mengganti komponen model:

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

Cara kerjanya

Monkey patch bekerja melalui proses dua langkah:

Pendaftaran: Panggil register_patch_mapping untuk menambahkan pemetaan ke registri global.
Aplikasi: Patches diterapkan secara otomatis selama inisialisasi model:
- from_pretrained / from_config: Patches diterapkan secara otomatis melalui context manager internal. Tidak perlu tindakan tambahan!
- Konstruksi manual (misalnya, Model(config)): Anda harus menggunakan context manager apply_patches secara manual.

Setelah patch didaftarkan, patch tersebut akan tetap ada dan memengaruhi semua pemuatan model berikutnya hingga Anda membersihkannya dengan clear_patch_mapping.

Batasan penting:

Hanya kelas di dalam modul pemodelan transformers yang diizinkan untuk di-patch (misalnya, LlamaAttention, LlamaMLP).
Kunci pemetaan dapat berupa nama kelas yang persis atau pola ekspresi reguler (lihat Pencocokan pola di bawah).

Pendaftaran global

Gunakan register_patch_mapping untuk mendaftarkan pemetaan secara 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,
)

Pencocokan pola

Anda dapat menggunakan ekspresi reguler untuk mencocokkan beberapa kelas dengan satu pola:

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

Penting: Kesesuaian persis memiliki prioritas lebih tinggi daripada pola. Jika Anda mendaftarkan "LlamaAttention" dan ".*Attention", kelas bernama LlamaAttention akan menggunakan penggantian kesesuaian persis, sementara kelas lain yang cocok akan menggunakan penggantian kesesuaian pola.

Pola regex dapat merusak model secara diam-diam. Pola yang terlalu luas seperti ".*Attention" akan cocok dengan setiap kelas yang namanya mengandung “Attention” — termasuk kelas kontainer yang membungkus perhatian yang sebenarnya ingin Anda ganti. Misalnya, BERT memiliki tiga kelas terkait perhatian: BertSelfAttention dan BertCrossAttention (implementasi perhatian internal) serta BertAttention (modul eksternal yang memuat salah satu kelas internal tersebut). Menambal ketiga kelas ini dengan lapisan perhatian kustom yang sama akan menghasilkan model yang rusak karena BertAttention eksternal tidak lagi membungkus yang internal — ia adalah satu di antaranya, sehingga menghilangkan sub-modul yang diharapkan seperti self dan output. Gunakan pola yang sempit (misalnya, ".*SelfAttention$") atau nama kelas yang persis untuk menghindari kecocokan yang tidak diinginkan.

Untuk mendaftarkan ulang patch, gunakan 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"])

Untuk menghapus semua patch yang terdaftar, gunakan clear_patch_mapping:

from transformers.monkey_patching import clear_patch_mapping

clear_patch_mapping()

Untuk melihat patch yang saat ini terdaftar, gunakan get_patch_mapping:

from transformers.monkey_patching import get_patch_mapping

current_patches = get_patch_mapping()
print(current_patches)

Konstruksi model manual

Context manager apply_patches hanya diperlukan saat Anda membangun model secara manual (misalnya, Model(config)) tanpa menggunakan from_pretrained atau 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

Catatan penting

Penanganan bobot: Monkey patching hanya mengganti kelas, bukan bobot. Jika kelas yang di-patch memiliki tata letak bobot yang berbeda, Anda perlu menangani konversi bobot secara terpisah untuk memastikan kompatibilitas dengan bobot pretrained. Lihat Contoh lengkap di bawah untuk cara menggabungkan monkey patch dengan pemetaan konversi bobot.
Efek global: Patch yang didaftarkan dengan register_patch_mapping diterapkan secara global ke semua model yang dimuat setelah pendaftaran. Selalu gunakan clear_patch_mapping untuk membersihkan saat selesai, terutama dalam pengujian, notebook, atau aplikasi yang berjalan lama.
Validasi kelas: API secara otomatis memvalidasi bahwa kelas pengganti adalah subclass dari nn.Module. Jika Anda meneruskan kelas yang tidak valid, Anda akan menerima pesan kesalahan yang jelas.
Keamanan thread: Semua operasi patching aman terhadap thread. Anda dapat dengan aman mendaftarkan, mendaftarkan ulang, dan menerapkan patch dari beberapa thread.
Perilaku pencocokan: Saat menggunakan nama kelas yang persis, nama tersebut harus sama persis dengan nama kelas asli sebagaimana muncul dalam kode sumber model (peka huruf besar/kecil). Saat menggunakan pola regex, pola tersebut dicocokkan terhadap nama kelas menggunakan re.search().

Pemecahan Masalah

Patch saya tidak diterapkan

Periksa nama kelas atau pola: Pastikan nama kelas atau pola dalam pemetaan Anda benar:

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

Verifikasi pendaftaran: Gunakan get_patch_mapping untuk memastikan pemetaan Anda terdaftar:

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

Periksa sumber model: Temukan nama kelas yang tepat di sumber model:

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

Bagaimana saya bisa mengetahui apakah patch saya berfungsi?

Periksa model yang dimuat untuk memverifikasi patch:

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

Kesalahan ketidakcocokan bentuk bobot

Jika kelas yang telah Anda tambal memiliki bentuk bobot yang berbeda, daftarkan konversi bobot:

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

Membersihkan patch

Selalu bersihkan patch setelah selesai untuk menghindari dampak pada kode lain:

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

Contoh lengkap

Berikut adalah contoh komprehensif yang menunjukkan cara merestrukturisasi modul experts dan attention dalam model Mixture-of-Experts (qwen2_moe) untuk kompatibilitas optimasi dan kuantisasi. Hal ini mendemonstrasikan:

Membuat kelas pengganti kustom yang mempertahankan antarmuka yang sama
Mendaftarkan monkey patch untuk beberapa komponen
Menangani konversi bobot untuk struktur baru

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

Merekam dan memutar ulang perutean pakar MoE

Alur kerja pelatihan Mixture-of-Experts seperti RLHF perlu merekam ke expert mana setiap token diarahkan selama proses generasi, lalu memutar ulang routing yang persis sama tersebut pada forward pass pelatihan yang terpisah. Anda dapat membangun ini secara end-to-end menggunakan mekanisme monkey patching dan penangkapan output yang sudah ada — tanpa perlu mengubah file modeling.

Pola ini memiliki tiga bagian:

Subkelas router yang dapat diputar ulang (replayable router subclass) yang secara opsional dapat membaca indeks paksa dari atribut instance.
context manager yang mengatur atribut-atribut tersebut di setiap router sebelum forward pass dan membersihkannya setelahnya.
Entri dalam registry penangkapan output model sehingga output_<name>=True mengekspos indeks melalui jalur standar @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 mempertahankan indeks pakar yang persis dan menghitung ulang skor routing dengan bobot router saat ini, sehingga gradien mengalir melalui parameter yang aktif sementara pemilihan pakar tetap tetap. Ini adalah kontrak replay minimal yang digunakan oleh pelatihan MoE bergaya Megatron.

Interoperabilitas dengan vLLM

vLLM dengan enable_return_routed_experts=True mengisi CompletionOutput.routed_experts sebagai array (seq_len, num_layers, top_k) bertipe np.int32. Konversikan menjadi daftar per-layer yang diharapkan oleh pola ini dengan satu ekspresi:

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

Resep yang sama berlaku untuk keluarga MoE lainnya — turunkan *TopKRouter dari keluarga tersebut, sesuaikan kontrak pengembalian aslinya (biasanya (router_logits, router_scores, router_indices)), dan daftarkan patch-nya. Lihat kelas router masing-masing model untuk tanda tangan yang tepat.

Referensi API

transformers.monkey_patching.register_patch_mapping

< source >

( mapping: dict[str, type[torch.nn.Module]]overwrite: bool = False )

Parameter

mapping (Dict[str, type[nn.Module]]) — Pemetaan dari nama kelas asli (atau pola regex) ke kelas pengganti. Mendukung:
- Nama kelas yang tepat: "Qwen2MoeExperts" → CustomExperts
- Pola Regex: ".*Attention" cocok dengan LlamaAttention, MistralAttention, dan sebagainya, atau "^Llama\d+Attention$" cocok dengan Llama2Attention, Llama3Attention, dan sebagainya.
Pencocokan persis memiliki prioritas lebih tinggi daripada pola. Pola dicocokkan menggunakan re.search(), sehingga dapat cocok di mana saja dalam nama kelas kecuali Anda menggunakan jangkar (^ untuk awal, $ untuk akhir).
overwrite (bool, opsional, default False) — Apakah akan menimpa pemetaan yang sudah ada untuk nama kelas yang telah terdaftar.

Daftarkan pemetaan patch untuk mengaktifkan patching otomatis saat pembuatan model menggunakan from_pretrained, from_config, atau di dalam context manager apply_patches.

Gunakan ini untuk mendaftarkan penggantian kelas yang akan diterapkan secara otomatis saat memuat model apa pun. Ini berguna untuk kompatibilitas library kuantisasi, optimasi struktural, dan eksperimen arsitektur. Pemetaan bersifat global, dapat bertambah dengan beberapa pemanggilan, dan dapat dihapus sepenuhnya.

Contoh:

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

Catatan: Untuk konversi bobot, gunakan ~transformers.register_checkpoint_conversion_mapping sebagai gantinya.

transformers.monkey_patching.unregister_patch_mapping

< source >

( keys: list[str] )

Parameter

keys (List[str]) — Daftar kunci pemetaan (nama kelas atau pola regex) yang akan dihapus dari pemetaan patch (contohnya, ["Qwen2MoeExperts"] atau [".*Attention"]).

Daftarkan ulang pemetaan patch untuk menonaktifkan patching otomatis.

Hal ini menghapus pemetaan yang ditentukan dari registri global, sehingga mencegah pemetaan tersebut diterapkan saat pemuatan model. Anda harus memberikan nama atau pola yang persis sama dengan yang digunakan saat pendaftaran.

Contoh:

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 >

( )

Hapus semua pemetaan patch yang terdaftar.

Ini menghapus semua pemetaan yang terdaftar dari registri global.

Contoh:

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

Mengembalikan

Dict[str, type[nn.Module]]

Kamus yang memetakan nama kelas atau pola ke kelas pengganti.

Dapatkan semua pemetaan patch yang terdaftar.

transformers.monkey_patching.apply_patches

< source >

( )

Context manager untuk menerapkan monkey patches yang terdaftar di dalam blok kode.

Ini secara sementara mengganti kelas asli dengan pengganti yang terdaftar selama eksekusi blok, dan memulihkan kelas asli setelahnya.

Contoh:

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