TRL documentation

Format dan tipe dataset

You are viewing v1.18.1 version. A newer version v1.18.2 is available.
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Format dan tipe dataset

Panduan ini memberikan gambaran umum tentang format dan tipe dataset yang didukung oleh setiap trainer di TRL.

Ikhtisar format dan tipe dataset

  • Format dari dataset merujuk pada bagaimana data tersebut disusun, yang biasanya dikategorikan sebagai standar atau konversasional.
  • type terkait dengan tugas spesifik yang menjadi tujuan dataset, seperti prompt-only atau preference. Setiap tipe dicirikan oleh kolom-kolomnya, yang bervariasi sesuai dengan tugas, seperti yang ditunjukkan pada tabel.
Tipe \ FormatStandarKonversasional
Pemodelan bahasa
{"text": "The sky is blue."}
{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}
Hanya prompt
{"prompt": "The sky is"}
{"prompt": [{"role": "user", "content": "What color is the sky?"}]}
Prompt-pelengkapan
{"prompt": "The sky is",
 "completion": " blue."}
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is blue."}]}
Preferensi
{"prompt": "The sky is",
 "chosen": " blue.",
 "rejected": " green."}
atau, dengan prompt implisit:
{"chosen": "The sky is blue.",
 "rejected": "The sky is green."}
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "chosen": [{"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "assistant", "content": "It is green."}]}
atau, dengan prompt implisit:
{"chosen": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "user", "content": "What color is the sky?"},
                {"role": "assistant", "content": "It is green."}]}
Preferensi tidak berpasangan
{"prompt": "The sky is",
 "completion": " blue.",
 "label": True}
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is green."}],
 "label": False}

Format

Standar

Format dataset standar biasanya terdiri dari string teks polos. Kolom dalam dataset bervariasi tergantung pada tugas. Ini adalah format yang diharapkan oleh trainer TRL. Di bawah ini adalah contoh format dataset standar untuk berbagai tugas:

# Language modeling
language_modeling_example = {"text": "The sky is blue."}
# Preference
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Unpaired preference
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

Konversasional

Dataset percakapan digunakan untuk tugas yang melibatkan dialog atau interaksi chat antara pengguna dan asisten. Berbeda dengan format dataset standar, dataset ini berisi rangkaian pesan di mana setiap pesan memiliki role (misalnya, "user" atau "assistant") dan content (teks pesan).

messages = [
    {"role": "user", "content": "Hello, how are you?"},
    {"role": "assistant", "content": "I'm doing great. How can I help you today?"},
    {"role": "user", "content": "I'd like to show off how chat templating works!"},
]

Sama seperti dataset standar, kolom dalam dataset percakapan bervariasi tergantung pada tugasnya. Berikut adalah contoh format dataset percakapan untuk berbagai tugas:

# Prompt-completion
prompt_completion_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                             "completion": [{"role": "assistant", "content": "It is blue."}]}
# Preference
preference_example = {
    "prompt": [{"role": "user", "content": "What color is the sky?"}],
    "chosen": [{"role": "assistant", "content": "It is blue."}],
    "rejected": [{"role": "assistant", "content": "It is green."}],
}

Pemanggilan Alat

Beberapa template chat mendukung tool calling, yang memungkinkan model berinteraksi dengan fungsi eksternal—yang disebut sebagai tools—selama proses generasi. Hal ini memperluas kemampuan percakapan model dengan memungkinkannya untuk mengeluarkan field "tool_calls" alih-alih pesan "content" standar setiap kali model memutuskan untuk memanggil sebuah tool.

Setelah asisten memulai panggilan alat, alat tersebut dieksekusi dan mengembalikan keluarannya. Asisten kemudian dapat memproses keluaran ini dan melanjutkan percakapan sesuai dengan hasilnya.

Berikut adalah contoh sederhana dari interaksi pemanggilan alat:

