ఇక్కడ, chosen ప్రస్తుత మూల్యాంకన ప్రమాణాల కింద మరింత అనుకూలమైన సమాధానాన్ని సూచిస్తుంది.

ప్రాధాన్యత డేటా సాధారణంగా ఈ క్రింది ప్రక్రియ ప్రకారం నిర్మించబడుతుంది:

1. నిజమైన వ్యాపారాలు లేదా పరీక్ష సమూహాల నుండి Promptsను సిద్ధం చేయడం;
2. ప్రస్తుత మోడల్, విభిన్న సంస్కరణల మోడల్ లేదా విభిన్న నమూనా పారామితులను ఉపయోగించి ఒకే Prompt కోసం అనేక అభ్యర్థి సమాధానాలను జనరేట్ చేయడం;
3. ఏకీకృత మూల్యాంకన ప్రమాణాల ప్రకారం, లేబులర్లు సమాధానాలను జతలుగా పోల్చడం లేదా పూర్తి క్రమం ఇవ్వడం;
4. క్రమ ఫలితాలను ప్రాధాన్య మరియు అప్రాధాన్య సమాధానాలతో కూడిన డేటా జతలుగా మార్చడం;
5. లేబులింగ్ స్థిరత్వాన్ని తనిఖీ చేసి, నిర్ణయించలేని నమూనాలను సమీక్షకులకు అప్పగించడం.

ఒకే ఇన్పుట్ A, B, C మరియు D నాలుగు సమాధానాలను జనరేట్ చేస్తే, అనేక ప్రాధాన్యత జతలుగా మార్చవచ్చు.

ప్రాధాన్యత లేబులింగ్ కొన్ని ఉపరితల కారకాలచే ప్రభావితమవుతుంది.

రివార్డ్ మోడల్ సమాధానాలకు స్కోర్ ఎలా ఇవ్వడం నేర్చుకుంటుంది?

ప్రాధాన్యత డేటా ఒకే Prompt కింద ఏ సమాధానం మెరుగు అనేదాన్ని chosen మరియు rejected మధ్య సాపేక్ష సంబంధంగా సూచిస్తుంది. రివార్డ్ మోడల్ పాత్ర ఏమిటంటే, ఈ ప్రాధాన్యత డేటాను ఉపయోగించి స్వయంచాలక స్కోరింగ్ ఫలనాన్ని నేర్చుకోవడం.

రివార్డ్ మోడల్ రెండు సమాధానాలకు విడిగా ఎన్ని పాయింట్లు రావాలో తెలుసుకోవాల్సిన అవసరం లేదు.

Prompt + chosen   → rchosen
Prompt + rejected → rrejected

ఇక్కడ, rchosen మరియు rrejected రివార్డ్ మోడల్ అవుట్‌పుట్ చేసిన రెండు స్కేలర్ స్కోర్లు. శిక్షణ లక్ష్యం ప్రాధాన్య సమాధానం స్కోర్ అప్రాధాన్య సమాధానం కంటే ఎక్కువగా ఉండటం.

\mathcal{L} = -\log \sigma\left(r_{\text{chosen}} - r_{\text{rejected}}\right)

ఇక్కడ, r_chosen మరియు r_rejected ప్రాధాన్య మరియు అప్రాధాన్య సమాధానాలపై రివార్డ్ మోడల్ మూల్యాంకనాలను సూచిస్తాయి.

రివార్డ్ మోడల్ సాధారణంగా భాషా మోడల్‌ను పునాదిగా ఉపయోగించి, స్కేలర్ స్కోర్ అవుట్‌పుట్ స్కోరింగ్ హెడ్‌ను జోడిస్తుంది.

రివార్డ్ మోడల్ ఏమి నేర్చుకుంటుందో ముందుగా నిర్మించిన ప్రాధాన్యత డేటాపై చాలా వరకు ఆధారపడి ఉంటుంది.

రివార్డ్ మోడల్ స్వయంగా మూల్యాంకనం మాత్రమే చేస్తుంది, భాషా మోడల్‌ను నేరుగా సవరించదు.

