# DeepSeek-V4

[DeepSeek-V4](https://huggingface.co/deepseek-ai) adalah model bahasa MoE generasi berikutnya dari DeepSeek ([paper](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash/blob/main/DeepSeek_V4.pdf)). Arsitekturnya mengganti Multi-head Latent Attention (MLA) dari DeepSeek-V3 dengan desain hybrid lokal + jarak jauh, mengganti koneksi residual dengan Manifold-Constrained Hyper-Connections (mHC), dan mem-bootstrapping beberapa lapisan MoE pertama dengan tabel hash statis token-id → expert-id.

Implementasi ini mencakup `DeepSeek-V4-Flash`, `DeepSeek-V4-Pro`, dan saudara pretrained mereka `-Base`. Keempatnya berbagi arsitektur yang sama; mereka hanya berbeda dalam lebar / kedalaman / jumlah pakar dan bobot.

> [!TIP]
> Setel `use_kernels=True` di [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengganti lapisan yang didukung dengan kernel yang dioptimalkan dari Hub. Lihat [Memuat kernel](../kernel_doc/loading_kernels) untuk mempelajari lebih lanjut.

## Architecture (paper §2)

### Perhatian hibrida (§2.3)

Setiap blok decoder adalah salah satu dari tiga jenis perhatian, yang dikirimkan oleh `config.layer_types[i]`:

* **Perhatian penuh jendela geser** (`"sliding_attention"`): hanya jendela lokal dari `sliding_window` token, tanpa cabang jarak jauh. Cocok dengan gaya "Full Attention" V3 untuk lapisan bootstrap.
* **Compressed Sparse Attention** (`"compressed_sparse_attention"`, **CSA** — paper §2.3.1): pool dengan kompresi rendah (`compress_rate_csa`, default `m=4`) dengan jendela yang tumpang tindih, ditambah **Lightning Indexer** (pers. 13–17) yang menilai query terhadap pool dan mengumpulkan blok top `index_topk` per query sebelum mencapai core attention.
* **Perhatian Terkompresi Tinggi** (`"heavily_compressed_attention"`, **HCA** — paper §2.3.2): pool kompresi tinggi (`compress_rate_hca`, default `m'=128`) dengan jendela yang tidak tumpang tindih. Tidak ada indexer — setiap entri yang di-pool berkontribusi pada perhatian.

Ketiga tipe ini berbagi backbone yang sama:

* **Shared K=V Multi-Query Attention**: `num_key_value_heads = 1`; `kv_proj` menghasilkan satu kepala KV dan tensor yang sama dibaca sebagai kunci dan nilai.
* **Partial RoPE** (interleaved-pair, paper §2.3.3 "Partial Rotary Positional Embedding") pada `qk_rope_head_dim = head_dim * partial_rotary_factor` channel terakhir dari setiap head. Rotasi yang sama diterapkan dengan posisi `-i` pada slice rope dari output attention (eq. 26) sehingga kontribusi dari setiap entri KV tetap menjadi fungsi dari jarak *relatif* ke query.
* **Per-head learnable attention sink** (pers. 27).
* **Proyeksi output ber-rank rendah berkelompok** (§2.3.1 "Grouped Output Projection"): `o_groups` grup kepala → `o_lora_rank` per grup → `hidden_size`, dihitung oleh `DeepseekV4GroupedLinear` (`o_a_proj`) yang diikuti oleh `o_b_proj`. Mengurangi biaya per token dari output perhatian yang lebar tanpa kehilangan ekspresivitas.
* **Cabang K=V sliding-window bersama** berukuran `sliding_window` ("Additional Branch of Sliding Window Attention", §2.3.1) mempertahankan dependensi lokal yang halus; keluaran kompresor jarak jauh digabungkan dengan KV cabang ini sebelum perhatian inti.

### Hyper-Connections dengan Kendala Manifold (§2.2)

Koneksi residual diganti oleh mHC (Xie et al., 2026): `hc_mult` aliran residual paralel yang dipertahankan dalam bentuk `[B, S, hc_mult, D]` di sepanjang setiap blok. Dua modul `DeepseekV4HyperConnection` — `attn_hc` dan `ffn_hc` — mencampur aliran masuk dan keluar di sekitar sublayer attention / MLP melalui triplet `(pre, post, comb)`. Matriks `comb` adalah proyeksi doubly-stochastic yang dihasilkan oleh iterasi Sinkhorn–Knopp `hc_sinkhorn_iters` pada manifold, sehingga membuat propagasi sinyal menjadi non-expansive di seluruh tumpukan yang dalam. `DeepseekV4HyperHead` terakhir meruntuhkan `hc_mult` aliran menjadi satu urutan tunggal sebelum model norm.

### Jadwal MoE (§2.1)

Routing dikonfigurasi per lapisan oleh `config.mlp_layer_types`, dengan nilai dari `{"hash_moe", "moe"}`:

* `"hash_moe"`: indeks expert berasal dari pencarian `tid2eid[input_ids]` yang dibekukan dan diisi dari checkpoint V4. Bobot gerbang yang dipelajari `weight` tetap menghasilkan skor per-expert yang menimbang expert yang dipilih; hanya *expert mana* yang statis. Digunakan untuk beberapa lapisan bootstrap pertama (default 3, dapat ditimpa melalui `num_hash_layers` legacy).
* `"moe"`: MoE top-k routed standar. Afinitas pakar menggunakan **Sqrt(Softplus(·))** alih-alih Sigmoid dari V3 ("kami mengubah fungsi aktivasi yang menghitung skor afinitas dari Sigmoid(·) menjadi Sqrt(Softplus(·))", paper §2.1), dan kendala `n_group` / `topk_group` dari V3 dihapus. Strategi bebas loss tambahan (DeepSeek's `noaux_tc`) dipertahankan melalui buffer `e_score_correction_bias` yang membiasakan argmax top-k tanpa mengalirkan gradien.

Routed experts menggunakan **clamped SwiGLU** (`gate.clamp(max=swiglu_limit)`, `up.clamp(min=-swiglu_limit, max=swiglu_limit)`, kemudian `act_fn(gate) * up`) di atas tata letak bobot expert Mixtral standar `[num_experts, 2 * moe_intermediate_size, hidden_size]`. Satu expert bersama (MLP SwiGLU biasa dengan lebar `moe_intermediate_size`) berjalan paralel pada setiap token.

### Tata letak attention mask

Setiap lapisan `DeepseekV4Attention` memperluas mask sliding-window-causal standar di sepanjang sumbu key dengan `block_bias` yang dikembalikan oleh kompresornya, kemudian memberikan mask yang digabungkan tersebut ke `eager_attention_forward`. Bagian sliding (kiri, `[S, S]`) sama untuk setiap jenis lapisan; bagian kompresor (kanan) berbeda tergantung jenis lapisan dan merupakan bagian "baru" yang sebenarnya diperkenalkan oleh V4.

Diagram di bawah dibuat dengan konfigurasi kecil (`sliding_window=8`, CSA `m=4`, HCA `m'=8`, `index_topk=2`) pada input 16 token agar mask per-jenis-lapisan penuh muat di layar. Hijau = diagonal query/key di bagian sliding, gelap = posisi KV standar yang terlihat, terang = ter-mask, amber = slot kompresor / indexer yang boleh diperhatikan oleh query. Kolom setelah garis putus-putus ditambahkan oleh kompresor melalui `cat([sliding_causal_mask, block_bias], dim=-1)`.

**Lapisan sliding-only (`"sliding_attention"`).** Tidak ada kompresor, tidak ada right-padding — mask-nya adalah mask sliding-window-causal polos dengan bentuk `[S, S]` (window = 8). Untuk `i ≥ window`, segitiga kiri-bawah dipotong, sehingga memulihkan pola perhatian lokal-only.

**Lapisan CSA (`"compressed_sparse_attention"`).** Kompresor meratakan output terkumpul per kuerinya menjadi `[B, 1, S·k, D]` dan mengisi mask di sisi kanan dengan `S·k` kolom. Untuk kueri `t`, hanya `k` slot pada kolom `[S + t·k, S + (t+1)·k)` yang membawa pilihan indexer; semua kolom kompresor lainnya bernilai `-inf`. Kueri sebelum jendela pertama tertutup (`t < m − 1`) tidak mendapatkan apa pun — sentinel `-1` dari indexer langsung diteruskan ke mask. Seiring `t` membesar, lebih banyak entri terkompresi yang siap dan indexer dapat mengisi semua `k` slot.

**Lapisan HCA (`"heavily_compressed_attention"`).** Tidak ada indexer — setiap entri terkompresi yang di-cache berpotensi terlihat. Di-pad ke kanan dengan `T_total = entry_count["compressor"]` kolom. Query `t` hanya dapat melihat entri `w` setelah jendela sumbernya tertutup, yaitu `w < (t + 1) // m`. Dengan `m=8` di sini, entri 0 (menutupi posisi `0..7`) dan 1 (menutupi `8..15`) baru menjadi terlihat pada `t ≥ 7` dan `t ≥ 15` masing-masing.

Diagram-diagram ini dapat direproduksi secara end-to-end melalui:

```bash
python docs/source/en/imgs/deepseek_v4/visualize_attention_masks.py \
    --svg docs/source/en/imgs/deepseek_v4
```

Skrip ini menjalankan forward pass pada konfigurasi kecil ini, membungkus setiap lapisan perhatian untuk menangkap mask persis pasca-`cat([attention_mask, block_bias])`, memetakan ulang mask flat-slot `[S, S·k]` CSA kembali ke tampilan visibilitas entri `[S, T_entries]` (sehingga setiap kolom `C_w` adalah *entri* yang dikompresi, bukan slot gather), dan menulis tiga SVG di atas. Skrip ini juga mencetak grid ANSI ke stdout untuk inspeksi terminal yang cepat dan menumpahkan pilihan top-k per-query dari indexer sehingga sentinel warm-up dan pilihan pick dapat diaudit.

### Lapisan cache

Setiap blok perhatian non-sliding perlu mengalirkan state kompresor / indexer di antara panggilan forward. V4 menyediakan dua tipe lapisan cache yang otomatis terdaftar dengan `LAYER_TYPE_CACHE_MAPPING`:

* `DeepseekV4HCACache`: buffer / pool / count kompresor HCA untuk K=V jendela geser (tanpa tumpang tindih, tanpa indexer).
* `DeepseekV4CSACache`: jendela geser K=V + kompresor CSA (dengan status tumpang tindih) + buffer / pool / hitungan / tumpang tindih indexer paralel pada `index_head_dim`.

`DynamicCache(config=…)` membangun lapisan cache yang tepat untuk setiap `config.layer_types[i]`.

## DeepseekV4Config[[transformers.DeepseekV4Config]]

#### transformers.DeepseekV4Config[[transformers.DeepseekV4Config]]

```python
transformers.DeepseekV4Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 129280, hidden_size: int = 4096, moe_intermediate_size: int = 2048, num_hidden_layers: int = 43, num_attention_heads: int = 64, num_key_value_heads: int = 1, head_dim: int = 512, q_lora_rank: int = 1024, num_experts_per_tok: int = 6, n_routed_experts: int = 256, n_shared_experts: int = 1, scoring_func: str = 'sqrtsoftplus', norm_topk_prob: bool = True, routed_scaling_factor: float = 1.5, max_position_embeddings: int = 1048576, rope_theta: float | int = 10000.0, layer_types: list[str] | None = None, compress_rates: dict | None = None, compress_rope_theta: float | int = 160000.0, hc_mult: int = 4, hc_sinkhorn_iters: int = 20, hc_eps: float = 1e-06, mlp_layer_types: list[str] | None = None, swiglu_limit: float = 10.0, sliding_window: int = 128, o_groups: int = 8, o_lora_rank: int = 1024, index_n_heads: int = 64, index_head_dim: int = 128, index_topk: int = 512, num_nextn_predict_layers: int = 1, output_router_logits: bool = False, router_aux_loss_coef: float = 0.001, router_jitter_noise: float = 0.0, hidden_act: str = 'silu', initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, partial_rotary_factor: float | None = None, attention_bias: bool = False, mlp_bias: bool = False, attention_dropout: float = 0.0)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/configuration_deepseek_v4.py#L40)

**Parameter:**

vocab_size (`int`, *opsional*, defaultnya `129280`) : Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh `input_ids`.

hidden_size (`int`, *opsional*, defaultnya `4096`) : Dimensi dari representasi tersembunyi.

moe_intermediate_size (`int`, *opsional*, defaultnya `2048`) : Ukuran perantara dari MLP pakar yang dirutekan.

num_hidden_layers (`int`, *opsional*, defaultnya `43`) : Jumlah lapisan tersembunyi dalam decoder Transformer.

num_attention_heads (`int`, *opsional*, defaultnya `64`) : Jumlah attention heads untuk setiap lapisan attention dalam decoder Transformer.

num_key_value_heads (`int`, *opsional*, defaultnya `1`) : Ini adalah jumlah key_value heads yang harus digunakan untuk mengimplementasikan Grouped Query Attention. Jika `num_key_value_heads=num_attention_heads`, model akan menggunakan Multi Head Attention (MHA), jika `num_key_value_heads=1` model akan menggunakan Multi Query Attention (MQA), selain itu GQA yang digunakan. Saat mengonversi checkpoint multi-head menjadi checkpoint GQA, setiap group key dan value head harus dibangun dengan meanpooling semua head asli di dalam grup tersebut. Untuk detail lebih lanjut, lihat [paper ini](https://huggingface.co/papers/2305.13245). Jika tidak ditentukan, akan default ke `num_attention_heads`.

head_dim (`int`, *opsional*, defaultnya `512`) : Dimensi kepala perhatian. Jika None, nilainya akan menjadi hidden_size // num_attention_heads

q_lora_rank (`int`, *opsional*, defaultnya `1024`) : Rank dari matriks LoRA untuk proyeksi query.

num_experts_per_tok (`int`, *opsional*, defaultnya `6`) : Jumlah pakar untuk merutekan setiap token. Ini adalah nilai top-k untuk perutekan pilihan token.

n_routed_experts (`int`, *opsional*, defaultnya `256`) : Jumlah pakar yang dirutekan.

n_shared_experts (`int`, *opsional*, defaultnya `1`) : Jumlah pakar bersama.

scoring_func (`str`, *opsional*, defaultnya `sqrtsoftplus`) : Aktivasi router — `sqrtsoftplus`, `softmax`, atau `sigmoid`.

norm_topk_prob (`bool`, *opsional*, defaultnya `True`) : Apakah akan menormalisasi bobot dari para ahli yang dirutekan.

routed_scaling_factor (`float`, *opsional*, defaultnya `1.5`) : Faktor penskalaan atau pakar yang dialihkan.

max_position_embeddings (`int`, *opsional*, defaultnya `1048576`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini.

rope_theta (`Union[float, int]`, *opsional*, defaultnya `10000.0`) : RoPE base untuk rotary self-attention utama.

layer_types (`list[str]`, *opsional*) : Jadwal perhatian per lapisan dengan nilai dari `{"compressed_sparse_attention", "heavily_compressed_attention"}`. Default V4-Pro: 2× HCA bootstrap + CSA / HCA berselang.

compress_rates (`dict[str, int]`) : Rasio kompresi per tipe layer. Default `{"compressed_sparse_attention": 4, "heavily_compressed_attention": 128}` (m=4 untuk CSA, m'=128 untuk HCA, paper §2.3.1 / §2.3.2). BC: konfigurasi yang menyertakan `compress_rate_csa` / `compress_rate_hca` sebagai kwargs tingkat atas akan digabungkan pada saat `__post_init__`.

compress_rope_theta (`Union[float, int]`, *opsional*, defaultnya `160000.0`) : RoPE base untuk cabang yang dikompresi (dipasangkan dengan `rope_scaling` untuk YaRN).

hc_mult (`int`, *opsional*, default `4`) : Faktor ekspansi n_hc untuk Manifold-Constrained Hyper-Connection (mHC) (selalu aktif; Bagian 2.2).

hc_sinkhorn_iters (`int`, *opsional*, default `20`) : Iterasi Sinkhorn-Knopp t_max untuk pemetaan residual mHC yang diproyeksikan ke matriks doubly-stochastic.

hc_eps (`float`, *opsional*, default `1e-06`) : Batas bawah numerik untuk normalisasi Sinkhorn-Knopp.

mlp_layer_types (`list[str]`, *opsional*) : Jadwal MoE per lapisan dengan nilai dari `{"hash_moe", "moe"}`. `hash_moe` melakukan routing melalui pencarian `tid2eid[input_ids]` yang dibekukan (makalah §2.1, "Hash-MoE bootstrap"); `moe` adalah MoE top-k yang di-rutekan secara standar. Default: 3× `hash_moe` lalu `moe` untuk sisanya. BC: konfigurasi legacy yang menyertakan `num_hash_layers` sebagai kwarg tingkat atas digabungkan pada saat `__post_init__`.

swiglu_limit (`float`, *opsional*, defaultnya `10.0`) : Memotong pre-aktivasi gate/up dari pakar yang diarahkan.

sliding_window (`int`, *opsional*, defaultnya `128`) : Ukuran jendela lokal n_win yang digunakan di cabang sliding-window setiap blok perhatian.

o_groups (`int`, *opsional*, default `8`) : Jumlah grup kepala g dalam proyeksi output terkelompok (makalah §2.3.1, "Grouped Output Projection").

o_lora_rank (`int`, *opsional*, default `1024`) : Dimensi perantara per grup d_g dalam proyeksi output bergrup.

index_n_heads (`int`, *opsional*, default `64`) : Jumlah kepala query indexer n_h^I (makalah §2.3.1, eq. 14).

index_head_dim (`int`, *opsional*, default `128`) : Dimensi head indexer c^I (makalah §2.3.1).

index_topk (`int`, *opsional*, default `512`) : Jumlah entri terkompresi per query yang disimpan Lightning Indexer melalui top-k (makalah §2.3.1, eq. 17).

num_nextn_predict_layers (`int`, *opsional*, defaultnya `1`) : jumlah lapisan MTP di checkpoint hulu (tidak diinstansiasi di sini).

output_router_logits (`bool`, *opsional*, defaultnya `False`) : Apakah logits router harus dikembalikan oleh model. Mengaktifkan ini juga akan memungkinkan model untuk mengoutputkan loss tambahan, termasuk load balancing loss dan router z-loss.

router_aux_loss_coef (`float`, *opsional*, default `0.001`) : Koefisien loss penyeimbangan beban bantu. Digunakan untuk menghukum perutean pakar yang tidak merata pada model MoE.

router_jitter_noise (`float`, *opsional*, default `0.0`) : Jumlah noise yang ditambahkan ke router logits selama pelatihan untuk load balancing yang lebih baik.

hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya.

initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

rms_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi rms.

use_cache (`bool`, *opsional*, defaultnya `True`) : Apakah model harus mengembalikan perhatian kunci/nilai terakhir (tidak digunakan oleh semua model). Hanya relevan jika `config.is_decoder=True` atau ketika model adalah model generatif yang hanya decoder.

pad_token_id (`int`, *opsional*) : ID token yang digunakan untuk padding dalam kosakata.

bos_token_id (`int`, *opsional*, defaultnya `0`) : Token id yang digunakan untuk awal-stream dalam kosakata.

eos_token_id (`Union[int, list[int]]`, *opsional*, defaultnya `1`) : Token id yang digunakan untuk end-of-stream dalam kosakata.

tie_word_embeddings (`bool`, *opsional*, defaultnya `False`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opsional*) : Dictionary yang berisi parameter konfigurasi untuk embedding RoPE. Dictionary harus berisi nilai untuk `rope_theta` dan secara opsional parameter yang digunakan untuk scaling jika Anda ingin menggunakan RoPE dengan `max_position_embeddings` yang lebih panjang.

partial_rotary_factor (`float`, *opsional*) : Fraksi dari head_dim yang mendapatkan RoPE. Bawaan adalah `qk_rope_head_dim / head_dim` sehingga ukuran cos/sin menjadi `qk_rope_head_dim`.

attention_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan proyeksi query, key, value, dan output selama self-attention.

mlp_bias (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan bias pada lapisan up_proj, down_proj, dan gate_proj di lapisan MLP.

attention_dropout (`float`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DeepseekV4Model. Kelas ini digunakan untuk membuat instans model Deepseek V4 sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [deepseek-ai/DeepSeek-V4-Flash-Base](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash-Base)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

#### validate_layer_type[[transformers.DeepseekV4Config.validate_layer_type]]

```python
validate_layer_type()
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/configuration_deepseek_v4.py#L214)

V4 mempersempit `ALLOWED_LAYER_TYPES` global menjadi tiga jenis blok perhatian dan dua jenis blok MLP yang benar-benar disertakan, di atas pemeriksaan panjang / keanggotaan tipe standar.

## DeepseekV4Model[[transformers.DeepseekV4Model]]

#### transformers.DeepseekV4Model[[transformers.DeepseekV4Model]]

```python
transformers.DeepseekV4Model(config: DeepseekV4Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/modeling_deepseek_v4.py#L1310)

**Parameter:**

config ([DeepseekV4Config](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Deepseek V4 polos yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.DeepseekV4Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/modeling_deepseek_v4.py#L1328)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

**Mengembalikan:** `MoeModelOutputWithPast` atau `tuple(torch.Tensor)`

A `MoeModelOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DeepseekV4Config](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4Config)) dan input.

Metode forward dari [DeepseekV4Model](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4Model) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention, dan secara opsional jika `config.is_encoder_decoder=True` di blok cross-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.
- **router_logits** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_router_probs=True` dan `config.add_router_probs=True` diteruskan atau ketika `config.output_router_probs=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, sequence_length, num_experts)`.

  Logit router mentah (setelah softmax) yang dihitung oleh router MoE; istilah-istilah ini digunakan untuk menghitung auxiliary loss pada model Mixture of Experts.

## DeepseekV4ForCausalLM[[transformers.DeepseekV4ForCausalLM]]

#### transformers.DeepseekV4ForCausalLM[[transformers.DeepseekV4ForCausalLM]]

```python
transformers.DeepseekV4ForCausalLM(config: DeepseekV4Config)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/modeling_deepseek_v4.py#L1458)

