Förstärkning av finjustering (RFT) med Azure OpenAI o4-mini (förhandsversion)

Förstärkning av finjustering (RFT) är en teknik för att förbättra resonemangsmodeller som o4-mini genom att träna dem genom en belöningsbaserad process i stället för att bara förlita sig på etiketterade data. Genom att använda feedback eller "belöningar" för att vägleda inlärningen hjälper RFT modeller att utveckla bättre resonemang och problemlösningsfärdigheter, särskilt i fall där märkta exempel är begränsade eller komplexa beteenden önskas.

Processen

Processen för finjustering av förstärkning (RFT) liknar övervakad finjustering (SFT) med några anmärkningsvärda skillnader:

• Systemmeddelanden för dataförberedelse stöds inte, och i stället för ett assistant meddelande är det slutliga meddelandet i dina träningsdata ett referenssvar.
• Modellval: endast o4-mini stöder RFT.
• Graderdefinition: RFT kräver användning av bedömare för att bedöma kvaliteten på din finjusterade modell och vägleda inlärning. Du kan använda strängkontroll, textlikhet eller modellbaserade bedömare – eller kombinera dem med en multivärderare.
• Utbildning: innehåller ytterligare parametrar: eval_samples, eval_interval, reasoning_effortoch compute_multiplier. Du har också möjlighet att pausa och återuppta jobb, så att du kan pausa träningen, inspektera kontrollpunkter och bara fortsätta om ytterligare utbildning behövs.
• Utvärdering: Förutom noggrannhet och förlust returnerar RFT genomsnittlig belöning, parsningfel och genomsnittligt antal tecken.

Under hela träningsprocessen itererar plattformen över datauppsättningen och genererar flera svar för varje fråga. Dessa svar utvärderas sedan av bedömaren och policy-gradient uppdateringar tillämpas baserat på de mottagna poängen. Den här cykeln upprepas tills träningsdata bearbetas helt eller jobbet stoppas vid en angiven kontrollpunkt, vilket i slutändan resulterar i en modell som finjusterats för önskat mått.

Men trots dessa skillnader finns det många likheter mellan SFT och RFT: dataförberedelse är nyckeln; serverlösa träningsjobb kan initieras via Foundry-användargränssnittet. och vi stöder standarddistributioner och globala standarddistributioner.

Krav för skapande av tränings- och utvärderingsfiler

Både tränings- och valideringsfiler krävs för att köra o4-mini RFT. o4-mini använder ett nytt dataformat för förstärkt finjustering. Dessa bör vara jsonl-filer, som vad som används för övervakad finjustering (SFT).

Varje rad i filen bör innehålla fältet meddelanden, med vissa skillnader jämfört med SFT:

• Systemmeddelanden stöds inte
• Det slutliga meddelandet måste vara från användaren, inte assistenten (vilket är fallet för SFT)
• Tools, response_formats, stöds
• Bilder/multimodala data stöds inte

Varje rad i JSONL-datafilen ska innehålla en meddelandematris, tillsammans med eventuella ytterligare fält som krävs för att bedöma utdata från modellen. Det här värdet måste vara ett giltigt JSON-objekt (till exempel dictionary eller lista; den specifika typen och strukturen är beroende av ditt valda bedömningssystem).

Exempel på träningsdata

Om vi ger modellen ett pussel att lösa i det nödvändiga RFT-träningsformatet skulle det vara följande:

"messages": [
    {
      "role": "user",
      "content": "You are a helpful assistant. Your task is to solve the following logic and puzzle quiz:\n\n2. In the expression 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 = 100, replace the asterisks with arithmetic operation signs to obtain a correct equation."
    }
  ],

  "solution": "Solution. 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 \\cdot 9 = 100.\n\nEvaluation. 12 points for the correct solution.",

  "final_answer": "1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 \\cdot 9 = 100"
}

Vi har expanderat texten ovan från en enda rad jsonlmed , så att du kan se de förväntade fälten: meddelanden, roll, innehåll och final_answer.

