Hugging Face's logo

Transformers documentation

Model Encoder Decoder

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
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 2017-06-12 dan disumbangkan ke Hugging Face Transformers pada 2020-11-16.

SDPA

Model Encoder Decoder

EncoderDecoderModel menginisialisasi model sequence-to-sequence dengan autoencoder pretrained dan model autoregressive pretrained apa pun. Model ini efektif untuk tugas generasi sequence, seperti yang ditunjukkan dalam Text Summarization with Pretrained Encoders yang menggunakan BertModel sebagai encoder dan decoder.

Model ini disumbangkan oleh thomwolf.

Klik pada model Encoder Decoder di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan Encoder Decoder ke berbagai tugas bahasa.

Contoh di bawah ini menunjukkan cara menghasilkan teks dengan Pipeline, AutoModel, dan dari baris perintah.

AutoModel
from transformers import AutoModelForCausalLM, AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16")
model = AutoModelForCausalLM.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16", device_map="auto",attn_implementation="sdpa")

text = "Plants create energy through a process known as photosynthesis. This involves capturing sunlight and converting carbon dioxide and water into glucose and oxygen."

inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(model.device)

summary = model.generate(**inputs, max_length=60, num_beams=4, early_stopping=True)
print(tokenizer.decode(summary[0], skip_special_tokens=True))

Catatan

  • EncoderDecoderModel dapat diinisialisasi menggunakan encoder dan decoder pretrained apa pun. Namun, tergantung pada arsitektur decoder, lapisan cross-attention mungkin diinisialisasi secara acak.

Model-model ini memerlukan penyesuaian lanjutan (fine-tuning), seperti yang dibahas dalam artikel blog ini. Gunakan from_encoder_decoder_pretrained() untuk menggabungkan checkpoint encoder dan decoder.

from transformers import BertTokenizer, EncoderDecoderModel


tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = EncoderDecoderModel.from_encoder_decoder_pretrained(
    "google-bert/bert-base-uncased",
    "google-bert/bert-base-uncased"
)
  • Model Encoder Decoder dapat dihaluskan seperti BART, T5, atau model encoder-decoder lainnya. Hanya 2 input yang diperlukan untuk menghitung loss, yaitu input_ids dan labels. Lihat notebook ini untuk contoh pelatihan yang lebih detail.
from transformers import BertTokenizer, EncoderDecoderModel


tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")

model.config.decoder_start_token_id = tokenizer.cls_token_id
model.config.pad_token_id = tokenizer.pad_token_id

input_ids = tokenizer(
    "The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side.During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was  finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft).Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.",
    return_tensors="pt",
).input_ids

labels = tokenizer(
    "the eiffel tower surpassed the washington monument to become the tallest structure in the world. it was the first structure to reach a height of 300 metres in paris in 1930. it is now taller than the chrysler building by 5. 2 metres ( 17 ft ) and is the second tallest free - standing structure in paris.",
    return_tensors="pt",
).input_ids

# the forward function automatically creates the correct decoder_input_ids
loss = model(input_ids=input_ids, labels=labels).loss
  • EncoderDecoderModel dapat diinisialisasi secara acak dari konfigurasi encoder dan decoder seperti yang ditunjukkan di bawah ini.
from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel


config_encoder = BertConfig()
config_decoder = BertConfig()

config = EncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = EncoderDecoderModel(config=config)
  • Model Encoder Decoder juga dapat digunakan untuk penerjemahan seperti yang ditunjukkan di bawah ini.
from transformers import AutoTokenizer, EncoderDecoderModel


# Load a pre-trained translation model
model_name = "google/bert2bert_L-24_wmt_en_de"
tokenizer = AutoTokenizer.from_pretrained(model_name, pad_token="<pad>", eos_token="</s>", bos_token="<s>")
model = EncoderDecoderModel.from_pretrained(model_name, device_map="auto")

# Input sentence to translate
input_text = "Plants create energy through a process known as"