messages = [
    {"role": "user", "content": "Turn on the living room lights."},
    {"role": "assistant", "tool_calls": [
        {"type": "function", "function": {
            "name": "control_light",
            "arguments": {"room": "living room", "state": "on"}
        }}]
    },
    {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
    {"role": "assistant", "content": "Done!"}
]

Saat menyiapkan dataset untuk Supervised Fine-Tuning (SFT) dengan tool calling, penting bahwa dataset Anda mencakup kolom tambahan bernama tools. Kolom ini berisi daftar tool yang tersedia untuk model, yang biasanya digunakan oleh chat template untuk menyusun system prompt.

Alat harus ditentukan dalam format skema JSON yang terstandar. Anda dapat menghasilkan skema ini secara otomatis dari tanda tangan fungsi Python menggunakan utilitas get_json_schema:

import json
from transformers.utils import get_json_schema

def control_light(room: str, state: str) -> str:
    """
    Controls the lights in a room.

    Args:
        room: The name of the room.
        state: The desired state of the light ("on" or "off").

    Returns:
        str: A message indicating the new state of the lights.
    """
    return f"The lights in {room} are now {state}."

# Generate JSON schema
json_schema = get_json_schema(control_light)

Skema yang dihasilkan akan terlihat seperti:

{"type": "function", "function": {"name": "control_light", "description": "Controls the lights in a room.", "parameters": {"type": "object", "properties": {"room": {"type": "string", "description": "The name of the room."}, "state": {"type": "string", "description": "The desired state of the light (\"on\" or \"off\")."}}, "required": ["room", "state"]}, "return": {"type": "string", "description": "str: A message indicating the new state of the lights."}}}

Entri dataset lengkap untuk SFT mungkin terlihat seperti:

{"messages": messages, "tools": [json_schema]}

Untuk mendapatkan Dataset, Anda perlu menggunakan tipe Json() untuk argumen tool karena objek JSON tersebut bersifat arbitrer, dan bukan kamus dengan field dan tipe yang tetap:

from datasets import Dataset

data = [
    {"messages": messages1, "tools": [json_schema1]},
    {"messages": messages2, "tools": [json_schema2]},
]
# auto-apply the Json() type
dataset = Dataset.from_list(data, on_mixed_types="use_json")

# or specify the features manually
from datasets import Features, Json, List, Value

features = Features(
    {
        "messages": List({"role": Value("string"), "content": Value("string"), "tool_calls": List(Json())}),
        "tools": List(Json()),
    }
)
dataset = Dataset.from_list(data, features=features)

Pada versi datasets yang lebih lama (<4.7.0) yang tidak memiliki tipe Json(), Anda harus menyimpan tools sebagai str JSON (dengan json.dumps([...])):

dataset = Dataset.from_list(
    [{"messages": messages1, "tools": json.dumps([json_schema1])},
     {"messages": messages2, "tools": json.dumps([json_schema2])}]
)

Untuk informasi lebih detail tentang tool calling, lihat bagian Tool Calling dalam dokumentasi transformers dan artikel blog Tool Use, Unified.

Harmony

Format respons Harmony diperkenalkan bersama model OpenAI GPT OSS. Format ini memperluas format percakapan dengan menambahkan struktur yang lebih kaya untuk penalaran, panggilan fungsi, dan metadata tentang perilaku model. Fitur-fitur utamanya meliputi:

  • Peran pengembang – Menyediakan instruksi tingkat tinggi (mirip dengan prompt sistem) dan mencantumkan alat yang tersedia.

  • Kanal – Pisahkan jenis output asisten ke dalam aliran yang berbeda:

    • analysis – untuk penalaran internal, dari kunci "thinking"
    • final – untuk jawaban yang ditampilkan ke pengguna, dari kunci "content"
    • commentary – untuk panggilan alat atau catatan meta
  • Usaha penalaran – Menunjukkan seberapa banyak pemikiran yang harus ditampilkan oleh model (misalnya, "low", "medium", "high").

  • Identitas model – Mendefinisikan secara eksplisit persona asisten.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("openai/gpt-oss-20b")

messages = [
    {"role": "developer", "content": "Use a friendly tone."},
    {"role": "user", "content": "What is the meaning of life?"},
    {"role": "assistant", "thinking": "Deep reflection...", "content": "The final answer is..."},
]

print(
    tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        reasoning_effort="low",
        model_identity="You are HuggingGPT, a large language model trained by Hugging Face.",
    )
)