Datamängdsstorlek för RFT

Börja med en liten datamängd, bestående av flera dussin till några hundra exempel, för att utvärdera effekten av RFT innan du genomför en större datamängd. Av säkerhetsskäl måste träningsuppsättningen genomgå en automatiserad screeningprocess som initieras när ett finjusteringsjobb startas, i stället för vid filuppladdning. När en fil har godkänts kan den användas upprepade gånger utan fördröjning.

Exempel av hög kvalitet är viktiga, även i begränsade kvantiteter. Efter screening är en ökad datavolym fördelaktig, förutsatt att den håller hög kvalitet. Större datamängder tillåter användning av högre batchstorlekar, vilket i allmänhet förbättrar träningsstabiliteten.

Träningsfiler kan innehålla högst 50 000 exempel, medan testdatauppsättningar kan innehålla upp till 1 000 exempel. Båda typerna av datamängder är föremål för automatisk screening

Skapa finjusteringsjobb

Du kan skapa träningsjobb för o4-mini RFT i Azure AI Foundry på samma sätt som du finjusterar andra modeller: Välj finjustering i en region som stöds och välj o4-mini som basmodell.

Val av hyperparameter

Avsnittet hyperparametrar i förstärkningsmetoden stöder alla vanliga träningshyperparametrar (till exempel inlärningshastighet, antal epoker och batchstorlek) samt tre nya hyperparametrar:

Klassare

RFT är unikt eftersom det använder bedömare för att bedöma kvaliteten på en modells svar för att lära modellen att resonera. Till skillnad från SFT kommer det slutliga meddelandet inte från assistenten – i stället provar vi modellen och använder en väghyvel på varje exempel för att bedöma dess kvalitet. Sedan tränar vi baserat på dessa poäng för att förbättra modellens prestanda.

I praktiken är bedömare funktioner som jämför referenssvar från din träningsfil med det urvalda svaret.

Klass:

• Returnera flyttalsnummer mellan 0 och 1. Det kan vara bra att ge modellen partiell kredit för svar i stället för binärt 0/1.
• Bedömare är specificerade som JSON (se nedan)

Stödda bedömare

Vi stöder tre typer av bedömare: Strängkontroll, Textlikhet, Modellbedömare. Det finns också ett alternativ på multihyvlar att använda hyvlar i kombinationer.

String-check-grader

Använd dessa grundläggande strängåtgärder för att returnera en 0 eller 1.

Specifikation:

{
    "type": "string_check",
    "name": string,
    "operation": "eq" | "ne" | "like" | "ilike",
    "input": string,
    "reference": string,
}

Åtgärder som stöds:

• eq: Returnerar 1 om indata matchar referensen (skiftlägeskänsligt), 0 annars
• neq: Returnerar 1 om indata inte matchar referensen (skiftlägeskänsligt), 0 annars
• like: Returnerar 1 om indata innehåller referensen (skiftlägeskänslig), 0 annars
• ilike: Returnerar 1 om indata innehåller referensen (inte skiftlägeskänslig), 0 annars

Textlikhet

För att utvärdera hur nära den modellgenererade utdata är till referensen, poängsätts med olika utvärderingsmått.

Specifikation:

{
    "type": "text_similarity",
    "name": string,
    "input": string,
    "reference": string,
    "pass_threshold": number,
    "evaluation_metric": "fuzzy_match" | "bleu" | "gleu" | "meteor" | "rouge_1" | "rouge_2" | "rouge_3" | "rouge_4" | "rouge_5" | "rouge_l" 
}

Åtgärder som stöds:

• bleu – beräknar BLEU-poäng mellan strängar
• Fuzzy_match – fuzzy strängmatchning, använder rapidfuzz
• gleu – beräknar google BLEU-poäng mellan strängar
• meteor – beräknar METEOR-poäng mellan strängar
• rouge-* – enligt definitionen i python-biblioteket för rouge

Score Model (Poängmodell)

Det här är Modellbedömare där du kan använda LLM för att bedöma träningsresultat.

