Hugging Face's logo

Transformers documentation

Pop2Piano

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Model ini dipublikasikan di HF papers pada 2022-11-02 dan disumbangkan ke Hugging Face Transformers pada 2023-08-21.

Pop2Piano

Ikhtisar

Model Pop2Piano diusulkan dalam Pop2Piano : Pop Audio-based Piano Cover Generation oleh Jongho Choi dan Kyogu Lee.

Piano covers dari musik pop sangat dinikmati, tetapi menghasilkannya dari musik bukanlah tugas yang mudah. Hal ini membutuhkan keahlian tinggi dalam bermain piano serta pemahaman tentang karakteristik dan melodi yang berbeda dari sebuah lagu. Dengan Pop2Piano, Anda dapat langsung menghasilkan cover dari waveform audio lagu. Ini adalah model pertama yang secara langsung menghasilkan piano cover dari audio pop tanpa modul ekstraksi melodi dan akor.

Pop2Piano adalah model Transformer encoder-decoder yang berbasis pada T5. Audio input diubah menjadi bentuk waveform-nya dan diteruskan ke encoder, yang kemudian mengubahnya menjadi representasi laten. Decoder menggunakan representasi laten ini untuk menghasilkan token id secara autoregresif. Setiap token id sesuai dengan salah satu dari empat jenis token yang berbeda: time, velocity, note, dan ‘special’. Token id tersebut kemudian didekode menjadi file MIDI yang setara.

Abstrak dari makalah tersebut adalah sebagai berikut:

Cover piano dari musik pop dinikmati oleh banyak orang. Namun, tugas menghasilkan cover piano dari musik pop secara otomatis masih kurang diteliti. Hal ini sebagian disebabkan oleh kurangnya pasangan data {Pop, Piano Cover} yang tersinkronisasi, yang membuat penerapan metode berbasis deep learning intensif data terbaru menjadi menantang. Untuk memanfaatkan kekuatan pendekatan berbasis data, kami membuat sejumlah besar data {Pop, Piano Cover} yang berpasangan dan tersinkronisasi menggunakan pipeline otomatis. Dalam makalah ini, kami memperkenalkan Pop2Piano, sebuah jaringan Transformer yang menghasilkan cover piano dari waveform musik pop. Sejauh pengetahuan kami, ini adalah model pertama yang menghasilkan cover piano langsung dari audio pop tanpa menggunakan modul ekstraksi melodi dan akor. Kami menunjukkan bahwa Pop2Piano, yang dilatih dengan dataset kami, mampu menghasilkan cover piano yang masuk akal.

Model ini disumbangkan oleh Susnato Dhar. Kode aslinya dapat ditemukan di sini.

Tips penggunaan

  • Untuk menggunakan Pop2Piano, Anda perlu menginstal pustaka 🤗 Transformers, serta modul pihak ketiga berikut:
pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy

Perhatikan bahwa Anda mungkin perlu memulai ulang runtime Anda setelah instalasi.

  • Pop2Piano adalah model berbasis Encoder-Decoder seperti T5.
  • Pop2Piano dapat digunakan untuk menghasilkan file midi-audio untuk urutan audio tertentu.
  • Memilih komposer yang berbeda di Pop2PianoForConditionalGeneration.generate() dapat menghasilkan variasi hasil yang berbeda.
  • Menetapkan laju sampling ke 44,1 kHz saat memuat file audio dapat memberikan kinerja yang baik.
  • Meskipun Pop2Piano terutama dilatih pada musik Pop Korea, model ini juga cukup baik dalam menangani lagu-lagu Pop Barat atau Hip Hop lainnya.

Contoh

  • Contoh menggunakan Dataset HuggingFace:
from datasets import load_dataset

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor


model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
ds = load_dataset("sweetcocoa/pop2piano_ci", split="test")

inputs = processor(
    audio=ds["audio"][0]["array"], sampling_rate=ds["audio"][0]["sampling_rate"], return_tensors="pt"
)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
  • Contoh menggunakan file audio Anda sendiri:
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor


audio, sr = librosa.load("<your_audio_file_here>", sr=44100)  # feel free to change the sr to a suitable value.
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=audio, sampling_rate=sr, return_tensors="pt").to(model.device)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
  • Contoh pemrosesan beberapa file audio dalam batch:
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor


# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=[audio1, audio2], sampling_rate=[sr1, sr2], return_attention_mask=True, return_tensors="pt").to(model.device)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")
  • Contoh pemrosesan beberapa file audio dalam batch (menggunakan Pop2PianoFeatureExtractor dan Pop2PianoTokenizer):
import librosa

from transformers import Pop2PianoFeatureExtractor, Pop2PianoForConditionalGeneration, Pop2PianoTokenizer


# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
feature_extractor = Pop2PianoFeatureExtractor.from_pretrained("sweetcocoa/pop2piano")
tokenizer = Pop2PianoTokenizer.from_pretrained("sweetcocoa/pop2piano")

inputs = feature_extractor(
    audio=[audio1, audio2],
    sampling_rate=[sr1, sr2],
    return_attention_mask=True,
    return_tensors="pt",
)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = tokenizer.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")

Pop2PianoConfig

kelas transformers.Pop2PianoConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 2400composer_vocab_size: int = 21d_model: int = 512d_kv: int = 64d_ff: int = 2048num_layers: int = 6num_decoder_layers: int | None = Nonenum_heads: int = 8relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'gated-gelu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1dense_act_fn: str = 'relu'is_decoder: bool = Falsetie_word_embeddings: bool = True )

Parameter

  • is_encoder_decoder (bool, opsional, defaultnya True) — Apakah model digunakan sebagai encoder/decoder atau tidak.
  • vocab_size (int, opsional, default 2400) — Ukuran kosakata model. Menentukan jumlah token berbeda yang dapat direpresentasikan oleh input_ids.
  • composer_vocab_size (int, opsional, default 21) — Menunjukkan jumlah komposer.
  • d_model (int, opsional, default 512) — Ukuran lapisan encoder dan lapisan pooler.
  • d_kv (int, opsional, default 64) — Ukuran proyeksi key, query, dan value per kepala perhatian. inner_dim dari lapisan proyeksi akan didefinisikan sebagai num_heads * d_kv.
  • d_ff (int, opsional, default 2048) — Dimensi representasi MLP.
  • num_layers (int, opsional, default 6) — Jumlah lapisan tersembunyi dalam decoder Transformer.
  • num_decoder_layers (int, opsional) — Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan num_layers jika tidak diatur.
  • num_heads (int, opsional, default 8) — Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.
  • relative_attention_num_buckets (int, opsional, defaultnya 32) — Jumlah bucket yang digunakan untuk setiap lapisan perhatian.
  • relative_attention_max_distance (int, opsional, default 128) — Jarak maksimum dari urutan yang lebih panjang untuk pemisahan bucket.
  • dropout_rate (Union[float, int], opsional, defaultnya 0.1) — Rasio untuk semua lapisan dropout.
  • layer_norm_epsilon (float, opsional, defaultnya 1e-06) — Epsilon yang digunakan oleh lapisan normalisasi lapisan.
  • initializer_factor (float, opsional, default 1.0) — Faktor untuk menginisialisasi semua matriks bobot (sebaiknya dipertahankan pada 1, digunakan secara internal untuk pengujian inisialisasi).
  • feed_forward_proj (string, opsional, default "gated-gelu") — Jenis lapisan feed forward yang akan digunakan. Harus salah satu dari "relu" atau "gated-gelu".
  • 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, default 0) — ID token yang digunakan untuk padding dalam kosakata.
  • eos_token_id (Union[int, list[int]], opsional, default 1) — ID token yang digunakan untuk end-of-stream dalam kosakata.
  • dense_act_fn (string, opsional, defaultnya "relu") — Jenis Activation Function yang akan digunakan di Pop2PianoDenseActDense dan di Pop2PianoDenseGatedActDense.
  • is_decoder (bool, opsional, default False) — Apakah model digunakan sebagai decoder atau tidak. Jika False, model digunakan sebagai encoder.
  • tie_word_embeddings (bool, opsional, default True) — Apakah akan mengikat bobot embedding sesuai dengan pemetaan tied_weights_keys model.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Pop2PianoModel. Kelas ini digunakan untuk membuat instans model Pop2Piano sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari sweetcocoa/pop2piano

Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.

