Versterkingsafstemming (RFT) met Azure OpenAI o4-mini (preview)

RfT (Reinforcement Fine-Tuning) is een techniek voor het verbeteren van redeneringsmodellen zoals o4-mini door ze te trainen via een beloningsproces, in plaats van alleen te vertrouwen op gelabelde gegevens. Door feedback of 'beloningen' te gebruiken om te leren, helpt RFT modellen bij het ontwikkelen van betere redenerings- en probleemoplossingsvaardigheden, met name in gevallen waarin gelabelde voorbeelden beperkt of complex gedrag gewenst zijn.

Proces

Reinforcement fine-tuning (RFT) is vergelijkbaar met Supervised fine-tuning (SFT) met enkele belangrijke verschillen.

• Berichten van het systeem voor gegevensvoorbereiding worden niet ondersteund en in plaats van een assistant bericht is het laatste bericht in uw trainingsgegevens een referentieantwoord.
• Modelselectie: alleen o4-mini ondersteunt RFT.
• Beoordelingsdefinitie: RFT vereist het gebruik van graders om de kwaliteit van uw nauwkeurig afgestemde model te beoordelen en het leren te begeleiden. U kunt tekenreekscontrole, gelijkenis van tekst of op modellen gebaseerde gradeerfuncties gebruiken, of deze combineren met een multi-grader.
• Training: bevat aanvullende parameters: eval_samples, eval_interval, reasoning_efforten compute_multiplier. U hebt ook de mogelijkheid om taken te onderbreken en hervatten, zodat u de training kunt onderbreken, controlepunten kunt inspecteren en alleen kunt doorgaan als er verdere training nodig is.
• Evaluatie: Naast nauwkeurigheid en verlies retourneert RFT gemiddelde beloning en parseringsfout en gemiddelde tokens.

Tijdens het trainingsproces doorloopt het platform de gegevensset en genereert meerdere antwoorden voor elke prompt. Deze antwoorden worden vervolgens geëvalueerd door de beoordelaar, en policy-gradiënt updates worden toegepast op basis van de ontvangen scores. Deze cyclus wordt herhaald totdat de trainingsgegevens volledig worden verwerkt of de taak wordt gestopt op een opgegeven controlepunt, wat uiteindelijk resulteert in een model dat is afgestemd op uw gewenste metrische gegevens.

Ondanks deze verschillen zijn er echter veel overeenkomsten tussen SFT en RFT: gegevensvoorbereiding is essentieel; serverloze trainingstaken kunnen worden gestart via de Gebruikersinterface van Foundry; en we ondersteunen standaard- en wereldwijde standaardimplementaties.

Vereisten voor training en evaluatiebestandsvorming

Zowel trainings- als validatiebestanden zijn vereist om o4-mini RFT uit te voeren. o4-mini maakt gebruik van een nieuwe indeling van gegevens voor het verfijnen van versterking. Dit moeten jsonl-bestanden zijn, zoals wat wordt gebruikt voor het afstemmen onder supervisie (SFT).

Elke regel van het bestand moet het berichtenveld bevatten, met enkele verschillen in SFT:

• Systeemberichten worden niet ondersteund
• Het laatste bericht moet afkomstig zijn van de gebruiker, niet van de assistent (zoals het geval is bij SFT)
• Tools, response_formatsworden ondersteund
• Afbeeldingen/multimodale gegevens worden niet ondersteund

Elke regel in het JSONL-gegevensbestand moet een berichtenmatrix bevatten, samen met eventuele extra velden die nodig zijn om de uitvoer van het model te beoordelen. Deze waarde moet een geldig JSON-object zijn (bijvoorbeeld woordenlijst of lijst; het specifieke type en de structuur zijn afhankelijk van de geselecteerde grader).

Voorbeeld van trainingsgegevens

Als we model een puzzel geven om op te lossen in de vereiste RFT-trainingsindeling, zou dit als volgt zijn:

"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"
}