**Parameter:**

config ([DeepseekV4Config](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4Config)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model Deepseek V4 untuk pemodelan bahasa kausal.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### forward[[transformers.DeepseekV4ForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_router_logits: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deepseek_v4/modeling_deepseek_v4.py#L1476)

**Parameter:**

input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks token dari urutan input dalam kosakata. Padding akan diabaikan secara default. Indeks dapat diperoleh menggunakan [AutoTokenizer](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Nilai mask dipilih dalam `[0, 1]`:  - 1 untuk token yang **tidak di-mask**, - 0 untuk token yang **di-mask**.  [Apa itu attention masks?](../glossary#attention-mask)

position_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Indeks posisi token dari setiap urutan input dalam embedding posisi. Dipilih dalam rentang `[0, config.n_positions - 1]`.  [Apa itu position ID?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opsional*) : Hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan untuk mempercepat decoding berurutan. Ini biasanya terdiri dari `past_key_values` yang dikembalikan oleh model pada tahap decoding sebelumnya, ketika `use_cache=True` atau `config.use_cache=True`. Hanya instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache) yang diizinkan sebagai input, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami. Jika tidak ada `past_key_values` yang diteruskan, [DynamicCache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.DynamicCache) akan diinisialisasi secara default. Model akan mengoutput format cache yang sama dengan yang diberikan sebagai input. Jika `past_key_values` digunakan, pengguna diharapkan untuk hanya menginput `input_ids` yang belum diproses (yang tidak memiliki state past key value mereka diberikan ke model ini) dengan bentuk `(batch_size, unprocessed_length)` alih-alih semua `input_ids` dengan bentuk `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan `input_ids`, Anda dapat memilih untuk langsung meneruskan representasi tertanam. Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi indeks `input_ids` menjadi vektor terkait daripada matriks pencarian penanaman internal model.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa kausal. Indeks harus berada dalam `[-100, 0, ..., config.vocab_size]` (lihat docstring `input_ids`). Token dengan indeks yang disetel ke `-100` diabaikan (dimasker), kerugian hanya dihitung untuk token dengan label dalam `[0, ..., config.vocab_size]`. Label akan **digeser secara internal** sehingga `labels[..., 1:]` digunakan untuk memprediksi `logits[..., :-1, :]`. Sampaikan label yang tidak digeser dan sesuai dengan `input_ids` (yaitu `labels = input_ids`). Jangan **geser** label Anda sendiri sebelum menyampaikannya. Jika label sudah digeser (misalnya dengan paralelisme urutan), sampaikan sebagai argumen kata kunci `shift_labels` dan akan digunakan apa adanya. `labels` tetap harus disampaikan agar kerugian dapat dihitung.

use_cache (`bool`, *opsional*) : Jika diatur ke `True`, state kunci-nilai `past_key_values` akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat `past_key_values`).

output_router_logits (`bool`, *opsional*) : Apakah akan mengembalikan logits dari semua router. Hal ini berguna untuk menghitung kerugian router, dan tidak seharusnya dikembalikan selama inferensi.

logits_to_keep (`Union[int, torch.Tensor]`, *opsional*, defaultnya `0`) : Jika berupa `int`, hitung logits untuk `logits_to_keep` token terakhir. Jika `0`, hitung logits untuk semua `input_ids` (kasus khusus). Hanya logits token terakhir yang diperlukan untuk generasi, dan menghitungnya hanya untuk token tersebut dapat menghemat memori, yang menjadi cukup signifikan untuk urutan panjang atau ukuran kosakata besar. Jika berupa `torch.Tensor`, harus 1D yang sesuai dengan indeks yang akan dipertahankan pada dimensi panjang urutan. Ini berguna saat menggunakan format tensor terpadu (satu dimensi untuk batch dan panjang urutan).

**Mengembalikan:** `MoeCausalLMOutputWithPast` atau `tuple(torch.Tensor)`

A `MoeCausalLMOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([DeepseekV4Config](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4Config)) dan input.

Metode forward dari [DeepseekV4ForCausalLM](/docs/transformers/v5.23.0/id/model_doc/deepseek_v4#transformers.DeepseekV4ForCausalLM) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor` dengan bentuk `(1,)`, *opsional*, dikembalikan saat `labels` disediakan) -- Loss pemodelan bahasa (untuk prediksi token berikutnya).
- **logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.vocab_size)`) -- Skor prediksi dari kepala pemodelan bahasa (skor untuk setiap token kosakata sebelum SoftMax).
- **aux_loss** (`torch.Tensor`, *opsional*, dikembalikan ketika `output_router_logits=True` dilewatkan atau ketika `config.output_router_logits=True`, dan model melatih router-nya dengan load-balancing loss) -- Load-balancing auxiliary loss untuk modul sparse. Model yang menyeimbangkan expert-nya dengan router bias (DeepSeek-V3 dan arsitektur yang diturunkan darinya) mengembalikan `None` di sini sambil tetap mengembalikan `router_logits`.
- **router_logits** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_router_logits=True` diteruskan atau ketika `config.output_router_logits=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap lapisan sparse) dengan bentuk `(batch_size * sequence_length, num_experts)`.

  Logit router mentah yang dihitung oleh router MoE. Logit ini dapat digunakan untuk menghitung kerugian penyeimbangan beban (load-balancing loss) atau untuk memeriksa bagaimana token didistribusikan ke para ahli (experts).
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/v5.23.0/id/internal/generation_utils#transformers.Cache). Untuk detail lebih lanjut, lihat [panduan kv cache](https://huggingface.co/docs/transformers/en/kv_cache) kami.

  Berisi hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention) yang dapat digunakan (lihat input `past_key_values`) untuk mempercepat decoding berurutan.
- **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`.

  Hidden-states model pada output setiap layer ditambah output embedding awal yang opsional.
- **attentions** (`tuple(torch.Tensor)`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`.

  Bobot perhatian setelah softmax perhatian, digunakan untuk menghitung rata-rata berbobot di kepala self-attention.

Contoh:

```python
>>> from transformers import AutoTokenizer, DeepseekV4ForCausalLM

>>> model = DeepseekV4ForCausalLM.from_pretrained("mistralai/DeepseekV4-8x7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/DeepseekV4-8x7B-v0.1")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."
```