Pop2PianoFeatureExtractor

kelas transformers.Pop2PianoFeatureExtractor

< >

( sampling_rate: int = 22050padding_value: int = 0window_size: int = 4096hop_length: int = 1024min_frequency: float = 10.0feature_size: int = 512num_bars: int = 2**kwargs )

Parameter

  • sampling_rate (int, opsional, default 22050) — Laju sampling target dari sinyal audio. Ini adalah laju sampling yang diteruskan ke model.
  • padding_value (int, opsional, default 0) — Nilai padding yang digunakan untuk mengisi audio. Seharusnya sesuai dengan bagian hening.
  • window_size (int, opsional, default 4096) — Panjang jendela dalam sampel yang menjadi objek transformasi Fourier.
  • hop_length (int, opsional, default 1024) — Ukuran langkah antara setiap jendela waveform, dalam sampel.
  • min_frequency (float, opsional, default 10.0) — Frekuensi terendah yang akan digunakan dalam spektrogram log-mel.
  • feature_size (int, opsional, default 512) — Dimensi fitur dari fitur yang diekstrak.
  • num_bars (int, opsional, default 2) — Menentukan interval antara setiap urutan.

Membangun ekstraktor fitur Pop2Piano.

Feature extractor ini mewarisi dari SequenceFeatureExtractor yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

Kelas ini mengekstrak ritme dan memproses praproses audio sebelum diteruskan ke model. Pertama, audio diteruskan ke algoritma RhythmExtractor2013 yang mengekstrak beat_times, posisi beat, serta memperkirakan tingkat kepercayaan dan tempo dalam bpm. Kemudian, beat_times diinterpolasi untuk mendapatkan beatsteps. Selanjutnya, kita menghitung extrapolated_beatsteps darinya untuk digunakan dalam tokenizer. Di sisi lain, audio diresample ke self.sampling_rate dan diproses praproses, kemudian log mel spectogram dihitung dari hasilnya untuk digunakan dalam model transformer kita.

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | list[int]steps_per_beat: int = 2resample: bool | None = Truereturn_attention_mask: bool | None = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs )

Parameter

  • audio (np.ndarray, List) — Audio atau batch audio yang akan diproses. Setiap audio dapat berupa array numpy, daftar nilai float, daftar array numpy, atau daftar dari daftar nilai float.
  • sampling_rate (int) — Laju sampling di mana input audio disampelkan. Sangat disarankan untuk meneruskan sampling_rate pada panggilan forward untuk mencegah kesalahan yang tidak terdeteksi.
  • steps_per_beat (int, opsional, defaultnya 2) — Ini digunakan dalam interpolasi beat_times.
  • resample (bool, opsional, default True) — Menentukan apakah audio akan diresample ke sampling_rate atau tidak sebelum diproses. Harus True selama inferensi.
  • return_attention_mask (bool opsional, defaultnya False) — Menunjukkan apakah attention_mask untuk input_features, beatsteps, dan extrapolated_beatstep akan diberikan sebagai output atau tidak. Secara otomatis diatur ke True untuk input yang di-batch.
  • return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor alih-alih daftar integer Python. Nilai yang dapat diterima adalah:
    • 'pt': Mengembalikan objek PyTorch torch.Tensor.
    • 'np': Mengembalikan objek Numpy np.ndarray. Jika tidak ada yang ditentukan, akan mengembalikan daftar array np.ndarray.

Metode utama untuk melakukan featurisasi dan persiapan untuk model.

Pop2PianoForConditionalGeneration

kelas transformers.Pop2PianoForConditionalGeneration

< >

( config: Pop2PianoConfig )

Parameter

  • config (Pop2PianoConfig) — Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode from_pretrained() untuk memuat bobot model.

Model Pop2Piano dengan kepala language modeling di atasnya.

Model ini mewarisi dari PreTrainedModel. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)