We hebben de bovenstaande tekst uitgebreid vanaf één regel, jsonlzodat u de verwachte velden kunt zien: berichten, rollen, inhoud en final_answer.

Grootte van gegevensset voor RFT

Begin met een kleine gegevensset, bestaande uit enkele tientallen tot een paar honderd voorbeelden, om de werkzaamheid van RFT te evalueren voordat u zich aan een grotere gegevensset verbindt. Om veiligheidsredenen moet de trainingsset een geautomatiseerd screeningproces ondergaan, dat initieert wanneer een taak voor het afstemmen wordt gestart, in plaats van bij het uploaden van bestanden. Zodra een bestand met succes is doorgelicht, kan het zonder vertraging herhaaldelijk worden gebruikt.

Voorbeelden van hoge kwaliteit zijn essentieel, zelfs in beperkte hoeveelheden. Na de screening is een toegenomen hoeveelheid gegevens voordelig, mits deze een hoge kwaliteit behoudt. Grotere gegevenssets maken het gebruik van grotere batchgrootten mogelijk, waardoor de trainingsstabiliteit over het algemeen wordt verbeterd.

Trainingsbestanden kunnen maximaal 50.000 voorbeelden bevatten, terwijl testgegevenssets maximaal 1000 voorbeelden kunnen bevatten. Beide typen gegevenssets zijn onderworpen aan geautomatiseerde screening

Taken maken voor fijn-tuning werkzaamheden.

U kunt trainingstaken maken voor o4-mini RFT in Azure AI Foundry op dezelfde manier als elk ander model: Selecteer fine-tuning in een ondersteunde regio en selecteer o4-mini als basismodel.

Hyperparameterselectie

De hyperparameterssectie van de versterkingsmethode ondersteunt alle reguliere trainingshyperparameters (bijvoorbeeld leersnelheid, aantal tijdvakken en batchgrootte), evenals drie nieuwe hyperparameters:

Beoordelaars

RFT is uniek omdat het beoordelaars gebruikt om de kwaliteit van het antwoord van een model te evalueren, waardoor het model leert te redeneren. In tegenstelling tot SFT is het laatste bericht niet afkomstig van de assistent. In plaats daarvan nemen we een steekproef van het model en gebruiken we een cijfer voor elk voorbeeld om de kwaliteit ervan te beoordelen. Vervolgens trainen we op basis van deze scores om de modelprestaties te verbeteren.

In feite zijn graders functies waarmee de reference_answer uit uw trainingsbestand worden vergeleken met het voorbeeldantwoord.

Leerlingen:

• Geef kommagetallen tussen 0 en 1. Het kan handig zijn om het model gedeeltelijke punten te geven voor antwoorden, in plaats van een binair systeem van 0/1.
• Graders worden opgegeven als JSON (zie hieronder)

Ondersteunde graders

We ondersteunen drie typen graders: tekenreekscontrole, gelijkenis van tekst, modelgraders. Er is ook een optie voor Multi-graders om graders in combinaties te gebruiken.

String-check-grader

Gebruik deze eenvoudige bewerkingen om een 0 of 1 te retourneren.

Specificatie:

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

Ondersteunde bewerkingen:

• eq: retourneert 1 als de invoer overeenkomt met de verwijzing (hoofdlettergevoelig), anders 0
• neq: retourneert 1 als de invoer niet overeenkomt met de verwijzing (hoofdlettergevoelig), anders 0
• like: retourneert 1 als de invoer de verwijzing (hoofdlettergevoelig) bevat, anders 0
• ilike: retourneert 1 als de invoer de verwijzing bevat (niet hoofdlettergevoelig), anders 0

Gelijkenis van tekst

Om te evalueren hoe dicht de door het model gegenereerde uitvoer bij de referentie ligt, beoordeeld met verschillende evaluatiemetrieken.

Specificatie:

{
    "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" 
}

Ondersteunde bewerkingen:

• bleu – berekent de BLEU-score tussen tekenreeksen
• Fuzzy_match – vervaagde tekenreeksvergelijking, met gebruik van rapidfuzz
• gleu – berekent Google BLEU-score tussen teksten
• meteor – berekent METEOR-score tussen tekenreeksen
• rouge-* - zoals gedefinieerd door de python-bibliotheek van rouge

ScoreModel

Dit is Model Grader waar u LLM kunt gebruiken om de trainingsuitvoer te beoordelen.

Modellen die we als gradermodellen ondersteunen, zijn:

• 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"
    }
}

Als u een scoremodelclassificatie wilt gebruiken, is de invoer een lijst met chatberichten, elk met een rol en inhoud. De uitvoer van de grader wordt afgekapt tot het opgegeven bereik en wordt standaard ingesteld op 0 voor alle niet-numerieke uitvoer.

Aangepaste codeklasse

Met aangepaste codeclassificatie kunt u willekeurige Python-code uitvoeren om de modeluitvoer te beoordelen. De beoordelaar verwacht dat er een cijferfunctie aanwezig is die twee argumenten ontvangt en een Float-waarde uitvoert. Elk ander resultaat (uitzondering, ongeldige floatwaarde, enzovoort) wordt gemarkeerd als ongeldig en retourneert een cijfer van 0.

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

Technische beperkingen: Uw geüploade code moet kleiner zijn dan 256kB. Er is geen netwerktoegang. De beoordelingsuitvoering zelf mag niet langer zijn dan 2 minuten. Tijdens runtime krijgt u een limiet van 2 Gb geheugen en 1 Gb schijfruimte om te gebruiken. Er is een limiet van 1 CPU-kernen. Elk gebruik boven deze hoeveelheid leidt tot beperking.

Multi Grader

Een multigrader-object combineert de uitvoer van meerdere beoordelingsmechanismen om één enkele score te genereren.

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

Ondersteunde bewerkingen:

Exploitanten:

• + (toevoeging)
• - (aftrekken)
• * (vermenigvuldiging)
• / (divisie)
• ^ (macht)

Functies:

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

Wanneer u de UX gebruikt, kunt u zo nodig een prompt schrijven en een geldige cijfer- en antwoordindeling genereren in json. Grader is verplicht om het veld in te voeren tijdens het indienen van een taak voor het afstemmen. De antwoordindeling is optioneel.

Hier volgt een voorbeeld van een cijfer voor elke categorie:

string-check-grader : gebruik eenvoudige tekenreeksbewerkingen om een 0 of 1 te retourneren.

Voorbeeld:

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

Gelijkenis van tekst: evalueer hoe dicht de door het model gegenereerde uitvoer overeenkomt met de verwijzing, beoordeeld met verschillende metrische evaluatiegegevens.

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

Score Model - Dit is Model Grader waar u LLM kunt gebruiken om de trainingsuitvoer te beoordelen.

Modellen die we ondersteunen als gradermodellen zijn gpt-4o-2024-08-06en 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}
}

Aangepaste codebeoordelaar - Dit is een Python-codebeoordelaar waar u elke Python-code kunt gebruiken om de trainingsuitvoer te beoordelen.

De volgende pakketten van derden zijn beschikbaar bij uitvoering voor de imagetag 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"
}

Als u uw beoordelingsfunctie niet handmatig in een tekenreeks wilt plaatsen, kunt u deze ook laden vanuit een Python-bestand met behulp van importlib en inspecteren.

Multi Grader - Een multigrader-object combineert de uitvoer van meerdere graders om één score te produceren.

{
"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"
}

Voorbeeld van de antwoordindeling die een optioneel veld is:

Als we het antwoord nodig hebben voor hetzelfde probleem met puzzels dat wordt gebruikt in het voorbeeld van trainingsgegevens, kunt u de antwoordindeling toevoegen, zoals hieronder wordt weergegeven waar velden 'oplossing' en 'eindantwoord' worden gedeeld in gestructureerde uitvoer.