De modeller som vi stöder som betygsmodeller är:

• gpt-4o-2024-08-06
• o3-mini-2025-01-31

{
    "type": "score_model",
    "name": string,
    "input": Message[],
    "model": string,
    "pass_threshold": number,
    "range": number[],
    "sampling_params": {
        "seed": number,
        "top_p": number,
        "temperature": number,
        "max_completions_tokens": number,
        "reasoning_effort": "low" | "medium" | "high"
    }
}

Om du vill använda en poängmodellklassare är indata en lista över chattmeddelanden som var och en innehåller en roll och innehåll. Utdata från bedömaren kommer att begränsas till det angivna intervallet, och kommer standardvärdet att vara 0 för alla icke-numeriska resultat.

Anpassad kodklassare

Med anpassad kodklassare kan du köra godtycklig python-kod för att betygsätta modellutdata. Utvärderaren förväntar sig att en betygsfunktion finns som tar emot två argument och returnerar ett flyttal. Andra resultat (undantag, ogiltigt flyttalvärde osv.) markeras som ogiltiga och returnerar ett 0-betyg.

{
    "type": "python",
    "source": "def grade(sample, item):\n    return 1.0"
}

Tekniska begränsningar: Den uppladdade koden måste vara mindre än 256 kB. Den har ingen nätverksåtkomst. Själva klassificeringsprocessen får inte överstiga 2 minuter. Vid körning får du en gräns på 2 GB minne och 1 GB diskutrymme att använda. Det finns en gräns på 1 CPU-kärna – all användning över den här mängden resulterar i nedstrypning.

Multigrader

Ett multigrader-objekt kombinerar utdata från flera betygsättare för att skapa en sammanlagd poäng.

{  
"type": "multi",
 "graders": dict[str, Grader],
 "calculate_output": string, 
"invalid_grade": float
}

Åtgärder som stöds:

operatorer:

• + (tillägg)
• - (subtraktion)
• * (multiplikation)
• / (avdelning)
• ^ (ström)

Funktioner:

• min
• max
• abs
• floor
• ceil
• exp
• sqrt
• log

När du använder användargränssnittet kan du skriva en fråga och generera ett giltigt grader- och svarsformat i json efter behov. Grader är ett obligatoriskt fält som måste anges när du skickar ett finjusteringsjobb. Svarsformatet är valfritt.

Här är ett exempel på en bedömningsmall för varje kategori.

string-check-grader – använd enkla strängoperationer för att returnera en 0 eller 1.

Exempel:

{
"name": "string_check_sample_grader",
 "type": "string_check", 
"input": "{{item.reference_answer}}",
 "reference": "{{sample.output_text}}", 
"operation": "eq"
}

Textlikhet – Utvärdera hur nära modellgenererade utdata är referensen, poängsatt med olika utvärderingsmått.

{
"name": "text_similarity_sample_grader",
 "type": "text_similarity",
 "input": "{{item.reference_answer}}",
 "reference": "{{sample.output_text}}", "evaluation_metric":"fuzzy_match"
}

Poängmodell – Det här är Modellklassare där du kan använda LLM för att betygsätta träningsutdata.

Modeller som vi stöder som gradermodeller är gpt-4o-2024-08-06och o3-mini-2025-01-31.

{ 
"name": "score_model_sample_grader", 
"type": "score_model",
 
"input": [ { 
"role": "user", 
"content": "Score\nhow close the reference answer is to the model answer. You will be comparing these\ntwo as JSON objects that contain 2 keys, \"extracted_text\" and\n\"clause_type\". Score 1.0 if they are both the same, 0.5 if one is\nthe same, and 0.0 if neither are the same. Return just a floating point\nscore\n\n Reference answer: {\"extracted_text\": \n{{item.extracted_text}}, \"clause_type\": {{item.clause_type}}}\n\n\nModel answer: {{sample.output_json}}"}],

"model": "gpt-4o-2024-08-06", 
"sampling_params": {"seed": 42}
}