RLHF, మానవ ప్రతిస్పందన శిక్షణలో ఎలా పాల్గొంటుంది?

RLHF (Reinforcement Learning from Human Feedback) సాధారణంగా మానవ ప్రతిస్పందన ఆధారంగా రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ అని పిలుస్తారు.

క్లాసిక్ RLHF సాధారణంగా మూడు దశలను కలిగి ఉంటుంది:

1. మానవ ప్రదర్శన డేటాను సేకరించి, SFT ద్వారా సూచనలను అనుసరించగల ప్రారంభ విధాన మోడల్‌ను పొందడం;
2. ఒకే Prompt కింద అనేక సమాధానాలకు మానవ క్రమం ఇవ్వడం, ఈ ప్రాధాన్యత డేటాను ఉపయోగించి రివార్డ్ మోడల్‌ను శిక్షణ ఇవ్వడం;
3. విధాన మోడల్ కొత్త సమాధానాలను జనరేట్ చేయనివ్వడం, రివార్డ్ మోడల్ స్కోర్ ఇవ్వడం, ఆపై PPO వంటి రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ అల్గారిథమ్‌లతో విధాన మోడల్‌ను నవీకరించడం.

క్లాసిక్ RLHF మార్గం మూడు వరుస దశలుగా విభజించబడింది. మొదటి దశలో లేబులర్లు ప్రదర్శన సమాధానాలను రాసి, ఈ డేటాతో SFT పూర్తి చేస్తారు.

ఈ ప్రక్రియను రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ భావనలో ఉంచితే, భాషా మోడల్ విధాన మోడల్.

RLHF లో, రివార్డ్ మోడల్ సాధారణంగా సమాధానం ముగిసిన తర్వాత మొత్తం స్కోర్ ఇస్తుంది.

PPO, మోడల్‌ను రివార్డ్ ఆధారంగా సవరించడం

PPO (Proximal Policy Optimization) ఒక సాధారణ రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ అల్గారిథమ్. ఇది ప్రతి పారామితి నవీకరణ యొక్క పరిమాణాన్ని పరిమితం చేస్తూ రివార్డ్‌ను పెంచే లక్ష్యంతో పాటు పనిచేస్తుంది.

PPO కొత్త విధానం మరియు పాత విధానం ఒకే టోకెన్‌కు ఇచ్చే సంభావ్యతను పోల్చాలి.

r_t(\theta)
=
\frac{\text{Probability of the new policy selecting the current token}}
{\text{Probability of the old policy selecting the current token}}

ఇక్కడ, rₜ లెక్కించిన స్కోర్‌ను సూచిస్తుంది,

θ సవరించాల్సిన మోడల్‌ను సూచిస్తుంది.

rₜ 1 కు సమీపంలో ఉంటే, కొత్త మరియు పాత విధానాల మధ్య తేడా తక్కువగా ఉంటుంది.

ఎడమ వైపు ప్రయోజనం ధనాత్మకంగా ఉన్న సందర్భాన్ని సూచిస్తుంది.

ఒక సాధారణ పెద్ద మోడల్ PPO శిక్షణకు అనేక భాగాలను ఏకకాలంలో నిర్వహించాలి.

GRPO, ఒకే ప్రశ్నకు అనేకసార్లు సమాధానం ఇవ్వండి, ఆపై స్కోర్లను పోల్చండి

GRPO (Group Relative Policy Optimization) PPO యొక్క వేరియేషన్. ఇది విలువ మోడల్‌ను విడిగా శిక్షణ ఇవ్వకుండా, ఒకే Prompt కింద అనేక సమాధానాల సాపేక్ష పోలిక ద్వారా ఆదాయాన్ని అంచనా వేస్తుంది.

వ్యవస్థ ముందుగా ఈ సమూహం యొక్క ఆదాయాల సగటు మరియు ప్రామాణిక విచలనాన్ని లెక్కిస్తుంది.

PPO తో పోల్చినప్పుడు, GRPO విలువ మోడల్ శిక్షణ ఖర్చులను తగ్గిస్తుంది.

DPO, ప్రాధాన్యతలను నష్ట ఫలనంలో వ్రాయడం

