# MOSS-Transcribe-Diarize

## Ikhtisar

**MOSS-Transcribe-Diarize 0.9B** adalah model pemahaman audio end-to-end untuk transkripsi multi-pembicara format panjang, diarization pembicara, dan timestamp. Model ini menggabungkan encoder bergaya Whisper, langkah penggabungan frame 4×, projector multi-modal, dan model bahasa Qwen3.

Checkpoint model tersedia di: [itazap/MOSS-Transcribe-Diarize-HF](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF)

Kemampuan utama meliputi:

* **Transkripsi dan diarisasi gabungan** dalam satu kali proses, dengan segmen yang diformat sebagai `[start][S01]text[end]`.
* **Audio berdurasi panjang** melalui chunking Whisper-window di hulu pada processor; model merakit ulang chunk per sampel.
* **Transkripsi yang dapat diprompt** melalui `apply_transcription_request` atau template chat.
* **Dukungan multibahasa** untuk lebih dari 50 bahasa.

Model ini disumbangkan oleh [Ita Zaporozhets](https://huggingface.co/itazap) dari tim Hugging Face. Lihat [model card](https://huggingface.co/itazap/MOSS-Transcribe-Diarize-HF) dan [OpenMOSS repository](https://github.com/OpenMOSS/MOSS-Transcribe-Diarize) untuk detail lebih lanjut.

## Penggunaan

> [!NOTE]
> Sebagian besar contoh di bawah menggunakan `apply_transcription_request`, sebuah fungsi praktis yang membangun chat template untuk Anda. Lihat [Penggunaan lanjutan dengan chat template](#advanced-usage-with-the-chat-template) untuk pemanggilan `apply_chat_template` yang setara.

### Transkripsi dan diarisasi dasar

Setiap giliran pembicara didekode sebagai segmen `[start][S0N]text[end]`. `processor.decode` dapat mengembalikan string hasil dekode mentah, segmen yang telah diurai sebagai daftar dict (`return_format="parsed"`), atau hanya transkripsi yang digabungkan (`return_format="transcription_only"`).

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/podcast_sample.wav"
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, do_sample=False, max_new_tokens=512)
generated_ids = outputs[:, inputs.input_ids.shape[1] :]

decoded = processor.decode(generated_ids, skip_special_tokens=True)
print("RAW OUTPUT:", decoded)

parsed = processor.decode(generated_ids, return_format="parsed")[0]
print("\nPARSED (list of dicts):")
for segment in parsed:
    print(segment)

transcription = processor.decode(generated_ids, return_format="transcription_only")
print("\nTRANSCRIPTION ONLY:", transcription[0])

"""
RAW OUTPUT: ["[0.48][S01] Hey everyone, welcome back to the show.[2.43][2.46][S01] Today, we're talking about the best way to learn a new skill.[5.22][5.43][S01] I'm here with Jordan to dig into it.[7.14][8.40][S02] Thanks for having me.[9.42][9.63][S02] My take is that consistency beats intensity every single time.[12.87][13.14][S01] That makes sense.[13.92][13.92][S01] Even 20 minutes a day adds up over a few months.[16.17][16.32][S02] Exactly, and writing down small wins keeps you motivated along the way.[19.62]"]

PARSED (list of dicts):
{'Start': 0.48, 'End': 2.43, 'Speaker': 1, 'Content': 'Hey everyone, welcome back to the show.'}
{'Start': 2.46, 'End': 5.22, 'Speaker': 1, 'Content': "Today, we're talking about the best way to learn a new skill."}
{'Start': 5.43, 'End': 7.14, 'Speaker': 1, 'Content': "I'm here with Jordan to dig into it."}
{'Start': 8.4, 'End': 9.42, 'Speaker': 2, 'Content': 'Thanks for having me.'}
{'Start': 9.63, 'End': 12.87, 'Speaker': 2, 'Content': 'My take is that consistency beats intensity every single time.'}
{'Start': 13.14, 'End': 13.92, 'Speaker': 1, 'Content': 'That makes sense.'}
{'Start': 13.92, 'End': 16.17, 'Speaker': 1, 'Content': 'Even 20 minutes a day adds up over a few months.'}
{'Start': 16.32, 'End': 19.62, 'Speaker': 2, 'Content': 'Exactly, and writing down small wins keeps you motivated along the way.'}

TRANSCRIPTION ONLY: Hey everyone, welcome back to the show. Today, we're talking about the best way to learn a new skill. I'm here with Jordan to dig into it. Thanks for having me. My take is that consistency beats intensity every single time. That makes sense. Even 20 minutes a day adds up over a few months. Exactly, and writing down small wins keeps you motivated along the way.
"""
```

### Prompt dan hotwords kustom

`apply_transcription_request` menerima `keywords` untuk membiaskan transkripsi ke arah istilah tertentu (misalnya nama diri atau kosakata spesifik domain), yang dirender sebagai `热词列表：`("hotword list") dalam template chat. `prompt` kustom dapat dikirimkan bersamanya untuk konteks tambahan.

Di bawah ini kami mentranskripsi klip audio yang menyebutkan "Yorùbá", membandingkan dengan dan tanpa melewatkan sebagai kata kunci.

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav"

# Without keywords
inputs = processor.apply_transcription_request(audio_url)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITHOUT keywords: {transcription[0]}")

# With keywords
inputs = processor.apply_transcription_request(audio_url, keywords=["Mandarin", "Yorùbá"])
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(f"WITH keywords   : {transcription[0]}")

"""
WITHOUT keywords: Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yoruba, with over 50 million speakers.
WITH keywords   : Let's talk about the most spoken languages in the world. Mandarin Chinese has the most native speakers, followed by Spanish, English, and Hindi. In West Africa, one of the most widely spoken languages is Yorùbá, with over 50 million speakers.
"""
```

### Penggunaan lanjutan dengan template chat

`apply_transcription_request` ekuivalen dengan chat template yang memiliki giliran user hanya berisi audio:

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "url": audio_url},
        ],
    },
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
).to(model.device, dtype=model.dtype)

outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
decoded = processor.decode(
    outputs[:, inputs.input_ids.shape[1] :],
    skip_special_tokens=True,
)
print(decoded)
```

### Inferensi batch

Lewatkan daftar audio, dan secara opsional daftar prompt dan/atau kata kunci yang sesuai, untuk mentranskripsi batch dalam satu panggilan. Atur entri ke `None` untuk melewatinya pada sampel tersebut.

```python
from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
# `from_pretrained` is used here for convenience, the model can also be built from a config directly.
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

audio = [
    "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav",
    "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/languages_sample.wav",
]
keywords = [None, ["Mandarin", "Yorùbá"]]

inputs = processor.apply_transcription_request(audio, keywords=keywords)
inputs = inputs.to(model.device, dtype=model.dtype)
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)
transcription = processor.decode(outputs[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)
```

### Pelatihan

Lewatkan transkripsi target, dalam format output bertanda waktu dan penanda pembicara dari model, ke `apply_transcription_request` dengan `transcription`. `labels` yang dikembalikan digunakan untuk menghitung loss.

```python
from transformers import AutoModelForCausalLM, AutoProcessor

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
model.train()

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
transcription = (
    "[0.00][S01] Welcome to this demonstration of automatic speech recognition and speaker diarization using an "
    "end-to-end transformer model.[7.47]"
)

inputs = processor.apply_transcription_request(audio_url, transcription=transcription)
inputs.to(model.device, dtype=model.dtype)

loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()
```

### Torch compile

Model dapat dikompilasi untuk inferensi/pelatihan yang lebih cepat. `device_map="auto"` membungkus jalur maju dengan hook `accelerate` yang menyebabkan kompilasi ulang berulang, jadi muat model langsung pada satu perangkat saja.

Pada B200, kami mengamati percepatan sekitar 2,1x untuk ukuran batch 4.

```python
import time

import torch

from transformers import AutoProcessor, AutoModelForCausalLM

model_id = "itazap/MOSS-Transcribe-Diarize-HF"

num_warmup = 5
num_runs = 20

# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")

# Prepare static inputs
audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16)