Anpassad kodklassare – Det här är python-kodklassare där du kan använda valfri Python-kod för att gradera träningsutdata.

Följande paket från tredje part är tillgängliga under körning för imagetaggen 2025-05-08

numpy==2.2.4 scipy==1.15.2 sympy==1.13.3 pandas==2.2.3 rapidfuzz==3.10.1 scikit-learn==1.6.1 rouge-score==0.1.2 deepdiff==8.4.2 jsonschema==4.23.0 pydantic==2.10.6 pyyaml==6.0.2 nltk==3.9.1 sqlparse==0.5.3 rdkit==2024.9.6 scikit-bio==0.6.3 ast-grep-py==0.36.2

{

    "type": "python",
    "source": "import json,re,ast\n\ndef safe_eval(e):\n    return _eval(ast.parse(e,mode='eval').body)\n\ndef _eval(n):\n    if isinstance(n,ast.Constant):return n.value\n    if isinstance(n,ast.BinOp) and type(n.op) in {ast.Add:lambda a,b:a+b,ast.Sub:lambda a,b:a-b,ast.Mult:lambda a,b:a*b,ast.Div:lambda a,b:a/b,ast.FloorDiv:lambda a,b:a//b,ast.Mod:lambda a,b:a%b,ast.Pow:lambda a,b:a**b}:return {ast.Add:lambda a,b:a+b,ast.Sub:lambda a,b:a-b,ast.Mult:lambda a,b:a*b,ast.Div:lambda a,b:a/b,ast.FloorDiv:lambda a,b:a//b,ast.Mod:lambda a,b:a%b,ast.Pow:lambda a,b:a**b}[type(n.op)](_eval(n.left),_eval(n.right))\n    if isinstance(n,ast.UnaryOp) and type(n.op) in {ast.UAdd:lambda a:+a,ast.USub:lambda a:-a}:return {ast.UAdd:lambda a:+a,ast.USub:lambda a:-a}[type(n.op)](_eval(n.operand))\n    raise ValueError('bad expr')\n\ndef grade(sample,item)->float:\n    try:\n        expr=sample['output_json']['expression'];expr_val=safe_eval(expr)\n        if sorted(map(int,re.findall(r'-?\\d+',expr)))!=sorted(map(int,json.loads(item['nums']))):return 0\n        sr,it=int(float(sample['output_json']['result'])),int(float(item['target']))\n        if expr_val!=sr:return 1\n        if sr==it:return 5\n        if abs(sr-it)<=1:return 4\n        if abs(sr-it)<=5:return 3\n        return 2\n    except: return 0"
}

Om du inte vill placera klassificeringsfunktionen manuellt i en sträng kan du även läsa in den från en Python-fil med hjälp av importlib och inspektera.

Multi Grader – Ett objekt med flera grader kombinerar utdata från flera grader för att skapa en enda poäng.

{
"name":"sample_multi_grader",
"type":"multi",
"graders":{"ext_text_similarity":{"name":"ext_text_similarity",
"type":"text_similarity",
"input":"{{sample.output_json.ext_text}}",
"reference":"{{item.ext_text}}",
"evaluation_metric":"fuzzy_match"},

"clause_string_check":{"name":"clause_string_check",
"type":"string_check",
"input":"{{sample.output_json.clause_type}}",
"operation":"eq",
"reference":"{{item.clause_type}}"}},

"calculate_output":"0.5 * ext_text_similarity + 0.5 * clause_string_check"
}

Exempel på svarsformat som är ett valfritt fält:

Om vi behöver svaret på samma problem med pussel som används i exemplet med träningsdata kan du lägga till svarsformatet enligt nedan där fälten "solution" och "final answer" delas i strukturerade utdata.

{
  "type": "json_schema",
  "name": "puzzles_assistant",
  "schema": {
    "type" : "object",
    "properties": {
      "solution": {
        "type": "string",
        "title": "solution"
      },
      "final_answer": {
        "type": "string",
        "title": "final_answer"
      }
    },
    "required": [
      "solution",
      "final_answer"
    ],
    "additionalProperties": false
  },
  "strict": true
}