Model ini juga merupakan subclass dari 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Parameter

  • input_ids (torch.LongTensor dengan bentuk (batch_size, sequence_length)) — Indeks token dari urutan input dalam kosakata. Pop2Piano adalah model dengan posisi relatif sehingga Anda seharusnya dapat mengisi (padding) input di sisi kanan dan kiri. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detail. Apa itu input ID? Untuk mengetahui lebih lanjut tentang cara menyiapkan input_ids untuk pra-pelatihan, lihat Pop2Piano Training.
  • attention_mask (torch.Tensor dengan bentuk (batch_size, sequence_length), opsional) — Mask untuk menghindari eksekusi attention pada indeks token padding. Nilai mask dipilih dari [0, 1]:
    • 1 untuk token yang tidak dimasker,
    • 0 untuk token yang dimasker.

    Apa itu attention mask?

  • decoder_input_ids (torch.LongTensor dengan bentuk (batch_size, target_sequence_length), opsional) — Indeks token dari urutan input decoder dalam kosakata. Indeks dapat diperoleh menggunakan AutoTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya. Apa itu decoder input IDs? Pop2Piano menggunakan pad_token_id sebagai token awal untuk generasi decoder_input_ids. Jika past_key_values digunakan, secara opsional hanya decoder_input_ids terakhir yang perlu diinput (lihat past_key_values). Untuk mengetahui lebih lanjut tentang cara menyiapkan
  • decoder_attention_mask (torch.BoolTensor dengan bentuk (batch_size, target_sequence_length), opsional) — Perilaku default: menghasilkan tensor yang mengabaikan token pad di decoder_input_ids. Mask kausal juga akan digunakan secara default.
  • encoder_outputs (tuple[tuple[torch.Tensor]], opsional) — Tuple terdiri dari (last_hidden_state, opsional: hidden_states, opsional: attentions) last_hidden_state dengan bentuk (batch_size, sequence_length, hidden_size), opsional) adalah rangkaian hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention decoder.
  • past_key_values (~cache_utils.Cache, opsional) — Hidden-states yang sudah 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 yang diizinkan sebagai input, lihat panduan kv cache kami. Jika tidak ada past_key_values yang diteruskan, DynamicCache akan diinisialisasi secara default.

    Model akan menghasilkan format cache yang sama dengan yang diberikan sebagai input.

    Jika past_key_values digunakan, pengguna diharapkan hanya memasukkan input_ids yang belum diproses (yang tidak memiliki state past key value yang 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. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
  • 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 Pop2PianoFeatureExtractor. Lihat Pop2PianoFeatureExtractor.call() untuk detailnya (Pop2PianoProcessor menggunakan Pop2PianoFeatureExtractor untuk memproses audio).
  • decoder_inputs_embeds (torch.Tensor dengan bentuk (batch_size, target_sequence_length, hidden_size), opsional) — Secara opsional, alih-alih meneruskan decoder_input_ids Anda dapat memilih untuk langsung meneruskan representasi tertanam. Jika past_key_values digunakan, secara opsional hanya decoder_inputs_embeds yang perlu dimasukkan (lihat past_key_values). Ini berguna jika Anda ingin lebih banyak kendali atas cara mengonversi decoder_input_ids indeks menjadi vektor terkait daripada matriks pencarian embedding internal model.

    Jika decoder_input_ids dan decoder_inputs_embeds keduanya tidak disetel, decoder_inputs_embeds mengambil nilai dari inputs_embeds.

  • labels (torch.LongTensor dengan bentuk (batch_size,), opsional) — Label untuk menghitung loss klasifikasi/regresi sekuens. Indeks harus berada dalam [-100, 0, ..., config.vocab_size - 1]. Semua label yang disetel ke -100 akan diabaikan (diberi mask), loss hanya dihitung untuk label dalam [0, ..., config.vocab_size]
  • use_cache (bool, opsional) — Jika diset ke True, state kunci-nilai past_key_values akan dikembalikan dan dapat digunakan untuk mempercepat decoding (lihat past_key_values).

Mengembalikan

Seq2SeqLMOutput atau tuple(torch.Tensor)

A Seq2SeqLMOutput atau tuple dari torch.Tensor (jika return_dict=False dilewatkan atau ketika config.return_dict=False) yang terdiri dari berbagai elemen tergantung pada konfigurasi (Pop2PianoConfig) dan input.

Metode forward dari Pop2PianoForConditionalGeneration 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.

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

  • past_key_values (EncoderDecoderCache, opsional, dikembalikan ketika use_cache=True diteruskan atau ketika config.use_cache=True) — Ini adalah instance EncoderDecoderCache. Untuk detail lebih lanjut, lihat panduan kv cache kami.

    Mengandung hidden-states yang telah dihitung sebelumnya (key dan values di blok self-attention dan di blok cross-attention) yang dapat digunakan (lihat input past_key_values) untuk mempercepat decoding berurutan.

  • decoder_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 dari decoder pada output setiap layer ditambah output embedding awal.

  • decoder_attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap lapisan) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

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

  • cross_attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap layer) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

    Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention.

  • encoder_last_hidden_state (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Urutan hidden-states pada keluaran lapisan terakhir dari encoder model.

  • encoder_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 dari encoder pada output setiap layer ditambah output embedding awal.

  • encoder_attentions (tuple(torch.Tensor), opsional, dikembalikan saat output_attentions=True dilewatkan atau saat config.output_attentions=True) — Tuple dari torch.Tensor (satu untuk setiap lapisan) dengan bentuk (batch_size, num_heads, sequence_length, sequence_length).

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

Contoh:

>>> from transformers import AutoProcessor, Pop2PianoForConditionalGeneration
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...

generate

< >

( input_featuresattention_mask = Nonecomposer = 'composer1'generation_config = None**kwargs ) → ModelOutput or torch.LongTensor

Parameter

  • input_features (torch.Tensor dengan bentuk (batch_size, sequence_length, hidden_size), opsional) — Ini adalah versi audio yang difeaturisasi yang dihasilkan oleh Pop2PianoFeatureExtractor.
  • attention_mask — Untuk generasi batched input_features di-pad agar memiliki bentuk yang sama di semua contoh. attention_mask membantu menentukan area mana yang di-pad dan mana yang tidak.
    • 1 untuk token yang tidak di-padded,
    • 0 untuk token yang diisi.
  • composer (str, opsional, default "composer1") — Nilai ini diteruskan ke Pop2PianoConcatEmbeddingToMel untuk menghasilkan embedding yang berbeda untuk setiap "composer". Pastikan nilai composer tersebut ada di composer_to_feature_token pada generation_config. Untuk contoh, silakan lihat https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json .
  • generation_config (~generation.GenerationConfig, opsional) — Konfigurasi generasi yang akan digunakan sebagai parametrisasi dasar untuk panggilan generasi. **kwargs yang diteruskan ke generate dan cocok dengan atribut dari generation_config akan menimpanya. Jika generation_config tidak disediakan, nilai default akan digunakan, yang memiliki prioritas pemuatan sebagai berikut: 1) dari file model generation_config.json, jika ada; 2) dari konfigurasi model. Perhatikan bahwa parameter yang tidak ditentukan akan mewarisi nilai default dari GenerationConfig, yang dokumentasinya harus diperiksa untuk memparametrisasi generasi.
  • kwargs — Parametrisasi ad hoc untuk generate_config dan/atau kwargs spesifik model tambahan yang akan diteruskan ke fungsi forward dari model. Jika model adalah model encoder-decoder, kwargs spesifik encoder tidak boleh diberi awalan dan kwargs spesifik decoder harus diberi awalan decoder_.