# Benchmark without compile
print("Warming up without compile...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking without torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
no_compile_time = (time.time() - start) / num_runs
print(f"Average time without compile: {no_compile_time:.4f}s")

# Benchmark with compile
print("\nCompiling model...")
model = torch.compile(model)

print("Warming up with compile (includes graph capture)...")
with torch.no_grad():
    for _ in range(num_warmup):
        _ = model(**inputs)

torch.accelerator.synchronize()

print("\nBenchmarking with torch.compile...")
torch.accelerator.synchronize()
start = time.time()
with torch.no_grad():
    for _ in range(num_runs):
        _ = model(**inputs)
torch.accelerator.synchronize()
compile_time = (time.time() - start) / num_runs
print(f"Average time with compile: {compile_time:.4f}s")

speedup = no_compile_time / compile_time
print(f"\nSpeedup: {speedup:.2f}x")
```

Untuk transkripsi autoregresif, `torch.compile` mempercepat langkah maju per token di dalam `generate` dengan menyediakan objek `CompileConfig` alih-alih mengompilasi `model.forward` secara langsung.

```python
import torch
from transformers import AutoProcessor, AutoModelForCausalLM, CompileConfig

model_id = "itazap/MOSS-Transcribe-Diarize-HF"
num_warmup = 3

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to("cuda")

audio_url = "https://huggingface.co/datasets/itazap/audio_samples/resolve/main/intro_sample.wav"
inputs = processor.apply_transcription_request([audio_url] * 4).to(model.device, torch.bfloat16)

compile_config = CompileConfig()

# Warmup
for _ in range(num_warmup):
    _ = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config)

# Apply model
generated_ids = model.generate(
    **inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config
)
transcription = processor.decode(generated_ids[:, inputs.input_ids.shape[1] :], return_format="transcription_only")
print(transcription)
```

## MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]]

#### transformers.MossTranscribeDiarizeConfig[[transformers.MossTranscribeDiarizeConfig]]

```python
transformers.MossTranscribeDiarizeConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 151671, projector_hidden_act: str = 'silu', projector_bias: bool = True, audio_merge_size: int = 4, audio_chunk_size: int = 480000, tie_word_embeddings: bool = True)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.py#L73)

**Parameter:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari audio backbone.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari text backbone.

audio_token_id (`int`, *opsional*, defaultnya `151671`) : Indeks token audio yang digunakan sebagai placeholder untuk audio input.

projector_hidden_act (`str`, *opsional*, defaultnya `silu`) : Fungsi aktivasi yang digunakan oleh proyektor multimodal.

projector_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan bias pada proyektor multimodal.

audio_merge_size (`int`, *opsional*, default 4) : Jumlah frame encoder Whisper berurutan yang digabungkan sebelum projector multi-modal.

audio_chunk_size (`int`, *opsional*, default 480000) : ukuran jendela encoder Whisper dalam sampel audio mentah, digunakan bersama `padding_mask` untuk memulihkan `audio_chunk_mapping`.

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

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari MossTranscribeDiarizeModel. Kelas ini digunakan untuk menginstansiasi model Moss Transcribe Diarize sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF)

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

Contoh:

```python
>>> from transformers import MossTranscribeDiarizeForConditionalGeneration, MossTranscribeDiarizeConfig

>>> # Initializing a MossTranscribeDiarize configuration
>>> configuration = MossTranscribeDiarizeConfig()

>>> # Initializing a model from the configuration
>>> model = MossTranscribeDiarizeForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]]

#### transformers.MossTranscribeDiarizeAudioConfig[[transformers.MossTranscribeDiarizeAudioConfig]]

```python
transformers.MossTranscribeDiarizeAudioConfig(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, num_mel_bins: int = 80, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, activation_function: str = 'gelu', hidden_size: int = 1024, dropout: float | int = 0.0, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_range: float = 0.02, max_source_positions: int = 1500)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/configuration_moss_transcribe_diarize.py#L30)