Träningsframstatus och resultat

RFT-jobb är vanligtvis tidskrävande och kan ta upp till 24 timmar beroende på val av parameter. Du kan spåra förloppet i båda finjusteringsvyerna i AI Foundry-portalen. Du kommer att se att ditt jobb går igenom samma statusar som vanliga finjusteringsjobben (i kö, körs, slutfört).

Du kan också granska resultatfilerna medan träningsprocesserna pågår för att få en inblick i förloppet och om din träning går som förväntat.

Ny funktion: pausa och återuppta

Under träningen kan du visa loggarna och RFT-måtten och pausa jobbet vid behov (om måtten konvergerar inte eller om du anser att modellen inte lär sig i rätt takt, fel bedömningsinstans har valts osv.). När träningsjobbet har pausats kommer en implementerbar kontrollpunkt att skapas och vara tillgänglig för att användas för att återuppta eller dra slutsatser från jobbet fram till dess fullbordan. Pausåtgärden gäller endast för jobb som har tränats i minst ett steg och är i körningstillstånd .

Riktlinjer för utgifter för utbildning

Eftersom ett RFT-jobb kan leda till höga utbildningskostnader pausar vi automatiskt jobben när de har nått 5 000 usd i totala utbildningskostnader (utbildning och betygsättning). Användare kan driftsätta den senaste kontrollpunkten eller återuppta träningsuppgiften. Om användaren bestämmer sig för att återuppta jobbet fortsätter faktureringen för jobbet och därefter läggs inga ytterligare prisgränser för träningsjobbet.

Tolka träningsresultat

För förstärkta finjusteringsjobb är de primära måtten belöningsmåtten per steg. Dessa mått anger hur bra din modell presterar på träningsdata. De beräknas av de graderare du definierade i dina jobbinställningar.

Belöningsmått

Det här är två separata belöningsmått på toppnivå:

• train_reward_mean: Den genomsnittliga belöningen för de exempel som tas från alla datapunkter i det aktuella steget. Eftersom de specifika datapunkterna i en batch ändras med varje steg är train_reward_mean värden för olika steg inte direkt jämförbara och de specifika värdena kan variera drastiskt från steg till steg.

• valid_reward_mean: Den genomsnittliga belöningen för de exempel som tas från alla datapunkter i valideringsuppsättningen, vilket är ett stabilare mått.

Resonemangstoken

Måtten train_reasoning_tokens_mean och valid_reasoning_tokens_mean för att se hur modellen ändrar sitt beteende över tid. Dessa mått är det genomsnittliga antalet resonemangstoken som används av modellen för att svara på en uppmaning i tränings- respektive valideringsdatauppsättningarna. Du kan också visa det genomsnittliga antalet resonemangstoken på instrumentpanelen för finjustering.

Utvärdera resultatet

När ditt finjusteringsjobb är klart bör du ha en bra uppfattning om hur bra modellen presterar baserat på medelvärdet för belöningen på valideringsuppsättningen. Det är dock möjligt att modellen antingen har överanpassat sig till träningsdatan eller har lärt sig att belöna att hacka ditt betygssystem, vilket gör att den kan få höga poäng utan att faktiskt vara korrekt.

Du kan snabbt förstå modellens beteende genom att inspektera utvärderingarna som är associerade med finjusteringsjobbet. Mer specifikt bör du vara uppmärksam på körningen som gjordes för det sista träningssteget för att se slutmodellens beteende. Du kan också använda evals-produkten för att jämföra den slutliga körningen med tidigare körningar och se hur modellens beteende har ändrats under träningen.

Distribuera och använda din o4-mini RFT-modell

Din finjusterade modell kan distribueras via användargränssnittet eller REST-API:et, precis som andra finjusterade modeller.