Ini menghasilkan:

<|start|>system<|message|>You are HuggingGPT, a large language model trained by Hugging Face.
Knowledge cutoff: 2024-06
Current date: 2025-08-03

Reasoning: low

# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions

Use a friendly tone.<|end|><|start|>user<|message|>What is the meaning of life?<|end|><|start|>assistant<|channel|>analysis<|message|>Deep reflection...<|end|><|start|>assistant<|channel|>final<|message|>The final answer is...<|return|>

Untuk detail lengkap mengenai struktur pesan, bidang yang didukung, dan penggunaan lanjutan, lihat dokumentasi Harmony.

Tipe

Pemodelan bahasa

Dataset pemodelan bahasa terdiri dari kolom "text" (atau "messages" untuk dataset percakapan) yang berisi urutan teks lengkap.

# Standard format
language_modeling_example = {"text": "The sky is blue."}
# Conversational format
language_modeling_example = {"messages": [
    {"role": "user", "content": "What color is the sky?"},
    {"role": "assistant", "content": "It is blue."}
]}

Hanya prompt

Pada dataset yang hanya berisi prompt, hanya prompt awal (pertanyaan atau kalimat parsial) yang disediakan di bawah kunci "prompt". Pelatihan biasanya melibatkan pembuatan kelengkapan (completion) berdasarkan prompt ini, di mana model belajar untuk melanjutkan atau melengkapi input yang diberikan.

# Standard format
prompt_only_example = {"prompt": "The sky is"}
# Conversational format
prompt_only_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]}

Untuk contoh dataset hanya-prompt, lihat koleksi dataset hanya-prompt.

Meskipun tipe prompt-only dan language modeling serupa, keduanya berbeda dalam cara menangani input. Pada tipe prompt-only, prompt mewakili input parsial yang mengharapkan model untuk melengkapi atau melanjutkan, sedangkan pada tipe language modeling, input diperlakukan sebagai kalimat atau urutan yang lengkap. Kedua tipe ini diproses secara berbeda oleh TRL. Berikut adalah contoh yang menunjukkan perbedaan output fungsi apply_chat_template untuk masing-masing tipe:

from transformers import AutoTokenizer
from trl import apply_chat_template

tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-128k-instruct")

# Example for prompt-only type
prompt_only_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]}
apply_chat_template(prompt_only_example, tokenizer)
# Output: {'prompt': '<|user|>\nWhat color is the sky?<|end|>\n<|assistant|>\n'}

# Example for language modeling type
lm_example = {"messages": [{"role": "user", "content": "What color is the sky?"}]}
apply_chat_template(lm_example, tokenizer)
# Output: {'text': '<|user|>\nWhat color is the sky?<|end|>\n<|endoftext|>'}
  • Output hanya prompt mencakup '<|assistant|>\n', yang menandakan awal giliran asisten dan mengharapkan model untuk menghasilkan kelengkapan.
  • Sebaliknya, output pemodelan bahasa memperlakukan input sebagai urutan lengkap dan mengakhirinya dengan '<|endoftext|>', menandakan akhir teks dan tidak mengharapkan konten tambahan.

Prompt-pelengkapan

Dataset prompt-completion mencakup "prompt" dan "completion".

# Standard format
prompt_completion_example = {"prompt": "The sky is", "completion": " blue."}
# Conversational format
prompt_completion_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                             "completion": [{"role": "assistant", "content": "It is blue."}]}

Untuk contoh dataset prompt-completion, lihat koleksi dataset prompt-completion.