**Parameter:**

num_mel_bins (`int`, *opsional*, defaultnya `80`) : Jumlah fitur mel yang digunakan per bingkai input. Seharusnya sesuai dengan nilai yang digunakan di kelas `AutoFeatureExtractor`.

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

num_attention_heads (`int`, *opsional*, defaultnya `16`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

intermediate_size (`int`, *opsional*, defaultnya `4096`) : Dimensi dari representasi MLP.

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

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

dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio untuk semua lapisan dropout.

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

activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected.

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

max_source_positions (`int`, *opsional*, default 1500) : Panjang maksimum sekuens fitur log-mel filter-bank yang mungkin digunakan dengan model ini.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari MossTranscribeDiarizeModel. Kelas ini digunakan untuk menginstansiasi model Moss Transcribe Diarize sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Menginstansiasi konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [hf-audio/MOSS-Transcribe-Diarize-HF](https://huggingface.co/hf-audio/MOSS-Transcribe-Diarize-HF)

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

Contoh:

```python
>>> from transformers import MossTranscribeDiarizeAudioConfig, MossTranscribeDiarizeAudioModel

>>> # Initializing a MossTranscribeDiarizeAudioConfig
>>> configuration = MossTranscribeDiarizeAudioConfig()

>>> # Initializing a MossTranscribeDiarizeAudioModel (with random weights)
>>> model = MossTranscribeDiarizeAudioModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]]

#### transformers.MossTranscribeDiarizeAudioModel[[transformers.MossTranscribeDiarizeAudioModel]]

```python
transformers.MossTranscribeDiarizeAudioModel(config: MossTranscribeDiarizeAudioConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L256)

**Parameter:**

config ([MossTranscribeDiarizeAudioConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model audio MOSS-Transcribe-Diarize, yang merupakan encoder Whisper.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeAudioModel.forward]]

```python
forward(input_features, attention_mask = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L295)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, feature_size, sequence_length)`) : Fitur log-mel yang diekstrak dari gelombang suara mentah, satu baris per jendela Whisper 30 detik. Lihat [__call__()](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__).

attention_mask (`torch.Tensor`, *opsional*) : MossTranscribeDiarize tidak mendukung masking pada `input_features`, argumen ini dipertahankan untuk kompatibilitas, tetapi tidak digunakan.

**Mengembalikan:** [BaseModelOutputWithPooling](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) dan input.

Metode forward dari [MossTranscribeDiarizeAudioModel](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeAudioModel) 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.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **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.

## MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]]

#### transformers.MossTranscribeDiarizeFeatureExtractor[[transformers.MossTranscribeDiarizeFeatureExtractor]]

```python
transformers.MossTranscribeDiarizeFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, chunk_length = 30, n_fft = 400, padding_value = 0.0, dither = 0.0, return_attention_mask = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L35)

Membangun feature extractor MOSS-Transcribe-Diarize.

Ini adalah [WhisperFeatureExtractor](/docs/transformers/main/id/model_doc/whisper#transformers.WhisperFeatureExtractor) yang juga memisahkan audio lebih panjang dari `chunk_length` detik menjadi chunk jendela Whisper yang berurutan sebelum mengekstrak fitur log-mel, dan melaporkan panjang audio mentah asli setiap sampel melalui `padding_mask` (sebaliknya dari `input_features_mask`, yang menandai frame valid per chunk).

#### __call__[[transformers.MossTranscribeDiarizeFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, device: str | None = 'cpu', **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/feature_extraction_moss_transcribe_diarize.py#L170)

**Parameter:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Urutan atau batch dari urutan yang akan diproses. Hanya audio mono-channel.

truncation (`bool`, *opsional*, defaultnya `True`) : Mengaktifkan pemotongan untuk memotong setiap chunk sepanjang `n_samples` menjadi `n_samples`.

pad_to_multiple_of (`int`, *opsional*) : Jika diatur, akan mengisi audio mentah setiap chunk hingga menjadi kelipatan dari nilai ini.

device (`str`, *opsional*, defaultnya `"cpu"`) : Perangkat yang digunakan untuk menghitung log-mel spectrogram.

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature)

dengan `input_features` (fitur log-mel, satu baris per chunk), `input_features_mask` (mask frame valid per chunk), dan `padding_mask` (mask sampel mentah valid, satu baris per sampel input).

Memecah setiap sampel audio menjadi potongan-potongan berurutan sepanjang `n_samples`, mengekstrak fitur log-mel per potongan, dan melaporkan panjang audio mentah asli setiap sampel melalui `padding_mask`.

## MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]]

#### transformers.MossTranscribeDiarizeProcessor[[transformers.MossTranscribeDiarizeProcessor]]

```python
transformers.MossTranscribeDiarizeProcessor(feature_extractor = None, tokenizer = None, chat_template: str | None = None, audio_token: str = '<|audio_pad|>', audio_bos_token: str = '<|audio_start|>', audio_eos_token: str = '<|audio_end|>', audio_tokens_per_second: float = 12.5, audio_merge_size: int = 4, time_marker_every_seconds: int = 2)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L43)