Mengembalikan

ModelOutput atau torch.LongTensor

ModelOutput (jika return_dict_in_generate=True atau ketika config.return_dict_in_generate=True) atau torch.Tensor. Karena Pop2Piano adalah model encoder-decoder (model.config.is_encoder_decoder=True), tipe ModelOutput yang mungkin adalah:

Membuat token id untuk output midi.

Sebagian besar parameter pengendali generasi diatur dalam generation_config yang, jika tidak diberikan, akan disetel ke konfigurasi generasi default model. Anda dapat menimpa generation_config mana pun dengan meneruskan parameter yang sesuai ke generate(), misalnya .generate(inputs, num_beams=4, do_sample=True). Untuk ringkasan strategi generasi dan contoh kode, lihat panduan berikut.

Pop2PianoTokenizer

kelas transformers.Pop2PianoTokenizer

< >

( vocabdefault_velocity = 77num_bars = 2unk_token = '-1'eos_token = '1'pad_token = '0'bos_token = '2'**kwargs )

Parameter

  • vocab (str) — Path ke file vocab yang berisi kosa kata.
  • default_velocity (int, opsional, defaultnya 77) — Menentukan kecepatan default yang akan digunakan saat membuat Note midi.
  • num_bars (int, opsional, default 2) — Menentukan cutoff_time_idx untuk setiap token.
  • unk_token (str atau tokenizers.AddedToken, opsional, default "-1") — Token yang tidak diketahui. Token yang tidak ada dalam kosakata tidak dapat dikonversi menjadi ID dan akan diset sebagai token ini.
  • eos_token (str atau tokenizers.AddedToken, opsional, default 1) — Token akhir dari urutan.
  • pad_token (str atau tokenizers.AddedToken, opsional, default 0) — Token khusus yang digunakan untuk membuat array token berukuran sama untuk keperluan batching. Token ini kemudian akan diabaikan oleh mekanisme attention atau perhitungan loss.
  • bos_token (str atau tokenizers.AddedToken, opsional, default 2) — Token awal urutan yang digunakan selama pra-pelatihan. Dapat digunakan sebagai token klasifikator urutan.