Du kan distribuera det finjusteringsjobb som har slutförts eller eventuella tillfälliga kontrollpunkter som skapas automatiskt eller manuellt genom att utlösa pausåtgärden. Mer information om modelldistribution och testning med Chat Playground finns i finjusteringsdistribution.

När du använder din modell ska du se till att använda samma instruktioner och struktur som används under träningen. Detta håller modellen i distribution och ser till att du ser samma prestanda på dina problem under slutsatsdragningen som du uppnådde under träningen.

REST-API

Skapa ett RFT-jobb

Med betygsmodellklassare

{
    "model": "o4-mini-2025-04-16",
    "training_file": "file-c6578ee2c5194ae99e33711e677d7aa9",
    "validation_file": "file-7ead313cc49e4e0480b9700bbd513bbc",
    "suffix": "TEST",
    "method": {
        "type": "reinforcement",
        "reinforcement": {
            "hyperparameters": {
                "eval_interval": 1,
                "eval_samples": 1,
                "compute_multiplier": 1,
                "reasoning_effort": "medium",
                "n_epochs": 1,
                "batch_size": 10,
                "learning_rate_multiplier": 1
            },
            "grader": {
                "type": "score_model",
                "name": "custom_grader",
                "input": [
                    {
                        "role": "developer",
                        "content": "You are a mathematical evaluator. Given a reference target number, a list of input numbers, and a model\u0027s output (an arithmetic expression and its reported result), your task is to evaluate the correctness and closeness of the model\u0027s answer.\n\nInput values are passed in as **strings**, including the number list and target. You must:\n1. Convert the \u0060target\u0060 string to a number.\n2. Convert the \u0060numbers\u0060 string into a list of numbers.\n3. Parse and validate the \u0060output_expression\u0060 \u2014 ensure it is a valid arithmetic expression.\n4. Evaluate the expression and confirm it matches the model\u0027s reported \u0060output_result\u0060.\n5. Check that **all input numbers are used exactly once**.\n6. Compare the evaluated result with the target and assign a score.\n\nScoring Rules:\n- 5: Valid expression, correct number usage, exact match to target\n- 4: Off by \u00B11\n- 3: Off by \u00B12 to \u00B15\n- 2: Off by \u003E5\n- 1: Minor issues (e.g., small mismatch in numbers used)\n- 0: Major issues \u2014 invalid expression or number usage\n\nOutput Format:\nScore: \u003C0 - 5\u003E\nReasoning: \u003Cbrief justification\u003E\n\nOnly respond with the score and reasoning."
                    },
                    {
                        "role": "user",
                        "content": "{ \u0022target\u0022: {{item.target}}, \u0022numbers\u0022: {{item.nums}}, \u0022output\u0022: {{sample.output_text}} }"
                    }
                ],
                "pass_threshold": 5,
                "range": [
                    0,
                    5
                ],
                "model": "o3-mini"
            },
            "response_format": {
                "type": "json_schema",
                "json_schema": {
                    "name": "math_expression",
                    "schema": {
                        "type": "object",
                        "required": [
                            "expression",
                            "result"
                        ],
                        "properties": {
                            "expression": {
                                "type": "string",
                                "description": "The mathematical expression to be evaluated."
                            },
                            "result": {
                                "type": "string",
                                "description": "The result of evaluating the mathematical expression."
                            }
                        },
                        "additionalProperties": false
                    },
                    "strict": true
                }
            }
        }
    }
}

Med strängkontrollsklassare

{
    "model": "o4-mini-2025-04-16",
    "training_file": "file-c6578ee2c5194ae99e33711e677d7aa9",
    "validation_file": "file-7ead313cc49e4e0480b9700bbd513bbc",
    "suffix": "TEST",
    "method": {
        "type": "reinforcement",
        "reinforcement": {
            "hyperparameters": {
                "eval_interval": 1,
                "eval_samples": 1,
                "compute_multiplier": 1,
                "reasoning_effort": "medium",
                "n_epochs": 1,
                "batch_size": 10,
                "learning_rate_multiplier": 1
            },
            "grader": {
                "name":"answer_string_check",
                "type":"string_check",
                "input":"{{item.reference_answer.final_answer}}",
                "operation":"eq",
                "reference":"{{sample.output_json.final_answer}}"
            }
        }
    }
}