DPO (Direct Preference Optimization) మరొక సాధారణ ప్రాధాన్యత సమన్వయ పద్ధతి. దీని పేపర్ శీర్షికలో, రచయితలు స్పష్టంగా చెప్పారు, ప్రాధాన్యత మోడల్ అవసరం లేకపోవచ్చు.

పై చిత్రం క్లాసిక్ RLHF మార్గం మరియు DPO ను పోల్చింది.

మొదటి దశ, ప్రాధాన్యత ధనాత్మక మరియు ఋణాత్మక ఉదాహరణల నమూనాలను రూపొందించడం.

రెండవ దశ, రూపొందించిన నష్ట ఫలనం ఆధారంగా, పోల్చడం నేర్చుకునే సంబంధిత పద్ధతులను ఉపయోగించి.

DPO శిక్షణ రూపం సాధారణ SFT కు సమీపంగా ఉంటుంది.

RLHF, PPO, GRPO మరియు DPO, చివరికి ఎలా వేరు చేయాలి మరియు ఎంచుకోవాలి?

ముందుగా RLHF, PPO, GRPO మరియు DPO యొక్క ప్రాథమిక సూత్రాలు మరియు శిక్షణ పద్ధతులను వివరించాము.

సమగ్రంగా చూస్తే, RLHF, PPO, GRPO మరియు DPO అన్నీ పెద్ద మోడల్ ప్రాధాన్యత సమన్వయంతో సంబంధం కలిగి ఉన్నాయి, కానీ అవి పరిష్కరించే సమస్యలు పూర్తిగా ఒకేలా ఉండవు.

వాస్తవ అనువర్తనంలో, పద్ధతి ఎంపిక మోడల్ ప్రస్తుతం లోపించిన సామర్థ్యం నుండి ప్రారంభించాలి.

ms-swift తో DPO మరియు GRPO ప్రయత్నించండి

ముందుగా ప్రాధాన్యత సమన్వయం మరియు రీన్ఫోర్స్‌మెంట్ లెర్నింగ్ ప్రాథమిక సూత్రాలను వివరించాము, ఇప్పుడు ms-swift తో రెండు నిర్దిష్ట ప్రయోగాలను పూర్తి చేద్దాం.

ప్రయోగ సిద్ధాంతం

ఈ ప్రయోగం ModelScope Notebook యొక్క ఏకైక GPU వాతావరణంలో పూర్తయింది.

ఇక్కడి శిక్షణ పరిమాణం చిన్నది, ఇది పూర్తి ప్రక్రియను ప్రదర్శించడానికి మాత్రమే ఉద్దేశించబడింది.

1. రన్నింగ్ వాతావరణాన్ని తనిఖీ చేయండి.

అనుబంధ Notebook తెరిచిన తర్వాత, GPU అందుబాటులో ఉందా మరియు ప్రస్తుత కెర్నల్ ఉపయోగిస్తున్న సాఫ్ట్‌వేర్ వెర్షన్‌లను తనిఖీ చేయండి.

2. మోడల్ మరియు రన్నింగ్ డైరెక్టరీలను సిద్ధం చేయండి.

పబ్లిక్ సిద్ధాంత భాగం కాష్ డైరెక్టరీ మరియు ఈ ప్రయోగ డైరెక్టరీని సృష్టిస్తుంది.

MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
MODEL_REVISION = "master"
DPO_DATA_ID = "AI-ModelScope/hh_rlhf_cn"
GRPO_DATA_ID = "AI-ModelScope/gsm8k"
SEED = 42