Membangun tokenizer Pop2Piano. Tokenizer ini tidak memerlukan pelatihan.

Tokenizer ini mewarisi dari PreTrainedTokenizer yang berisi sebagian besar metode utama. Pengguna harus merujuk ke superclass ini untuk informasi lebih lanjut mengenai metode-metode tersebut.

__call__

< >

( notes: numpy.ndarray | list[pretty_midi.Note] | list[list[pretty_midi.Note]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = True**kwargs )

Parameter

  • notes (numpy.ndarray dengan bentuk [batch_size, max_sequence_length, 4] atau list daftar pretty_midi.Note objek) — Ini mewakili nada midi.

    Jika notes adalah numpy.ndarray:

    • Setiap urutan harus memiliki 4 nilai, yaitu onset idx, offset idx, pitch dan velocity. Jika notes adalah list yang berisi objek pretty_midi.Note:
    • Setiap urutan harus memiliki 4 atribut, yaitu start, end, pitch dan velocity.
  • padding (bool, str atau PaddingStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:
    • True atau 'longest': Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
    • 'max_length': Pad hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
    • False atau 'do_not_pad' (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
  • truncation (bool, str atau TruncationStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:
    • True atau 'longest_first': Memotong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.
    • 'only_first': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
    • 'only_second': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
    • False atau 'do_not_truncate' (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
  • max_length (int, opsional) — Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding. Jika tidak disetel atau disetel ke None, ini akan menggunakan panjang maksimum model yang telah ditentukan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum spesifik (seperti XLNet) truncation/padding ke panjang maksimum akan dinonaktifkan.
  • pad_to_multiple_of (int, opsional) — Jika diset, akan melakukan padding pada urutan hingga menjadi kelipatan dari nilai yang diberikan. Ini sangat berguna untuk memungkinkan penggunaan Tensor Cores pada perangkat keras NVIDIA dengan kemampuan komputasi >= 7.5 (Volta).
  • return_attention_mask (bool, opsional) — Apakah akan mengembalikan attention mask. Jika dibiarkan pada nilai default, akan mengembalikan attention mask sesuai dengan default tokenizer tertentu, yang didefinisikan oleh return_outputs atribut.

    Apa itu attention mask?

  • return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor alih-alih daftar integer Python. Nilai yang dapat diterima adalah:
    • 'pt': Mengembalikan objek PyTorch torch.Tensor.
    • 'np': Mengembalikan objek Numpy np.ndarray.
  • verbose (bool, opsional, defaultnya True) — Apakah akan mencetak lebih banyak informasi dan peringatan.

Ini adalah metode __call__ untuk Pop2PianoTokenizer. Metode ini mengkonversi nada midi menjadi id token yang dihasilkan transformer.

Pop2PianoProcessor

kelas transformers.Pop2PianoProcessor

< >

( feature_extractortokenizer )

Parameter

  • feature_extractor (Pop2PianoFeatureExtractor) — Feature extractor adalah input yang wajib.
  • tokenizer (tokenizer_class) — Tokenizer adalah input yang wajib.

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

Pop2PianoProcessor menyediakan semua fungsionalitas dari Pop2PianoFeatureExtractor dan tokenizer_class. Lihat ~Pop2PianoFeatureExtractor dan ~tokenizer_class untuk informasi lebih lanjut.

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] = Nonesampling_rate: int | list[int] | None = Nonesteps_per_beat: int = 2resample: bool | None = Truenotes: list | transformers.utils.generic.TensorType = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Noneverbose: bool = True**kwargs )

Parameter

  • audio (Union[numpy.ndarray, list[float], list[numpy.ndarray]], 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 dari audio tersebut.
  • sampling_rate (int atau list[int], opsional) — Laju sampling audio input dalam Hz. Nilai ini harus sesuai dengan laju sampling yang digunakan oleh ekstraktor fitur. Jika tidak diberikan, laju sampling default dari konfigurasi prosesor akan digunakan.
  • steps_per_beat (int, opsional, default 2) — Jumlah langkah waktu per ketukan musik. Parameter ini mengontrol resolusi temporal dari representasi musik. Nilai yang lebih tinggi memberikan granularitas temporal yang lebih halus tetapi meningkatkan panjang urutan. Digunakan saat memproses audio untuk mengekstrak fitur musik.
  • resample (bool, opsional, default True) — Filter resampling yang digunakan jika mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum PILImageResampling. Hanya berpengaruh jika do_resize diatur ke True.
  • notes (list atau TensorType, opsional) — Catatan musik yang sudah diekstrak sebelumnya dalam format MIDI. Jika disediakan, prosesor akan melewati ekstraksi fitur audio dan langsung memproses catatan melalui tokenizer. Setiap catatan harus direpresentasikan sebagai list atau tensor yang berisi informasi pitch, velocity, dan timing.
  • padding (bool, str atau PaddingStrategy, opsional, defaultnya False) — Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut:
    • True atau 'longest': Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan).
    • 'max_length': Pad hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan.
    • False atau 'do_not_pad' (default): Tidak ada padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda).
  • truncation (bool, str atau TruncationStrategy, opsional) — Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut:
    • True atau 'longest_first': Memotong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini akan memotong per token, dengan menghapus satu token dari urutan terpanjang dalam pasangan jika sepasang urutan (atau batch pasangan) diberikan.
    • 'only_first': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan pertama dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
    • 'only_second': Potong hingga panjang maksimum yang ditentukan dengan argumen max_length atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. Ini hanya akan memotong urutan kedua dari sebuah pasangan jika sepasang urutan (atau batch dari pasangan) diberikan.
    • False atau 'do_not_truncate' (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model).
  • max_length (int, opsional) — Mengontrol panjang maksimum yang digunakan oleh salah satu parameter truncation/padding.

    Jika tidak disetel atau disetel ke None, ini akan menggunakan panjang maksimum model yang telah didefinisikan sebelumnya jika panjang maksimum diperlukan oleh salah satu parameter truncation/padding. Jika model tidak memiliki panjang input maksimum yang spesifik (seperti XLNet), truncation/padding ke panjang maksimum akan dinonaktifkan.

  • pad_to_multiple_of (int, optional) — If set will pad the sequence to a multiple of the provided value. Requires padding to be activated. This is especially useful to enable using Tensor Cores on NVIDIA hardware with compute capability >= 7.5 (Volta).
  • verbose (bool, opsional, defaultnya True) — Apakah akan mencetak lebih banyak informasi dan peringatan.
  • return_tensors (str atau TensorType, opsional) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:
    • 'pt': Mengembalikan objek PyTorch torch.Tensor.
    • 'np': Mengembalikan objek NumPy np.ndarray.
Update on GitHub

←Pocket TTS Audio Tokenizer Qwen3 ASR→