Textlikhetsklassare

{
    "model": "o4-mini-2025-04-16",
    "training_file": "file-c6578ee2c5194ae99e33711e677d7aa9",
    "validation_file": "file-7ead313cc49e4e0480b9700bbd513bbc",
    "suffix": "TEST",
    "method": {
        "type": "reinforcement",
        "reinforcement": {
            "hyperparameters": {
                "eval_interval": 1,
                "eval_samples": 1,
                "compute_multiplier": 1,
                "reasoning_effort": "medium",
                "n_epochs": 1,
                "batch_size": 10,
                "learning_rate_multiplier": 1
            },
            "grader": {
              "name":"solution_similarity",
              "type":"text_similarity",
              "input":"{{sample.output_json.solution}}",
              "reference":"{{item.reference_answer.solution}}",
              "evaluation_metric":"bleu"
            }
        }
    }
}

Exempel:Referera till Jupyter Notebook.

Verifiera graderare

curl -X POST $AZURE_OPENAI_ENDPOINT/openai/v1/fine_tuning/alpha/graders/validate \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{ "grader": { "name":"answer_string_check", "type":"string_check", "input":" {{item.reference_answer.final_answer}}", "operation":"eq", "reference":" {{sample.output_json.final_answer}}" } }' 

Kör väghyvel

curl -X POST $AZURE_OPENAI_ENDPOINT/openai/v1/fine_tuning/alpha/graders/run \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -d '{ "grader": { "name":"solution_similarity", "type":"string_check", "input": " {{item.reference_answer}}", "reference": " {{sample.output_text}}", "operation": "eq" }, "reference_answer": "yes", "model_sample": "yes" }'

Metodtips

Val av graderingsmaskin

Dina bedömare används för förstärkningsinlärning: att välja fel bedömare innebär att dina belöningar blir ogiltiga och att finjusteringen inte kommer att ge de förväntade resultaten.

Vissa grundläggande regler för val av grader:

• Om du har korta, specifika svar såsom siffror, Ja/Nej-svar eller flervalsalternativ, välj en strängmatchande bedömare.

• Om du har komplexa svar som kan poängsätts enligt flera kriterier använder du flerklassare. På så sätt kan du poängsätta olika aspekter av svaret och kombinera det till en aggregering.

• Överväg att dela upp bedömningssystemet i flera steg och ge partiell poäng för att styra modellernas resonemang i rätt riktning. Graderingen är stabil och i linje med preferenser. Ge exempel på bra, medelmåttiga och dåliga svar i uppgiften.

• Använd en LLM som domare när koden misslyckas. För omfattande, öppna svar ber du en annan språkmodell att betygsätta. När du skapar LLM-bedömare kör du flera kandidatsvar och grundsanningar med hjälp av din LLM-bedömare för att säkerställa korrekta bedömningar.

Testa dina bedömare

Alla bedömningsverktyg som finns tillgängliga i RFT stöds i Azure OpenAI-utvärdering. Innan du påbörjar en träningskörning bör du testa en vanilla o4-mini-modell mot dina valideringsdata med samma väghyvel som du tänker använda för träning. Om bedömarens poäng inte matchar dina förväntningar måste du välja en annan bedömare.

Vi tillhandahåller också ett API för graderkontroll som du kan använda för att kontrollera giltigheten för din konfiguration.

Dataförberedelse

Sikta på några hundra exempel från början och överväg att skala upp till cirka 1 000 exempel om det behövs. Datamängden bör balanseras, när det gäller klasser som förutsägs, för att undvika bias och säkerställa generalisering.

För uppmaningarna måste du ange tydliga och detaljerade instruktioner, inklusive att ange svarsformatet och eventuella begränsningar för utdata (t.ex. minsta längd för förklaringar, endast svara med sant/falskt osv.)