**Parameter:**

feature_extractor (`MossTranscribeDiarizeFeatureExtractor`) : Ekstraktor fitur adalah input yang wajib.

tokenizer (`Qwen2Tokenizer`) : Tokenizer adalah input yang wajib.

chat_template (`str`, *opsional*) : Template Jinja untuk mengonversi daftar pesan dalam chat menjadi string yang dapat ditokenisasi.

audio_token (`str`, *opsional*, defaultnya `"<|audio_pad|>"`) : Token khusus yang digunakan untuk merepresentasikan input audio dalam template chat.

audio_bos_token (`str`, *opsional*, defaultnya `"<|audio_start|>"`) : Token khusus yang menandai awal rentang audio dalam template chat.

audio_eos_token (`str`, *opsional*, defaultnya `"<|audio_end|>"`) : Token khusus yang menandai akhir rentang audio dalam template chat.

audio_tokens_per_second (`float`, *opsional*, default 12.5) : Jumlah token placeholder audio yang diharapkan per detik audio input.

audio_merge_size (`int`, *opsional*, default 4) : Faktor penggabungan frame Whisper yang digunakan saat menghitung token audio.

time_marker_every_seconds (`int`, *opsional*, default 2) : Sisipkan token penanda waktu numerik ke dalam rentang audio setiap N detik. Atur ke `0` untuk menonaktifkan penanda waktu dan mengeluarkan rentang placeholder audio polos sebagai gantinya.

Membangun MossTranscribeDiarizeProcessor yang membungkus feature extractor dan tokenizer menjadi satu processor.

[MossTranscribeDiarizeProcessor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) menyediakan semua fungsionalitas dari [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) dan [Qwen2Tokenizer](/docs/transformers/main/id/model_doc/qwen2#transformers.Qwen2Tokenizer). Lihat [~MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) dan [~Qwen2Tokenizer](/docs/transformers/main/id/model_doc/qwen2#transformers.Qwen2Tokenizer) untuk informasi lebih lanjut.

#### __call__[[transformers.MossTranscribeDiarizeProcessor.__call__]]

```python
__call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.models.moss_transcribe_diarize.processing_moss_transcribe_diarize.MossTranscribeDiarizeProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L104)

**Parameter:**

text (`Union[str, list[str]]`) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string pretokenized). Jika Anda memasukkan input pretokenized, setel `is_split_into_words=True` untuk menghindari ambiguitas dengan input batched.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opsional*) : Audio atau batch audio yang akan disiapkan. Setiap audio dapat berupa array NumPy atau tensor PyTorch. Jika berupa array NumPy/tensor PyTorch, setiap audio harus memiliki bentuk (C, T), di mana C adalah jumlah channel, dan T adalah panjang sampel audio.

output_labels (`bool`, *opsional*, default=False) : Apakah akan mengembalikan label untuk pelatihan.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** [BatchFeature](/docs/transformers/main/id/main_classes/feature_extractor#transformers.BatchFeature)

Kamus dengan teks yang ditokenisasi (`input_ids`, `attention_mask`) dan fitur audio (`input_values`, `padding_mask`).

#### apply_chat_template[[transformers.MossTranscribeDiarizeProcessor.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, tools: list[dict] | None = None, documents: list[dict[str, str]] | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, return_assistant_tokens_mask: bool = False, tokenize: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = 'auto', return_dict: bool = False, load_audio_from_video: bool = False, processor_kwargs: dict | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2250)

**Parameter:**

conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`) : Percakapan yang akan diformat.