Preferensi

Dataset preferensi digunakan untuk tugas di mana model dilatih untuk memilih antara dua atau lebih kemungkinan penyelesaian untuk prompt yang sama. Dataset ini mencakup "prompt", penyelesaian "chosen", dan penyelesaian "rejected". Model dilatih untuk memilih respons "chosen" di atas respons "rejected". Beberapa dataset mungkin tidak menyertakan kolom "prompt", di mana prompt bersifat implisit dan langsung disertakan dalam penyelesaian "chosen" dan "rejected". Kami merekomendasikan penggunaan prompt eksplisit setiap kali memungkinkan.

# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}

Untuk contoh dataset preferensi, lihat koleksi dataset preferensi.

Beberapa dataset preferensi dapat ditemukan dengan tag dpo di Hugging Face Hub. Anda juga dapat menjelajahi Koleksi DPO dari librarian-bots untuk mengidentifikasi dataset preferensi.

Preferensi tidak berpasangan

Dataset preferensi tidak berpasangan mirip dengan dataset preferensi, tetapi alih-alih memiliki penyelesaian "chosen" dan "rejected" untuk prompt yang sama, dataset ini mencakup satu "completion" tunggal dan "label" yang menunjukkan apakah penyelesaian tersebut diprioritaskan atau tidak.

# Standard format
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}
# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}

Untuk contoh dataset preferensi tidak berpasangan, lihat Koleksi dataset preferensi tidak berpasangan.

Jenis dataset mana yang harus digunakan?

Memilih jenis dataset yang tepat bergantung pada tugas yang sedang Anda kerjakan dan persyaratan spesifik dari TRL trainer yang Anda gunakan. Di bawah ini adalah ringkasan singkat tentang jenis dataset yang didukung oleh masing-masing TRL trainer.

TrainerJenis dataset yang diharapkan
AsyncGRPOTrainerHanya prompt
DPOTrainerPreferensi (disarankan menggunakan prompt eksplisit)
GRPOTrainerHanya prompt
KTOTrainerPreferensi tidak berpasangan atau Preferensi (disarankan menggunakan prompt eksplisit)
RewardTrainerPreferensi (prompt implisit disarankan)
RLOOTrainerHanya prompt
SFTTrainerPemodelan bahasa atau Prompt-completion
experimental.cpo.CPOTrainerPreferensi (disarankan menggunakan prompt eksplisit)
experimental.gkd.GKDTrainerPrompt-pelengkap
experimental.online_dpo.OnlineDPOTrainerHanya prompt
experimental.orpo.ORPOTrainerPreferensi (disarankan menggunakan prompt eksplisit)

Menggunakan dataset apa pun dengan TRL: pra-pemrosesan dan konversi

Banyak dataset hadir dalam format yang disesuaikan untuk tugas tertentu, yang mungkin tidak langsung kompatibel dengan TRL. Untuk menggunakan dataset tersebut dengan TRL, Anda mungkin perlu melakukan pra-pemrosesan dan mengonversinya ke format yang diperlukan.

Untuk memudahkan hal ini, kami menyediakan seperangkat skrip contoh yang mencakup konversi dataset umum.

Contoh: dataset UltraFeedback

Mari kita ambil dataset UltraFeedback sebagai contoh. Berikut adalah pratinjau dataset:

Seperti yang ditunjukkan di atas, format dataset tidak sesuai dengan struktur yang diharapkan. Dataset ini tidak dalam format percakapan, nama kolomnya berbeda, dan hasilnya berkaitan dengan model yang berbeda (misalnya, Bard, GPT-4) serta aspek yang berbeda (misalnya, “helpfulness”, “honesty”).

Dengan menggunakan skrip konversi yang disediakan examples/datasets/ultrafeedback.py, Anda dapat mengubah dataset ini menjadi tipe preferensi tanpa pasangan, dan mengirimkannya ke Hub:

