Fonction de récompense qui vérifie si l'achèvement correspond à la vérité de terrain.

• Si la référence et la prédiction sont toutes deux analysables → utiliser la vérification mathématique.
• Si l'or n'est pas analysable → retourner None pour ignorer l'exemple.

>>> from trl.rewards import accuracy_reward

>>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}"]
>>> completions = [
...     [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{3}}"}],
...     [{"role": "assistant", "content": r"My answer is \boxed{\frac{1}{2}}"}],
... ]
>>> accuracy_reward(completions, solutions)
[1.0, 0.0]

Fonction de récompense qui supprime le contenu de raisonnement et vérifie si la réponse finale correspond à la vérité de terrain.

• Si la référence et la prédiction sont toutes deux analysables → utiliser la vérification mathématique.
• Si l'or n'est pas analysable → retourner None pour ignorer l'exemple.

>>> from trl.rewards import reasoning_accuracy_reward

>>> reasoning_delimiters = ["</think>"]
>>> solutions = [r"\frac{1}{3}", r"\frac{1}{3}", r"\frac{1}{3}"]
>>> completions = [
...     [
...         {
...             "role": "assistant",
...             "content": r"<think> Reasoning content </think> The final answer is \boxed{\frac{1}{3}}",
...         }
...     ],
...     [
...         {
...             "role": "assistant",
...             "content": r"<think> Reasoning content </think> The final answer is \boxed{\frac{1}{2}}",
...         }
...     ],
...     [
...         {
...             "role": "assistant",
...             "content": r"<think> Reasoning content with partial answers \boxed{\frac{1}{3}} but no final answer",
...         }
...     ],
... ]
>>> reasoning_accuracy_reward(completions, solutions, reasoning_delimiters=reasoning_delimiters)
[1.0, 0.0, 0.0]

Fonction de récompense qui met à l'échelle une récompense de justesse en fonction de la longueur de la complétion, selon un calendrier cosinus, afin de favoriser un raisonnement concis. Référence : Annexe C.1 de l'article « Demystifying Long Chain-of-Thought Reasoning » (https://huggingface.co/papers/2502.03373).

La justesse est déterminée par la vérification mathématique (comme dans accuracy_reward()), et la longueur correspond au nombre de jetons de complétion. La récompense interpole selon un calendrier cosinus entre une borne de complétion courte et une borne de complétion longue : $$R_{\text{cosine}}(y) = v_{\min} + \frac{1}{2}(v_{\max} - v_{\min})\left(1 + \cos\left(\frac{|y|}{L_{\max}}\pi\right)\right)$$

Pour une complétion correcte, $(v{\min}, v{\max}) = (\texttt{min_value_correct}, \texttt{max_value_correct})$, de sorte qu’une complétion plus courte est davantage récompensée. Pour une complétion erronée, les bornes sont inversées : $(v{\min}, v{\max}) = (\texttt{max_value_wrong}, \texttt{min_value_wrong})$, de sorte qu’une complétion plus courte est davantage pénalisée (une complétion erronée plus longue est moins pénalisée, ce qui préserve l’exploration). Lorsque la solution de référence n’est pas analysable, l’exemple est ignoré (récompense None), comme dans accuracy_reward().

>>> from trl.rewards import get_cosine_scaled_reward

>>> cosine_scaled_reward = get_cosine_scaled_reward(max_len=100)
>>> completions = [[{"content": r"\boxed{\frac{1}{3}}"}], [{"content": r"\boxed{\frac{1}{2}}"}]]
>>> solution = [r"\frac{1}{3}", r"\frac{1}{3}"]
>>> completion_ids = [[1] * 50, [1] * 50]  # both completions are 50 tokens, half of max_len
>>> cosine_scaled_reward(completions, solution, completion_ids)
[0.75, -0.75]

Fonction de récompense qui vérifie si le processus de raisonnement est encadré par les balises "<think>" et "</think>". La fonction renvoie une récompense de 1.0 si le format est correct, sinon 0.0.

>>> from trl.rewards import think_format_reward

>>> completions = [
...     [{"content": "<think>\nThis is my reasoning.\n</think>\nThis is my answer."}],
...     [{"content": "<think>\nThis is my reasoning.\nThis is my answer."}],
... ]
>>> think_format_reward(completions)
[1.0, 0.0]

Fonction de récompense qui pénalise les n-grammes répétés dans une complétion, utilisée pour décourager les textes dégénérés et répétitifs (un mode d’échec courant et une stratégie de fraude de la récompense lorsque des récompenses de façonnage de la longueur ou du format sont utilisées). Référence : Annexe C.2 de l’article « Demystifying Long Chain-of-Thought Reasoning » (https://huggingface.co/papers/2502.03373).

La pénalité est proportionnelle à la fraction de n-grammes répétés dans la complétion : $$R_{\text{repetition}}(y) = \left(1 - \frac{\#\,\text{unique } n\text{-grams}}{\#\,\text{total } n\text{-grams}}\right) \times p$$

où $p$ est max_penalty. Une complétion sans n-gramme répété reçoit une récompense de 0.0, tandis qu'une complétion entièrement répétitive se rapproche de max_penalty. Les n-grammes sont calculés sur les identifiants de jetons de la complétion (l'article applique la pénalité aux jetons répétés), de sorte que la récompense est définie par le tokeniseur et indépendante de la langue. Les complétions contenant moins de ngram_size jetons reçoivent une récompense de 0.0.

>>> from trl.rewards import get_repetition_penalty_reward

>>> repetition_penalty = get_repetition_penalty_reward(ngram_size=2, max_penalty=-1.0)
>>> completion_ids = [[1, 2, 3, 4], [5, 5, 5, 5, 5]]
>>> repetition_penalty(completion_ids)
[0.0, -0.75]

Fonction de récompense qui pénalise les compléments trop longs. Elle est utilisée pour pénaliser les compléments trop longs, mais pas pour récompenser les compléments plus courts. Référence : Éq. (13) du papier DAPO (https://huggingface.co/papers/2503.14476) $$R_{\text{length}}(y) = \begin{cases} 0, & |y| \le L_{\max} - L_{\text{cache}} \\ \dfrac{(L_{\max} - L_{\text{cache}}) - |y|}{L_{\text{cache}}}, & L_{\max} - L_{\text{cache}} < |y| \le L_{\max} \\ -1, & L_{\max} < |y| \end{cases}$$

>>> from trl.rewards import get_soft_overlong_punishment

>>> soft_overlong_punishment = get_soft_overlong_punishment(max_completion_len=100, soft_punish_cache=20)
>>> completion_ids = [[1] * 90]  # simulating a completion with 90 tokens. 90 is between 80 and 100.
>>> soft_overlong_punishment(completion_ids)
>>> [-0.5]