# Encode the input text
inputs = tokenizer(input_text, return_tensors="pt", add_special_tokens=False).to(model.device).input_ids

# Generate the translated output
outputs = model.generate(inputs)[0]

# Decode the output tokens to get the translated sentence
translated_text = tokenizer.decode(outputs, skip_special_tokens=True)

print("Translated text:", translated_text)

EncoderDecoderConfig

kelas transformers.EncoderDecoderConfig

< >

( 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 | None = Trueencoder: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonedecoder: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonepad_token_id: int | None = Nonedecoder_start_token_id: int | None = None )

Parameter

  • is_encoder_decoder (bool, opsional, defaultnya True) — Apakah model digunakan sebagai encoder/decoder atau tidak.
  • encoder (Union[~configuration_utils.PreTrainedConfig, dict], opsional) — Objek config atau dictionary dari backbone encoder.
  • decoder (Union[~configuration_utils.PreTrainedConfig, dict], opsional) — Objek config atau dictionary dari backbone decoder.
  • pad_token_id (int, opsional) — ID token yang digunakan untuk padding dalam kosakata.
  • decoder_start_token_id (int, opsional) — Jika model encoder-decoder memulai decoding dengan token yang berbeda dari bos, id dari token tersebut.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari model Encoder Decoder. Kelas ini digunakan untuk membuat model Encoder Decoder sesuai dengan argumen yang ditentukan, yang mendefinisikan arsitektur model. Membuat konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari

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

Contoh:

>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

>>> # Initializing a BERT google-bert/bert-base-uncased style configuration
>>> config_encoder = BertConfig()
>>> config_decoder = BertConfig()

>>> config = EncoderDecoderConfig(encoder=config_encoder, decoder=config_decoder)

>>> # Initializing a Bert2Bert model (with random weights) from the google-bert/bert-base-uncased style configurations
>>> model = EncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = EncoderDecoderConfig.from_pretrained("my-model")
>>> model = EncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)

from_encoder_decoder_configs

< >

( encoder_config: PreTrainedConfigdecoder_config: PreTrainedConfig**kwargs ) → EncoderDecoderConfig

Mengembalikan

EncoderDecoderConfig

Instans dari objek konfigurasi

Instansiasi EncoderDecoderConfig (atau kelas turunan) dari konfigurasi model encoder yang telah dilatih sebelumnya dan konfigurasi model decoder.

EncoderDecoderModel

kelas transformers.EncoderDecoderModel

< >

( config: transformers.configuration_utils.PreTrainedConfig | None = Noneencoder: transformers.modeling_utils.PreTrainedModel | None = Nonedecoder: transformers.modeling_utils.PreTrainedModel | None = None )

Parameter

  • config (PreTrainedConfig, opsional) — 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.
  • encoder (PreTrainedModel, opsional) — Model encoder yang akan digunakan.
  • decoder (PreTrainedModel, opsional) — Model decoder yang akan digunakan.