MODEL_DIR = Path(snapshot_download(
    MODEL_ID,
    revision=MODEL_REVISION,
    cache_dir=str(CACHE_DIR / "models"),
    allow_file_pattern=[
        "*.json", "*.safetensors", "*.txt", "*.model", "*.tiktoken"
    ],
).resolve()

ఇక్కడ, snapshot_download ModelScope నుండి వచ్చింది, CACHE_DIR పబ్లిక్ సిద్ధాంత కోడ్ ద్వారా సృష్టించబడింది.

DPO ప్రాధాన్యత డేటాను సిద్ధం చేయడం

DPO కు ఒకే సందర్భం కింద రెండు అభ్యర్థి సమాధానాలు అవసరం.

1. ms-swift ఉపయోగించే డేటా ఫార్మాట్‌కు మార్చడం.

ms-swift ఉపయోగించే ప్రాధాన్యత నమూనా నిర్మాణం ఈ క్రింది విధంగా ఉంటుంది.

{
  "messages": [
    {"role": "user", "content": "The same question"},
    {"role": "assistant", "content": "Preferred answer"}
  ],
  "rejected_response": "Non-preferred answer"
}

SFT నమూనాతో పోల్చినప్పుడు, ఇక్కడ rejected_response జోడించబడింది.

def convert_dpo(row):
    role_map = {
        "human": "user", "user": "user",
        "assistant": "assistant", "system": "system"
    }
    context = [
        {"role": role_map[m["role"]], "content": m["text"].strip()}
        for m in row["context"]
    ]
    chosen = row["chosen"]["text"].strip()
    rejected = row["rejected"]["text"].strip()

    assert context and context[-1]["role"] == "user"
    assert chosen and rejected and chosen != rejected
    assert all(m["content"] for m in context)
    if context[0]["role"] != "system":
        context.insert(0, {"role": "system", "content": GENERAL_SYSTEM})

    return {
        "messages": context + [{"role": "assistant", "content": chosen}],
        "rejected_response": rejected,
    }

2. డేటాను శుభ్రం చేసి విభజించడం.

ఈ ప్రయోగంలో ప్రాధాన్య మరియు అప్రాధాన్య సమాధానాల పొడవును విడిగా లెక్కించి, రెండూ 1024 టోకెన్ల కంటే ఎక్కువ లేని నమూనాలను మాత్రమే నిల్వ చేస్తుంది.

DPO శిక్షణను ప్రారంభించడం

శిక్షణ ముందు, ప్రారంభ మోడల్ టెస్ట్ సెట్‌పై పనితీరును నమోదు చేయండి.

def dpo_evaluate(adapter=None):
    def action(model):
        rows = []
        for index, row in enumerate(dpo_test):
            context = row["messages"][:-1]
            lp_chosen = response_logp(model, context, row["messages"][-1]["content"])
            lp_rejected = response_logp(model, context, row["rejected_response"])
            rows.append({"sample_id": index, "chosen_logp": lp_chosen,
                         "rejected_logp": lp_rejected, "gap": lp_chosen - lp_rejected})
        # Generate only 4 for close reading; the remaining candidate pairs still participate in probability diagnosis.
        generations = [{"sample_id": i, "context": dpo_test[i]["messages"][:-1],
                        "response": generate_one(model, dpo_test[i]["messages"][:-1])}
                       for i in range(min(4, len(dpo_test)]
        return rows, generations
    return with_local_model(action, adapter)

dpo_before, dpo_before_text = dpo_evaluate()

DPO శిక్షణ సంబంధిత దశలు ఈ క్రింది విధంగా ఉన్నాయి:

1. శిక్షణ పారామితులను సెట్ చేయండి.

రెండు ప్రయోగాలు common_options() ద్వారా పబ్లిక్ కాన్ఫిగరేషన్‌ను పునఃఉపయోగిస్తాయి.

DPO_OUTPUT = RUN_DIR / "dpo"
DPO_BETA = 0.1
dpo_options = common_options() | {
    "rlhf_type": "dpo", "loss_type": "sigmoid", "beta": DPO_BETA,
    "dataset": str(DPO_PATHS["train"]),
    "val_dataset": str(DPO_PATHS["val"]),
    "output_dir": str(DPO_OUTPUT), "max_length": 1024,
    "truncation_strategy": "delete", "max_steps": 20,
    "learning_rate": 5e-5, "lr_scheduler_type": "cosine",
    "warmup_ratio": 0.1,
    "per_device_train_batch_size": 1,
    "per_device_eval_batch_size": 1,
    "gradient_accumulation_steps": 8,
    "eval_strategy": "steps", "eval_steps": 10,
    "save_strategy": "steps", "save_steps": 10,
}
train_swift(dpo_options, RUN_DIR / "dpo_train.log")
DPO_ADAPTER = latest_adapter(DPO_OUTPUT)

ప్రధాన పారామితుల అర్థాలు ఈ క్రింది విధంగా ఉన్నాయి:

2. శిక్షణ అవుట్‌పుట్‌ను చూడండి.

శిక్షణ ప్రారంభమైన తర్వాత, ms-swift నష్టం, అంతర్గత రివార్డ్లు, ధృవీకరణ సూచికలు మరియు చెక్‌పాయింట్ సేవ్ స్థానాన్ని అవుట్‌పుట్ చేస్తుంది.

లాగ్‌లోని rewards/chosen మరియు rewards/rejected విధానం మరియు రిఫరెన్స్ విధానం యొక్క లాగ్ సంభావ్యత తేడా ఆధారంగా లెక్కించబడిన అంతర్గత రివార్డ్లు.

DPO శిక్షణ ముందు మరియు తర్వాత ఫలితాలను పోల్చడం

DPO అడాప్టర్‌ను లోడ్ చేసిన తర్వాత, అదే టెస్ట్ డేటాను ఉపయోగించి మూల్యాంకనం చేయండి.

dpo_after, dpo_after_text = dpo_evaluate(DPO_ADAPTER)
before_df = pd.DataFrame(dpo_before).set_index("sample_id")
after_df = pd.DataFrame(dpo_after).set_index("sample_id")

comparison = pd.DataFrame({
    "before_gap": before_df["gap"],
    "after_gap": after_df["gap"],
    "relative_dpo_margin": DPO_BETA * (
        after_df["gap"] - before_df["gap"]
    ),
})

ఇక్కడ, gap ప్రాధాన్య సమాధానం యొక్క క్రమ లాగ్ సంభావ్యత మైనస్ అప్రాధాన్య సమాధానం యొక్క క్రమ లాగ్ సంభావ్యతకు సమానం.

ఈ ప్రయోగ ఫలితాలు ఈ క్రింది చిత్రంలో చూపబడ్డాయి:

శిక్షణ రౌండ్లు తక్కువగా ఉన్నందున, కొన్ని నమూనాల తేడా పెద్దది కావచ్చు, కానీ ఋణాత్మకం నుండి ధనాత్మకంగా మారలేదు.

User: What methods can I use to strengthen my home network signal? My laptop has trouble connecting to the network router!

ప్రారంభ మోడల్ సమాధానం ఈ క్రింది కంటెంట్‌ను కలిగి ఉంటుంది, మూలాన్ని ఉటంకించి నిల్వ చేస్తుంది:

1. **Use a wireless router**: If you have multiple devices at home that need internet access, consider installing a wireless router. This will let you connect to the internet via Wi-Fi.

DPO శిక్షణ తర్వాత సమాధానం ఈ క్రింది వాటిని కలిగి ఉంటుంది:

3. **Restart the router**: Sometimes a simple restart can resolve some network connection issues. Please follow the router's instructions.

పూర్తి అవుట్‌పుట్ నుండి, ప్రారంభ సమాధానం ఎక్కువగా పరికరాలను మార్చడం లేదా జోడించడాన్ని సూచిస్తుంది, శిక్షణ తర్వాత నెట్‌వర్క్ సెట్టింగ్లు, డ్రైవర్లు మరియు రీస్టార్ట్ చుట్టూ సమాధానాలను సంఘటిస్తుంది.

GRPO డేటా మరియు రివార్డ్ ఫలనాన్ని సిద్ధం చేయడం

DPO డేటాలో ఇప్పటికే ఇచ్చిన రెండు సమాధానాలను ఉపయోగిస్తుంది, GRPO కు శిక్షణ సమయంలో అభ్యర్థి సమాధానాలను జనరేట్ చేయాలి.

1. ప్రశ్న మరియు ప్రామాణిక సమాధానాన్ని వేరు చేయండి.

అసలు GSM8K డేటా question మరియు answer అనే రెండు ఫీల్డ్‌లను కలిగి ఉంటుంది.

def convert_grpo(row):
    question = row["question"].strip()
    original_answer = row["answer"].strip()
    assert question and "####" in original_answer
    answer = parse_numeric(original_answer.rsplit("####", 1)[-1])
    assert answer is not None
    return {
        "messages": [
            {"role": "system", "content": MATH_SYSTEM},
            {"role": "user", "content": question},
        ],
        "solution": str(answer),
    }

మార్చిన messages లో ప్రామాణిక పరిష్కార ప్రక్రియ లేదు, మోడల్ అనుకరించడానికి assistant సమాధానం కూడా లేదు.

2. సరైనత రివార్డ్ మరియు ఫార్మాట్ రివార్డ్‌ను నిర్వచించండి.

ఈ ప్రయోగం యొక్క మొత్తం రివార్డ్ ఈ క్రింది విధంగా ఉంటుంది:

Total reward = correctness reward + 0.1 × format reward

సరైనత రివార్డ్ మోడల్ అవుట్‌పుట్ నిర్దిష్ట లేబుల్ ఫార్మాట్‌ను అనుసరించాలని, మరియు లేబుల్‌లోని సంఖ్య solution కు సమానంగా ఉండాలని అవసరం పెడుతుంది.

def extract_answer(completion):
    if not isinstance(completion, str):
        return None
    if completion.count("<answer>") != 1 or completion.count("</answer>") != 1:
        return None
    match = re.search(r"<answer>\s*([^<>]+?)\s*</answer>\s*\Z", completion)
    return parse_numeric(match.group(1) if match else None

class Chapter10Accuracy(ORM):
    def __call__(self, completions, solution, **kwargs):
        if len(completions) != len(solution):
            raise ValueError("Number of candidate answers does not match solutions.")
        rewards = []
        for text, gold in zip(completions, solution):
            expected = parse_numeric(gold)
            if expected is None:
                raise ValueError(f"Invalid gold answer format: {gold!r}")
            predicted = extract_answer(text)
            rewards.append(float(predicted is not None and predicted == expected)
        return rewards

class Chapter10Format(ORM):
    def __call__(self, completions, **kwargs):
        return [float(extract_answer(text) is not None) for text in completions]

ఇక్కడ, completions అనేది మోడల్ జనరేట్ చేసిన సమాధానాల సమూహం, solution ట్రైనర్ అందించిన అనుగుణమైన ప్రామాణిక సమాధానం.

రివార్డ్ క్లాస్ నమోదు చేయాలి, ఈ శిక్షణ ట్రైనర్ ఉపయోగించే రివార్డ్ ప్లగిన్ ఈ క్రింది విధంగా ఉంటుంది:

orms["chapter10_accuracy"] = Chapter10Accuracy
orms["chapter10_format"] = Chapter10Format

Notebook పూర్తి ప్లగిన్‌ను plugins/chapter10_rewards.py గా సేవ్ చేస్తుంది.

3. ముందుగా రివార్డ్ ఫలనాన్ని తనిఖీ చేసి, ఆపై శిక్షణ ప్రారంభించండి.

ఇవి కొన్ని ఫలితాల రివార్డ్ లెక్కింపు ఫలితాలు:

ఈ ప్రయోగంలో ఉపయోగించిన రివార్డ్ ఫలనం లెక్కింపు పద్ధతి ప్రకారం, సాధారణ వచనం The answer is 12. సరైన సంఖ్యను కలిగి ఉన్నప్పటికీ, ఫార్మాట్ అవసరాలను నెరవేర్చలేదు.

GRPO శిక్షణను ప్రారంభించి లాగ్‌ను గమనించండి

డేటా మరియు రివార్డ్ ఫలనం సిద్ధాంతం తర్వాత, సంబంధిత ప్రయోగాల సెట్టింగ్ మరియు శిక్షణ పనులను పూర్తి చేయండి.

1. జనరేషన్ సమూహం మరియు శిక్షణ పారామితులను సెట్ చేయండి.

ఈ ప్రయోగం ఒకే ప్రశ్నకు 4 అభ్యర్థి సమాధానాలను జనరేట్ చేస్తుంది.

ఈ క్రింది GRPO ప్రయోగ కాన్ఫిగరేషన్. GRPO_PATHS, PLUGIN_PATH మరియు సంబంధిత కాన్ఫిగరేషన్ మరియు కంటెంట్.

GRPO_OUTPUT = RUN_DIR / "grpo"
grpo_options = common_options() | {
    "rlhf_type": "grpo", "loss_type": "grpo",
    "dataset": str(GRPO_PATHS["train"]),
    "val_dataset": str(GRPO_PATHS["val"]),
    "output_dir": str(GRPO_OUTPUT),
    "external_plugins": str(PLUGIN_PATH),
    "reward_funcs": ["chapter10_accuracy", "chapter10_format"],
    "reward_weights": [1.0, 0.1], "remove_unused_columns": False,
    "num_generations": 4, "generation_batch_size": 4,
    "per_device_train_batch_size": 1,
    "gradient_accumulation_steps": 4,
    "per_device_eval_batch_size": 4, "num_generations_eval": 4,
    "max_length": 512, "max_completion_length": 256,
    "truncation_strategy": "left",
    "max_steps": 10, "learning_rate": 1e-5,
    "lr_scheduler_type": "constant", "warmup_ratio": 0.0,
    "beta": 0.04, "num_iterations": 1,
    "temperature": 0.9, "top_p": 0.95,
    "use_vllm": False, "log_completions": True,
    "eval_strategy": "steps", "eval_steps": 5,
    "save_strategy": "steps", "save_steps": 5,
}
train_swift(grpo_options, RUN_DIR / "grpo_train.log")
GRPO_ADAPTER = latest_adapter(GRPO_OUTPUT)

సమూహ పరిమాణం మరియు జనరేషన్ బ్యాచ్ సహకరించే విధంగా సెట్ చేయాలి.

2. శిక్షణ లాగ్‌ను చదవండి.

GRPO శిక్షణ నష్టం గణిత ప్రశ్న సరైన రేటు కాదు.

చిత్రం నుండి, శిక్షణ 2వ దశ నుండి సున్నా కాని సమూహం లోపల ఆదాయ తేడాలను ప్రదర్శిస్తుంది.

పూర్తి మూల్యాంకనం మరియు ఫలితాల విశ్లేషణ

శిక్షణ లాగ్ శిక్షణ ప్రక్రియలో నమూనా చేయబడిన అభ్యర్థులను ప్రతిబింబిస్తుంది, చివరికి స్వతంత్ర టెస్ట్ సెట్‌తో మోడల్ పనితీరును పోల్చాలి.

ప్రారంభ ఫలితాలు శిక్షణ ముందు grpo_evaluate() ద్వారా సేవ్ చేయబడతాయి.

grpo_after = grpo_evaluate(GRPO_ADAPTER)
grpo_summary = pd.DataFrame([
    {
        "Model": name,
        "Strict answer accuracy": np.mean([r["correct"] for r in rows]),
        "Correct question count": int(sum(r["correct"] for r in rows),
        "Valid format ratio": np.mean([r["format_ok"] for r in rows]),
        "Format-passing question count": int(sum(r["format_ok"] for r in rows),
        "Average total reward": np.mean([r["total_reward"] for r in rows]),
        "Test question count": len(rows),
    }
    for name, rows in [
        ("Initial Instruct", grpo_before), ("GRPO LoRA", grpo_after)
    ]
])
display(grpo_summary)

ఈ పూర్తి మూల్యాంకన ఫలితాలు ఈ క్రింది విధంగా ఉన్నాయి:

పై పూర్తి మూల్యాంకన ఫలితాల ఆధారంగా, మోడల్ ఫార్మాట్ చెల్లుబాటు అయ్యే నిష్పత్తి 89.16% నుండి 94.24%కి పెరిగింది.

ఈ అధ్యాయంలోని అన్ని ప్రయోగ డేటా మరియు కోడ్, https://modelscope.cn/gallery/liucong/8a5fefc5-6f90-42df-9a09-bc9781ed3da8 లో చూడవచ్చు.