python examples/datasets/ultrafeedback.py --push_to_hub --repo_id trl-lib/ultrafeedback-gpt-3.5-turbo-helpfulness

Setelah dikonversi, dataset akan terlihat seperti ini:

Sekarang, Anda dapat menggunakan dataset ini dengan TRL!

Dengan mengadaptasi skrip yang disediakan atau membuat skrip Anda sendiri, Anda dapat mengonversi dataset apa pun ke dalam format yang kompatibel dengan TRL.

Utilitas untuk mengonversi tipe dataset

Bagian ini menyediakan kode contoh untuk membantu Anda mengonversi antara berbagai tipe dataset. Meskipun beberapa konversi dapat dilakukan setelah menerapkan template chat (yaitu, dalam format standar), kami merekomendasikan untuk melakukan konversi sebelum menerapkan template chat agar dapat bekerja secara konsisten.

Untuk kesederhanaan, beberapa contoh di bawah ini tidak mengikuti rekomendasi ini dan menggunakan format standar. Namun, konversi dapat diterapkan langsung ke format percakapan tanpa modifikasi.

Dari \ KePemodelan bahasaPrompt-pelengkapanHanya promptPreferensi dengan prompt implisitPreferensiPreferensi tidak berpasangan
Pemodelan bahasaN/AN/AN/AN/AN/AN/A
Prompt-pelengkapan🔗N/A🔗N/AN/AN/A
Hanya promptN/AN/AN/AN/AN/AN/A
Preferensi dengan prompt implisit🔗🔗🔗N/A🔗🔗
Preferensi🔗🔗🔗🔗N/A🔗
Preferensi tidak berpasangan🔗🔗🔗N/AN/AN/A

Dari prompt-completion ke dataset pemodelan bahasa

Untuk mengubah dataset prompt-completion menjadi dataset pemodelan bahasa, gabungkan prompt dan completion.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "completion": [" blue.", " in the sky."],
})

def concat_prompt_completion(example):
    return {"text": example["prompt"] + example["completion"]}

dataset = dataset.map(concat_prompt_completion, remove_columns=["prompt", "completion"])
>>> dataset[0]
{'text': 'The sky is blue.'}

Dari dataset prompt-pelengkapan ke dataset hanya-prompt

Untuk mengubah dataset prompt-completion menjadi dataset prompt-only, hapus completion.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "completion": [" blue.", " in the sky."],
})

dataset = dataset.remove_columns("completion")
>>> dataset[0]
{'prompt': 'The sky is'}

Dari preferensi dengan prompt implisit ke dataset pemodelan bahasa

Untuk mengonversi dataset preferensi dengan prompt implisit menjadi dataset pemodelan bahasa, hapus kolom yang ditolak, dan ganti nama kolom "chosen" menjadi "text".

from datasets import Dataset

dataset = Dataset.from_dict({
    "chosen": ["The sky is blue.", "The sun is in the sky."],
    "rejected": ["The sky is green.", "The sun is in the sea."],
})

dataset = dataset.rename_column("chosen", "text").remove_columns("rejected")
>>> dataset[0]
{'text': 'The sky is blue.'}

Dari preferensi dengan prompt implisit ke dataset prompt-pelengkapan

Untuk mengonversi dataset preferensi dengan prompt implisit menjadi dataset prompt-completion, ekstrak prompt dengan extract_prompt(), hapus yang ditolak, dan ganti nama kolom "chosen" menjadi "completion".

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})
dataset = dataset.map(extract_prompt).remove_columns("rejected").rename_column("chosen", "completion")
>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], 'completion': [{'role': 'assistant', 'content': 'It is blue.'}]}

Dari preferensi dengan prompt implisit ke dataset hanya prompt

Untuk mengonversi dataset preferensi dengan prompt implisit menjadi dataset hanya prompt, ekstrak prompt dengan extract_prompt(), dan hapus rejected dan chosen.

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})
dataset = dataset.map(extract_prompt).remove_columns(["chosen", "rejected"])
>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}]}