Model Encoder Decoder polos yang menghasilkan hidden-states mentah tanpa head spesifik 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[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)

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. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

    Apa itu input ID?

  • 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 PreTrainedTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya. Apa itu input ID? Jika past_key_values digunakan, secara opsional hanya decoder_input_ids terakhir yang perlu diinput (lihat past_key_values). Untuk pelatihan, decoder_input_ids dibuat secara otomatis oleh model dengan menggeser label ke kanan, mengganti -100 dengan pad_token_id, dan menambahkan decoder_start_token_id di depannya.

    Indeks dapat diperoleh menggunakan PreTrainedTokenizer. Lihat PreTrainedTokenizer.encode() dan PreTrainedTokenizer.call() untuk detailnya.

    Apa itu input ID?

    Jika past_key_values digunakan, secara opsional hanya decoder_input_ids terakhir yang perlu diinput (lihat past_key_values).

    Untuk pelatihan, decoder_input_ids dibuat secara otomatis oleh model dengan menggeser labels ke kanan, mengganti -100 dengan pad_token_id, dan menambahkan decoder_start_token_id di awal.

  • 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[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.
  • 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. Hal ini berguna jika Anda ingin memiliki kendali lebih atas cara mengonversi indeks decoder_input_ids menjadi vektor terkait, dibandingkan dengan matriks pencarian penanaman internal model.
  • labels (torch.LongTensor dengan bentuk (batch_size, sequence_length), opsional) — Label untuk menghitung kerugian pemodelan bahasa tersembunyi (masked language modeling loss) untuk decoder. Indeks harus berada dalam [-100, 0, ..., config.vocab_size] (lihat docstring input_ids). Token dengan indeks yang disetel ke -100 diabaikan (ditutupi), kerugian hanya dihitung untuk token dengan 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 (EncoderDecoderConfig) dan input.

Metode forward dari EncoderDecoderModel 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 EncoderDecoderModel, BertTokenizer
>>> import torch

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google-bert/bert-base-uncased", "google-bert/bert-base-uncased"
... )  # initialize Bert2Bert from pre-trained checkpoints

>>> # training
>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> input_ids = tokenizer("This is a really long text", return_tensors="pt").input_ids
>>> labels = tokenizer("This is the corresponding summary", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("bert2bert")
>>> model = EncoderDecoderModel.from_pretrained("bert2bert")

>>> # generation
>>> generated = model.generate(input_ids)

from_encoder_decoder_pretrained

< >

( encoder_pretrained_model_name_or_path: str | None = Nonedecoder_pretrained_model_name_or_path: str | None = None*model_args**kwargs )

Parameter

  • encoder_pretrained_model_name_or_path (str, opsional) — Informasi yang diperlukan untuk memulai encoder. Bisa berupa:
    • String, model id dari model pretrained yang dihosting di dalam model repo di huggingface.co.
    • Path ke direktori yang berisi bobot model yang disimpan menggunakan save_pretrained(), misalnya ./my_model_directory/.
  • decoder_pretrained_model_name_or_path (str, opsional, default ke None) — Informasi yang diperlukan untuk memulai decoder. Bisa berupa:
    • String, model id dari model pretrained yang dihosting di dalam model repo di huggingface.co.
    • Path ke direktori yang berisi bobot model yang disimpan menggunakan save_pretrained(), misalnya ./my_model_directory/.
  • model_args (argumen posisional lainnya, opsional) — Semua argumen posisional lainnya akan diteruskan ke metode __init__ model yang mendasarinya.
  • kwargs (sisa kamus argumen kata kunci, opsional) — Dapat digunakan untuk memperbarui objek konfigurasi (setelah dimuat) dan menginisiasi model (mis., output_attentions=True).
    • Untuk memperbarui konfigurasi encoder, gunakan prefiks encoder_ untuk setiap parameter konfigurasi.
    • Untuk memperbarui konfigurasi decoder, gunakan prefiks decoder_ untuk setiap parameter konfigurasi.
    • Untuk memperbarui konfigurasi model induk, jangan gunakan awalan untuk setiap parameter konfigurasi.

    Berperilaku berbeda tergantung pada apakah config disediakan atau dimuat secara otomatis.

Instansiasi encoder dan decoder dari satu atau dua kelas dasar pustaka dari checkpoint model pretrained.

Model secara default diatur dalam mode evaluasi menggunakan model.eval() (modul Dropout dinonaktifkan). Untuk melatih model, Anda perlu terlebih dahulu mengembalikannya ke mode pelatihan dengan model.train().

Contoh:

>>> from transformers import EncoderDecoderModel

>>> # initialize a bert2bert from two pretrained BERT models. Note that the cross-attention layers will be randomly initialized
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2bert")
>>> # load fine-tuned model
>>> model = EncoderDecoderModel.from_pretrained("./bert2bert")
Update on GitHub

←ELECTRA ERNIE→