{
  "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
}

Voortgang en resultaten van training

RFT-taken zijn doorgaans langlopend en kunnen tot 24 uur duren, afhankelijk van uw parameterselectie. U kunt de voortgang bijhouden in beide aangepaste weergaven van de AI Foundry portal. U ziet dat uw taak dezelfde statussen doorloopt als normale taakafstemming (in de wachtrij geplaatst, uitgevoerd, geslaagd).

U kunt ook de resultatenbestanden bekijken tijdens het trainen, om een kijkje te nemen in de voortgang en te zien of uw training verloopt zoals verwacht.

Nieuwe functie: onderbreken en hervatten

Tijdens de training kunt u de logboeken en RFT-metrische gegevens bekijken en de taak indien nodig onderbreken (als metrische gegevens niet worden samengevoegd of als u denkt dat het model niet in het juiste tempo leert, onjuiste grader gekozen, enzovoort). Zodra de trainingstaak is onderbroken, wordt er een implementeerbaar controlepunt gemaakt en kunt u de taak afleiden of hervatten totdat deze is voltooid. Pauzebewerking is alleen van toepassing op taken die ten minste één stap getraind zijn en in de actieve staat zijn.

Richtlijnen voor trainingsuitgaven

Omdat een RFT-taak kan leiden tot hoge kosten voor training, onderbreken we taken automatisch zodra ze 5.000 dollar hebben bereikt in de totale kosten voor training (opleiding + beoordeling). Gebruikers kunnen het meest recente controlepunt implementeren of de trainingstaak hervatten. Als de gebruiker besluit de taak te hervatten, wordt de facturering voortgezet voor de taak en worden er vervolgens geen verdere prijslimieten in de trainingstaak geplaatst.

Trainingsresultaten interpreteren

Voor het verfijnen van versterkingstaken zijn de primaire metrische gegevens de metrische gegevens voor beloning per stap. Deze metrische gegevens geven aan hoe goed uw model presteert op de trainingsgegevens. Ze worden berekend door de beoordelaars die u hebt gedefinieerd in uw taakconfiguratie.

Metrische beloningsgegevens

Dit zijn twee afzonderlijke beloningsgegevens op het hoogste niveau:

• train_reward_mean: De gemiddelde beloning voor de voorbeelden die zijn genomen uit alle gegevenspunten in de huidige stap. Omdat de specifieke gegevenspunten in een batch met elke stap veranderen, zijn train_reward_mean waarden in verschillende stappen niet rechtstreeks vergelijkbaar en kunnen de specifieke waarden drastisch van stap tot stap fluctueren.

• valid_reward_mean: De gemiddelde beloning voor de voorbeelden uit alle gegevenspunten in de validatieset, wat een stabielere metriek is.

Redeneringstokens

De train_reasoning_tokens_mean en valid_reasoning_tokens_mean metrische gegevens om te zien hoe het model het gedrag in de loop van de tijd wijzigt. Deze metrische gegevens zijn het gemiddelde aantal redeneringstokens dat door het model wordt gebruikt om respectievelijk te reageren op een prompt in de trainings- en validatiegegevenssets. U kunt ook het gemiddelde aantal redeneringstokens bekijken in het dashboard voor het afstemmen.

De resultaten evalueren

Op het moment dat uw taak is voltooid, moet u een goed idee hebben van hoe goed het model presteert op basis van de gemiddelde beloningswaarde voor de validatieset. Het is echter mogelijk dat het model gefixeerd is op de trainingsgegevens of dat het heeft geleerd om uw beoordelaar te omzeilen, waardoor het hoge scores kan produceren zonder echt correct te zijn.

Inzicht in het gedrag van het model kan snel worden uitgevoerd door de evals te inspecteren die zijn gekoppeld aan de taak voor het afstemmen. Let met name op de run voor de laatste trainingsstap om het gedrag van het eindmodel te observeren. U kunt het evals-product ook gebruiken om de laatste uitvoering te vergelijken met eerdere uitvoeringen en te zien hoe het gedrag van het model in de loop van de training is gewijzigd.