Dari dataset preferensi prompt implisit ke eksplisit

Untuk mengonversi dataset preferensi dengan prompt implisit menjadi dataset preferensi dengan prompt eksplisit, ekstrak prompt dengan extract_prompt().

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = dataset.map(extract_prompt)
>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}],
 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]}

Dari preferensi dengan prompt implisit ke dataset preferensi tidak berpasangan

Untuk mengonversi dataset preferensi dengan prompt implisit menjadi dataset preferensi tanpa pasangan, ekstrak prompt dengan extract_prompt(), dan hapus pasangan dataset dengan unpair_preference_dataset().

from datasets import Dataset
from trl import extract_prompt, unpair_preference_dataset

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = dataset.map(extract_prompt)
dataset = unpair_preference_dataset(dataset)
>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'completion': [{'role': 'assistant', 'content': 'It is blue.'}],
 'label': True}

Perlu diingat bahwa penyelesaian "chosen" dan "rejected" dalam dataset preferensi bisa sama-sama baik atau buruk. Sebelum menerapkan unpair_preference_dataset(), pastikan bahwa semua penyelesaian "chosen" dapat diberi label baik dan semua penyelesaian "rejected" sebagai buruk. Hal ini dapat dipastikan dengan memeriksa penilaian absolut dari setiap penyelesaian, misalnya dari model reward.

Dari dataset preferensi ke dataset pemodelan bahasa

Untuk mengubah dataset preferensi menjadi dataset pemodelan bahasa, hapus yang ditolak, lalu gabungkan prompt dan yang dipilih ke dalam kolom "text".

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

def concat_prompt_chosen(example):
    return {"text": example["prompt"] + example["chosen"]}

dataset = dataset.map(concat_prompt_chosen, remove_columns=["prompt", "chosen", "rejected"])
>>> dataset[0]
{'text': 'The sky is blue.'}

Dari dataset preferensi ke dataset prompt-pelengkapan

Untuk mengubah dataset preferensi menjadi dataset prompt-completion, hapus kolom yang ditolak, dan ganti nama kolom "chosen" menjadi "completion".

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

dataset = dataset.remove_columns("rejected").rename_column("chosen", "completion")
>>> dataset[0]
{'prompt': 'The sky is', 'completion': ' blue.'}

Dari preferensi ke dataset hanya-prompt

Untuk mengonversi dataset preferensi menjadi dataset hanya-prompt, hapus rejected dan chosen.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

dataset = dataset.remove_columns(["chosen", "rejected"])
>>> dataset[0]
{'prompt': 'The sky is'}

Dari dataset preferensi prompt eksplisit ke implisit

Untuk mengubah dataset preferensi dengan prompt eksplisit menjadi dataset preferensi dengan prompt implisit, gabungkan prompt ke chosen dan rejected, lalu hapus prompt.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": "What color is the sky?"}],
        [{"role": "user", "content": "Where is the sun?"}],
    ],
    "chosen": [
        [{"role": "assistant", "content": "It is blue."}],
        [{"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "assistant", "content": "It is green."}],
        [{"role": "assistant", "content": "In the sea."}],
    ],
})

def concat_prompt_to_completions(example):
    return {"chosen": example["prompt"] + example["chosen"], "rejected": example["prompt"] + example["rejected"]}

dataset = dataset.map(concat_prompt_to_completions, remove_columns="prompt")
>>> dataset[0]
{'chosen': [{'role': 'user', 'content': 'What color is the sky?'}, {'role': 'assistant', 'content': 'It is blue.'}],
 'rejected': [{'role': 'user', 'content': 'What color is the sky?'}, {'role': 'assistant', 'content': 'It is green.'}]}

Dari preferensi ke dataset preferensi tak berpasangan

Untuk mengonversi dataset menjadi dataset preferensi yang tidak berpasangan, pisahkan dataset tersebut dengan unpair_preference_dataset().