chat_template (`Optional[str]`, *opsional*) : Template Jinja yang digunakan untuk memformat percakapan. Jika tidak disediakan, template chat tokenizer akan digunakan.

Mirip dengan metode `apply_chat_template` pada tokenizer, metode ini menerapkan template Jinja ke percakapan input untuk mengubahnya menjadi satu string yang dapat ditokenisasi.

Input yang diharapkan berada dalam format berikut, di mana setiap konten pesan adalah daftar yang terdiri dari teks dan secara opsional input gambar atau video. Anda juga dapat menyediakan gambar, video, URL, atau jalur lokal yang akan digunakan untuk membentuk `pixel_values` ketika `return_dict=True`. Jika tidak disediakan, Anda hanya akan mendapatkan teks yang diformat, dan secara opsional teks yang ditokenisasi.

conversation = [ { "role": "user", "content": [ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"}, {"type": "text", "text": "Please describe this image in detail."}, ], }, ]

#### apply_transcription_request[[transformers.MossTranscribeDiarizeProcessor.apply_transcription_request]]

```python
apply_transcription_request(audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], prompt: str | list[str] | None = None, keywords: str | list[str] | list[list[str]] | None = None, transcription: str | list[str] | None = None, tokenize: bool = True, **kwargs: *<class 'transformers.models.moss_transcribe_diarize.processing_moss_transcribe_diarize.MossTranscribeDiarizeProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/processing_moss_transcribe_diarize.py#L213)

**Parameter:**

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Audio yang akan ditranskripsi. String diinterpretasikan sebagai path lokal atau URL dan akan dimuat secara otomatis oleh chat template loader; array NumPy dan tensor PyTorch diteruskan secara langsung.

prompt (`str` atau `list[str]`, *opsional*) : Prompt kustom untuk disertakan dalam giliran pengguna. Daftar harus memiliki panjang yang sama dengan batch. Ketika `None`, template chat menyediakan prompt diarization berstempel waktu secara default.

keywords (`str`, `list[str]`, atau `list[list[str]]`, *opsional*) : Hotwords/istilah domain (misalnya nama diri) untuk memihak transkripsi ke ejaan yang benar. String atau daftar string datar dibagikan di seluruh batch; daftar bersarang menyediakan kata kunci terpisah untuk setiap sampel audio.

transcription (`str` atau `list[str]`, *opsional*) : Transkrip target untuk pelatihan, satu per audio, dalam format keluaran model (mis. `"[0.00][S01] Hello world.[1.20]"`). Jika diberikan, setiap transkrip ditulis sebagai giliran asisten dan `labels` dikembalikan (lihat `output_labels` di [__call__()](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor.__call__)).

tokenize (`bool`, *opsional*, defaultnya `True`) : Apakah akan melakukan tokenisasi pada prompt dan memproses audio. Jika `False`, audio tidak dimuat dan prompt dikembalikan sebagai string dengan placeholder audio yang belum diperluas. Mengalirkannya bersama audio ke processor, `processor(text=prompts, audio=audio)`, menghasilkan output yang sama dengan `tokenize=True`.

- ****kwargs** : Argumen kata kunci tambahan yang diteruskan ke [apply_chat_template()](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). Argumen processor (misalnya `text_kwargs`, `audio_kwargs`, ...) harus diteruskan sebagai `processor_kwargs={...}`.

Siapkan input untuk transkripsi / diarization tanpa menulis template chat secara manual, baik untuk inferensi maupun, ketika `transcription` diberikan, untuk pelatihan.

## MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]]

#### transformers.MossTranscribeDiarizeModel[[transformers.MossTranscribeDiarizeModel]]

```python
transformers.MossTranscribeDiarizeModel(config: MossTranscribeDiarizeConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L382)

**Parameter:**

config ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model MOSS-Transcribe-Diarize: encoder Whisper, penggabungan waktu 4x, proyektor multi-modal, dan model bahasa Qwen3.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L459)

**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/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Lihat [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) untuk detailnya ([MossTranscribeDiarizeProcessor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.Tensor` dengan bentuk `(num_chunks, feature_sequence_length)`, *opsional*) : Mask yang menandai indeks fitur yang valid (non-padded), satu baris per baris fitur log-mel yang di-chunk dalam `input_features`. Digunakan untuk menghitung panjang output encoder yang valid untuk setiap chunk.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Diteruskan apa adanya ke model bahasa.

inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Embedding yang sudah dihitung sebelumnya, sebagai pengganti `input_ids`. Ketika `input_features` juga diberikan, `input_ids` tetap diperlukan agar posisi placeholder audio dalam `inputs_embeds` dapat ditemukan dan diisi dengan embedding audio.

padding_mask (`torch.Tensor` dengan bentuk `(batch_size, max_audio_length)`, *opsional*) : Mask yang menandai panjang audio mentah yang valid untuk setiap sampel audio. Digunakan bersama `config.audio_chunk_size` untuk memulihkan `audio_chunk_mapping`.

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

A `MossTranscribeDiarizeModelOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) dan input.

Metode forward dari [MossTranscribeDiarizeModel](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeModel) 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.

  Jika `past_key_values` digunakan, hanya hidden-state terakhir dari sekuens dengan bentuk `(batch_size, 1, hidden_size)` yang dioutput.
- **past_key_values** (`Cache`, *opsional*, dikembalikan saat `use_cache=True` dilewatkan atau saat `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/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.
- **audio_hidden_states** (`torch.Tensor`, *opsional*) -- Hidden states audio yang diproyeksikan.

#### get_audio_features[[transformers.MossTranscribeDiarizeModel.get_audio_features]]

```python
get_audio_features(input_features: Tensor, input_features_mask: Tensor, padding_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L394)

**Parameter:**

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Lihat [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) untuk detailnya ([MossTranscribeDiarizeProcessor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.Tensor` dengan bentuk `(num_chunks, feature_sequence_length)`) : Mask yang menandai indeks fitur yang valid (non-padded), satu baris per baris fitur log-mel yang di-chunk dalam `input_features`. Digunakan untuk menghitung panjang output encoder yang valid untuk setiap chunk.

padding_mask (`torch.Tensor` dengan bentuk `(batch_size, max_audio_length)`) : Mask yang menandai panjang audio mentah yang valid untuk setiap sampel audio, satu baris per sampel. Digunakan bersama `config.audio_chunk_size` untuk memulihkan `audio_chunk_mapping`.

**Mengembalikan:** [BaseModelOutputWithPooling](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau `tuple(torch.Tensor)`

[BaseModelOutputWithPooling](/docs/transformers/main/id/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) dan input.

Ekstrak embedding audio MOSS dari fitur log-mel, merakit ulang audio multi-chunk per sampel.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir model.
- **pooler_output** (`torch.Tensor` dengan bentuk `(batch_size, hidden_size)`) -- Hidden-state lapisan terakhir dari token pertama dalam urutan (token klasifikasi) setelah diproses lebih lanjut melalui lapisan yang digunakan untuk tugas pra-pelatihan tambahan. Misalnya, untuk keluarga model BERT, ini mengembalikan token klasifikasi setelah diproses melalui lapisan linear dan fungsi aktivasi tanh. Bobot lapisan linear dilatih dari tujuan prediksi kalimat berikutnya (klasifikasi) selama pra-pelatihan.
- **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.

## MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]]

#### transformers.MossTranscribeDiarizeForConditionalGeneration[[transformers.MossTranscribeDiarizeForConditionalGeneration]]

```python
transformers.MossTranscribeDiarizeForConditionalGeneration(config: MossTranscribeDiarizeConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L522)

**Parameter:**

config ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) : 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/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model MOSS-Transcribe-Diarize untuk generasi kondisional dengan transkripsi dan diarasi pembicara.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/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.MossTranscribeDiarizeForConditionalGeneration.forward]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L535)

**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/main/id/model_doc/auto#transformers.AutoTokenizer). Lihat [PreTrainedTokenizer.encode()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) dan [PreTrainedTokenizer.__call__()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) untuk detailnya. [Apa itu input IDs?](../glossary#input-ids)

input_features (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, feature_dim)`, *opsional*) : Tensor yang sesuai dengan fitur audio input. Fitur audio dapat diperoleh menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor). Lihat [MossTranscribeDiarizeFeatureExtractor.__call__()](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor.__call__) untuk detailnya ([MossTranscribeDiarizeProcessor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeProcessor) menggunakan [MossTranscribeDiarizeFeatureExtractor](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeFeatureExtractor) untuk memproses audio).

input_features_mask (`torch.Tensor` dengan bentuk `(num_chunks, feature_sequence_length)`, *opsional*) : Mask yang menandai indeks fitur yang valid (non-padded), satu baris per baris fitur log-mel yang di-chunk dalam `input_features`. Digunakan untuk menghitung panjang output encoder yang valid untuk setiap chunk.

attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask untuk menghindari pelaksanaan attention pada indeks token padding. Diteruskan apa adanya ke model bahasa.

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/main/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/main/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*) : Embedding yang sudah dihitung sebelumnya, sebagai pengganti `input_ids`. Ketika `input_features` juga diberikan, `input_ids` tetap diperlukan agar posisi placeholder audio dalam `inputs_embeds` dapat ditemukan dan diisi dengan embedding audio.

labels (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Label untuk menghitung kerugian pemodelan bahasa yang disamarkan (masked language modeling loss).

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

padding_mask (`torch.Tensor` dengan bentuk `(batch_size, max_audio_length)`, *opsional*) : Mask yang menandai panjang audio mentah yang valid untuk setiap sampel audio. Digunakan bersama `config.audio_chunk_size` untuk memulihkan `audio_chunk_mapping`.

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

A `MossTranscribeDiarizeCausalLMOutputWithPast` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([MossTranscribeDiarizeConfig](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeConfig)) dan input.

Metode forward dari [MossTranscribeDiarizeForConditionalGeneration](/docs/transformers/main/id/model_doc/moss_transcribe_diarize#transformers.MossTranscribeDiarizeForConditionalGeneration) 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.
- **past_key_values** (`Cache`, *opsional*, dikembalikan ketika `use_cache=True` dilewatkan atau ketika `config.use_cache=True`) -- Ini adalah instance [Cache](/docs/transformers/main/id/internal/generation_utils#transformers.Cache).
- **hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `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.
- **audio_hidden_states** (`torch.Tensor`, *opsional*) -- Hidden states dari audio encoder setelah proyeksi.

Contoh:

```python
>>> from transformers import MossTranscribeDiarizeForConditionalGeneration, AutoProcessor

>>> model_id = "hf-audio/MOSS-Transcribe-Diarize-HF"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = MossTranscribeDiarizeForConditionalGeneration.from_pretrained(model_id, device_map="auto")
>>> inputs = processor.apply_transcription_request("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
>>> inputs = inputs.to(model.device, dtype=model.dtype)
>>> outputs = model.generate(**inputs, do_sample=False, max_new_tokens=500)
>>> processor.batch_decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True)
```

#### get_audio_features[[transformers.MossTranscribeDiarizeForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features, input_features_mask, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moss_transcribe_diarize/modeling_moss_transcribe_diarize.py#L532)