Uw o4-mini RFT-model implementeren en gebruiken

Uw nauwkeurig afgestemde model kan worden geïmplementeerd via de gebruikersinterface of REST API, net als elk ander nauwkeurig afgestemd model.

U kunt de voltooide taak voor fijnafstemming implementeren of alle tussentijdse checkpoints die automatisch of handmatig zijn gemaakt door de pauze-operatie te activeren. Voor meer informatie over modelimplementatie en testen met Chat Playground raadpleegt u de implementatie voor het afstemmen van de implementatie.

Wanneer u uw model gebruikt, moet u dezelfde instructies en structuur gebruiken als tijdens de training. Dit houdt het model binnen de distributie en zorgt ervoor dat u dezelfde prestaties ziet voor uw vragen tijdens inferentie zoals u tijdens de training hebt bereikt.

REST-API

Een RFT-taak maken

Met scoremodelbeoordelaar

{
    "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
                }
            }
        }
    }
}

Met de Tekenreekscontrole-beoordelaar

{
    "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}}"
            }
        }
    }
}

Tekstovereenkomstbeoordelaar

{
    "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"
            }
        }
    }
}

Voorbeelden:Verwijzing naar Jupyter Notebook.

Grader valideren

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}}" } }' 

Grader uitvoeren

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" }'

Beste praktijken

Beoordelaarselectie

Uw graders worden gebruikt voor versterkingsleer: het kiezen van de verkeerde grader betekent dat uw beloningen ongeldig zijn en dat uw afstemming niet de verwachte resultaten oplevert.

Enkele basisregels voor graderselectie:

• Als u korte, specifieke antwoorden hebt, zoals getallen, Booleaanse antwoorden of meerdere keuzen, kiest u een overeenkomende cijferreeks.

• Als u complexe antwoorden hebt die op meerdere criteria kunnen worden beoordeeld, moet u meerdere beoordelaars gebruiken. Hiermee kunt u verschillende aspecten van het antwoord beoordelen en combineren tot een aggregaties.

• Overweeg om de grader op te splitsen in meerdere stappen en gedeeltelijke punten te geven, zodat de redenatie van de modellen in de juiste richting wordt gestuurd. De beoordeling is hiermee stabiel en afgestemd op voorkeur. Geef enkele voorbeelden van geweldige, eerlijke en slechte antwoorden in de prompt.

• Gebruik een LLM als beoordelaar wanneer de code tekortschiet. Vraag een ander taalmodel om uitgebreide, open antwoorden te evalueren. Wanneer u LLM-graders bouwt, verwerkt u meerdere kandidatenreacties en grondwaarheden via uw LLM-beoordelaar om ervoor te zorgen

Uw graders testen

Alle graders die beschikbaar zijn in RFT, worden ondersteund in de Azure OpenAI-evaluatie. Voordat u een trainingsuitvoering start, test u een vanille o4-minimodel op basis van uw validatiegegevens met dezelfde grader die u wilt gebruiken voor training. Als de scores van de grader niet aan uw verwachtingen voldoen, moet u een andere grader selecteren.

We bieden ook een grader-controle-API die u kunt gebruiken om de geldigheid van uw configuratie te controleren.

Gegevensvoorbereiding

Richt u in eerste instantie op enkele honderd voorbeelden en overweeg indien nodig omhoog te schalen tot ongeveer 1000 voorbeelden. De gegevensset moet worden verdeeld, wat betreft de voorspelde klassen, om vooroordelen te voorkomen en te zorgen voor generalisatie.

Voor de prompts moet u duidelijke en gedetailleerde instructies opgeven, waaronder het opgeven van de antwoordindeling en eventuele beperkingen voor de uitvoer (bijvoorbeeld minimale lengte voor uitleg, alleen reageren met waar/onwaar, enzovoort)