from datasets import Dataset
from trl import unpair_preference_dataset

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": "What color is the sky?"}],
        [{"role": "user", "content": "Where is the sun?"}],
    ],
    "chosen": [
        [{"role": "assistant", "content": "It is blue."}],
        [{"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "assistant", "content": "It is green."}],
        [{"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = unpair_preference_dataset(dataset)
>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'completion': [{'role': 'assistant', 'content': 'It is blue.'}],
 'label': True}

Perlu diingat bahwa penyelesaian "chosen" dan "rejected" dalam dataset preferensi bisa sama-sama baik atau buruk. Sebelum menerapkan unpair_preference_dataset(), pastikan bahwa semua penyelesaian "chosen" dapat diberi label baik dan semua penyelesaian "rejected" sebagai buruk. Hal ini dapat dipastikan dengan memeriksa penilaian absolut dari setiap penyelesaian, misalnya dari model reward.

Dari dataset preferensi tidak berpasangan ke dataset pemodelan bahasa

Untuk mengubah dataset preferensi tidak berpasangan menjadi dataset pemodelan bahasa, gabungkan prompt dengan penyelesaian yang baik ke dalam kolom "text", lalu hapus kolom prompt, completion, dan label.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

def concatenate_prompt_completion(example):
    return {"text": example["prompt"] + example["completion"]}

dataset = dataset.filter(lambda x: x["label"]).map(concatenate_prompt_completion).remove_columns(["prompt", "completion", "label"])
>>> dataset[0]
{'text': 'The sky is blue.'}

Dari preferensi yang tidak berpasangan ke dataset prompt-selesai

Untuk mengubah dataset preferensi tanpa pasangan menjadi dataset prompt-completion, saring label yang baik, lalu hapus kolom label.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

dataset = dataset.filter(lambda x: x["label"]).remove_columns(["label"])
>>> dataset[0]
{'prompt': 'The sky is', 'completion': ' blue.'}

Dari dataset preferensi tidak berpasangan ke dataset hanya prompt

Untuk mengonversi dataset preferensi yang tidak berpasangan menjadi dataset hanya-prompt, hapus kolom completion dan label.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

dataset = dataset.remove_columns(["completion", "label"])
>>> dataset[0]
{'prompt': 'The sky is'}

Dataset visi

Beberapa trainer juga mendukung fine-tuning model vision-language (VLM) menggunakan pasangan gambar-teks. Dalam skenario ini, disarankan untuk menggunakan format percakapan, karena setiap model menangani placeholder gambar dalam teks dengan cara yang berbeda.

Dataset visual percakapan berbeda dari dataset percakapan standar dalam dua hal utama:

  1. Dataset harus berisi kunci images dengan data gambar (sebagai daftar gambar PIL) atau image dengan satu gambar PIL.
  2. Field "content" dalam pesan harus berupa daftar kamus, di mana setiap kamus menentukan jenis data: "image" atau "text".

Contoh:

# Textual dataset:
"content": "What color is the sky?"

# Vision dataset:
"content": [
    {"type": "image"},
    {"type": "text", "text": "What color is the sky in the image?"}
]

Salah satu contoh dataset visi percakapan adalah openbmb/RLAIF-V-Dataset. Di bawah ini adalah tampilan tertanam dari data pelatihan dataset tersebut, yang memungkinkan Anda menjelajahinya secara langsung:

Mencampur data teks saja dan data vision-language dalam dataset dimungkinkan, tetapi memerlukan transformers versi 4.57.0 atau lebih baru. Contoh:

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What color is the sky in the image?"}]}],
        [{"role": "user", "content": [{"type": "text", "text": "What is the capital of France?"}]}],
    ],
    "completion": [
        [{"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]}],
        [{"role": "assistant", "content": [{"type": "text", "text": "Paris."}]}],
    ],
    "images": [
        [PIL.Image.open("path/to/sky_image1.png")],
        [],
    ],
})
Update on GitHub