Documents expliqués 428: GPT-ASS. Modèles de langue ouverte d’Openai… | | par Ritvik Rastogi | Août 2025
- Intelligence Artificielle
Noesis News- 0
- 46 minutes de lecture
Les modèles de langue ouverte d’OpenAI, y compris GPT-OSS-120B et GPT-OSS-20B, sont conçus pour le raisonnement, les tâches agentiques. Ils sont formés sur le format de réponse harmontique et offrent un effort de raisonnement configurable (faible, moyen, élevé), des capacités complètes de chaîne de réflexions et de réglage fin. Les modèles prennent en charge les capacités d’agence comme l’appel de fonction, la navigation Web et l’exécution du code Python, et sont quantifiées en nativement dans MXFP4 pour un déploiement efficace.
Les modèles sont disponibles à Étreinte.
Les modèles GPT-ASS sont des transformateurs de mélange de réchauffe autorégressifs (MOE) qui s’appuient sur les architectures GPT-2 et GPT-3.
- GPT-OSS-120B se compose de 36 couches (116,8b paramètres totaux et paramètres «actifs» de 5,1b par jeton par passe avant).
- GPT-OSS-20B se compose de 24 couches (20,9b au total et des paramètres actifs 3,6b).
Les deux modèles ont une dimension de flux résiduel de 2880, appliquant une normalisation quadratique moyenne sur les activations avant chaque attention et le bloc MOE. Semblable à GPT-2, le placement pré-LN est utilisé.
Chaque bloc MOE se compose d’un nombre fixe d’experts (128 pour GPT-ASS-120B et 32 pour GPT-ASS-20B), ainsi qu’une projection de routeur linéaire standard qui mappe les activations résiduelles aux scores pour chaque expert. Pour les deux modèles, les 4 meilleurs experts pour chaque jeton sont sélectionnés par le routeur, et la sortie de chaque expert est pondérée par le softmax de la projection du routeur sur uniquement les experts sélectionnés. Les blocs MOE utilisent la fonction d’activation Swiglu fermée.
Après GPT-3, les blocs d’attention alternent entre la fenêtre à bande et les motifs entièrement denses, où la bande passante est de 128 jetons. Chaque couche a 64 têtes de dimension 64 de requête et utilise l’attention de la requête groupée (GQA) avec 8 têtes de valeur clé. Les incorporations de position rotative sont appliquées et la longueur de contexte des couches denses est étendue à 131 072 jetons en utilisant du fil. Chaque tête d’attention a un biais appris dans le dénominateur du softmax, similaire à des puits d’attention et d’attention hors un, ce qui permet au mécanisme d’attention de ne prêter aucune attention aux jetons.
À toutes les étapes de formation, le tokenizer O200K_Harmony est utilisé. Ce codage de paires d’octets (BPE) étend le tokenzer O200K utilisé pour d’autres modèles OpenAI tels que GPT-4O et OpenAI O4-MinI avec des jetons explicitement utilisés pour le format de chat Harmony et a un total de 201 088 jetons.
Les modèles sont formés sur un ensemble de données en texte uniquement avec des milliards de jetons, en mettant l’accent sur la tige, le codage et les connaissances générales. Pour améliorer la sécurité du modèle, les données sont filtrées pour un contenu nocif dans la pré-formation, en particulier autour des connaissances sur la biosécurité dangereuses, en réutilisant les filtres pré-entraînement CBRN de GPT-4O. Le modèle a une coupure de connaissances de juin 2024.
Après la pré-formation, les modèles sont post-formés en utilisant des techniques de COT similaires à celles d’OpenAI O3. L’ensemble de données de formation se compose d’un large éventail de problèmes du codage, des mathématiques, des sciences, etc.
Pour la formation des modèles, un format de chat personnalisé connu sous le nom de format de chat harmonie est utilisé.
Formation du raisonnement d’effort variable
Les modèles sont formés pour soutenir trois niveaux de raisonnement: faible, moyen et élevé. Ces niveaux sont configurés dans l’invite du système en insérant des mots clés tels que «raisonnement: faible». L’augmentation du niveau de raisonnement entraînera une augmentation de la longueur du lit de lit du modèle du modèle.
Utilisation d’outil agentique
Pendant le post-formation, les modèles apprennent à utiliser différents outils agentiques:
- Un outil de navigation qui permet au modèle d’appeler la recherche et d’ouvrir des fonctions pour interagir avec le Web. Cela aide la factualité et permet aux modèles de récupérer des informations au-delà de leur coupure de connaissances.
<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2025-06-28Reasoning: high
# Tools
## browser
// Tool for browsing.
// The `cursor` appears in brackets before each browsing display: `({cursor})`.
// Cite information from the tool using the following format:
// `【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`.
// Do not quote more than 10 words directly from the tool output.
// sources=web (default: web)
namespace browser {
// Searches for information related to `query` and displays `topn` results.
type search = (_: {
query: string,
topn?: number, // default: 10
source?: string,
}) => any;
// Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.
// Valid link ids are displayed with the formatting: `【{id}†.*】`.
// If `cursor` is not provided, the most recent page is implied.
// If `id` is a string, it is treated as a fully qualified URL associated with `source`.
// If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.
// Use this function without `id` to scroll to a new location of an opened page.
type open = (_: {
id?: number | string, // default: -1
cursor?: number, // default: -1
loc?: number, // default: -1
num_lines?: number, // default: -1
view_source?: boolean, // default: false
source?: string,
}) => any;
// Finds exact matches of `pattern` in the current page, or the page given by `cursor`.
type find = (_: {
pattern: string,
cursor?: number, // default: -1
}) => any;
} // namespace browser
# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
- Un outil Python, qui permet au modèle d’exécuter du code dans un environnement de cahier Jupyter.
<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2025-06-28Reasoning: high
# Tools
## python
Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).
When you send a message containing Python code to python, it will be executed in a stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 120.0 seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is UNKNOWN. Depends on the cluster.
# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|>
- Fonctions de développeur arbitraire, où l’on peut spécifier des schémas de fonction dans un message de développement similaire à l’API OpenAI. Le modèle peut entrelacer le COT, les appels de fonction, les réponses de la fonction, les messages intermédiaires qui sont affichés aux utilisateurs et les réponses finales.
Les modèles sont post-formés avec la quantification des poids MOE au format MXFP4, où les poids sont quantifiés à 4,25 bits par paramètre. Les poids MOE sont responsables de 90 +% du nombre total de paramètres, et les quantifier à MXFP4 permet au modèle plus grand de s’adapter sur un seul GPU de 80 Go et le modèle plus petit pour fonctionner sur des systèmes avec aussi peu que 16 Go de mémoire.
- Les modèles GPT-ASS sont forts en mathématiques en particulier, c’est-à-dire qu’ils peuvent utiliser efficacement très longs COTS, par exemple, GPT-ASS-20B utilise plus de 20 000 jetons de lit de lit par problème en moyenne pour l’AIME.
- Sur des tâches plus liées aux connaissances telles que GPQA, le modèle GPT-OSS-20B est en retard en raison de sa taille plus petite.
- Les modèles GPT-ASS ont des performances particulièrement solides sur les tâches de codage et d’utilisation des outils.
- GPT-OSS-120B se rapproche de O4-Mini d’Openai en performance.
- Les rendements log-linéaires sont observés sur la plupart des tâches où les lits plus longs offrent une précision plus élevée à une augmentation relativement importante de la latence et du coût de la réponse finale.
- Les modèles GPT-OSS au niveau du raisonnement ont bien performant compétitif aux meilleurs modèles fermés, y compris OpenAI O3, et surpassent certains modèles frontaliers. En particulier,
- GPT-OSS-120B correspond presque aux performances Openai O3 sur HealthBench et HealthBench Hard, et surpasse GPT-4O, Openai O1, Openai O3-Mini et Openai O4-Mini par des marges significatives.
- Le GPT-OSS-120B à un raisonnement élevé se rapproche de la performance Openai O4-MinI-High.
Le format de chat Harmony, structure des conversations avec des jetons et des rôles spéciaux (système, développeur, utilisateur, assistant, outil) pour définir les types de messages, l’effort de raisonnement, les instructions et les outils disponibles, tout en utilisant des canaux (final, analyse, commentaire) pour séparer les réponses destinées aux utilisateurs du raisonnement interne et des appels d’outils, en garantissant un comportement et une sécurité des modèles appropriés.
Rôles
Chaque message que le modèle traite un rôle qui lui est associé. Le modèle connaît trois types de rôles:
Ces rôles représentent également la hiérarchie d’informations que le modèle s’applique en cas de conflits d’instructions: Système> Développeur> utilisateur> Assistant> Outil.
Canaux
Les messages assistants peuvent être sortis en trois «canaux» différents. Ceux-ci sont utilisés pour séparer entre les réponses orientées par les utilisateurs et les messages de face interne.
Jetons spéciaux
Le modèle utilise un ensemble de jetons spéciaux pour identifier la structure de votre entrée.
Format de message
Le format de réponse Harmony se compose de «messages» avec le modèle générant potentiellement plusieurs messages en une seule fois. La structure générale d’un message est la suivante:
<|start|>{header}<|message|>{content}<|end|>
L’en-tête {contient une série de méta-informations comprenant le rôle. <| end |> représente la fin d’un message entièrement terminé, mais le modèle peut également utiliser d’autres jetons d’arrêt tels que <| Call |> pour l’appel à outils et <| return |> pour indiquer que le modèle se fait avec l’achèvement.
Format de message système
Le message système est utilisé pour fournir des informations générales au système. Ceci est différent de ce qui pourrait être considéré comme «l’invite du système» dans d’autres formats rapides. Le message système est utilisé pour définir:
- L’identité du modèle: cela devrait toujours rester comme vous êtes Chatgpt, un modèle grand langage formé par Openai.
- Dates de méta: en particulier le coupure de connaissances: et la date actuelle:
- L’effort de raisonnement: comme spécifié sur les niveaux élevés, moyens, bas
- Canaux disponibles: Pour les meilleures performances, cela devrait mapper l’analyse, les commentaires et la finale.
- Outils intégrés: le modèle a été formé à la fois sur un outil Python et du navigateur.
Format de message du développeur
Le message du développeur représente ce qui est généralement considéré comme «l’invite du système». Il contient les instructions fournies au modèle et éventuellement une liste d’outils de fonction disponibles pour une utilisation ou le format de sortie que vous souhaitez que le modèle adhère aux sorties structurées.
Fonction d’appel
Toutes les fonctions disponibles pour le modèle doivent être définies dans le message du développeur dans une section d’outils dédiés.
Pour définir les fonctions, une syntaxe de type type de typeScript est utilisée et les fonctions sont enveloppées dans un espace de noms de fonctions dédié.
- Définir chaque fonction comme un type {function_name} = () => tout s’il ne reçoit aucun argument
- Pour les fonctions qui reçoivent un argument Nom de l’argument _ et en ligne de la définition de type
- Ajouter des commentaires pour des descriptions dans la ligne au-dessus de la définition du champ
- En utilisez toujours comme type de retour
- Gardez une ligne vide après chaque définition de la fonction
- Enveloppez vos fonctions dans un espace de noms, les fonctions sont généralement l’espace de noms que vous devez utiliser pour ne pas entrer en conflit avec d’autres outils sur lesquels le modèle aurait pu être formé.
<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2025-06-28Reasoning: high
# Valid channels: analysis, commentary, final. Channel must be included for every message.
Calls to these tools must go to the commentary channel: 'functions'.<|end|><|start|>developer<|message|># Instructions
Use a friendly tone.
# Tools
## functions
namespace functions {
// Gets the location of the user.
type get_location = () => any;
// Gets the current weather in the provided location.
type get_current_weather = (_: {
// The city and state, e.g. San Francisco, CA
location: string,
format?: "celsius" | "fahrenheit", // default: celsius
}) => any;
// Gets the current weather in the provided list of locations.
type get_multiple_weathers = (_: {
// List of city and state, e.g. ("San Francisco, CA", "New York, NY")
locations: string(),
format?: "celsius" | "fahrenheit", // default: celsius
}) => any;
} // namespace functions<|end|><|start|>user<|message|>What is the weather like in SF?<|end|><|start|>assistant
Réception des appels d’outils
Si le modèle décide d’appeler un outil, il définira un destinataire dans l’en-tête du message à l’aide du format vers = {nom}. Par exemple, s’il décide de déclencher la fonction get_current_weather d’en haut, il spécifierait à = fonctions.get_current_weather dans l’en-tête et le commentaire comme canal comme spécifié dans le message système. Le destinataire peut être défini dans la section Rôle ou canal de l’en-tête.
Le modèle peut également spécifier un jeton <| contrainte |> pour indiquer le type d’entrée pour l’appel à l’outil. Dans ce cas, car il est passé en tant que JSON, la <| contrain |> est définie sur JSON.
<|channel|>analysis<|message|>Need to use function get_weather.<|end|><|start|>assistant<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"location":"San Francisco"}<|call|>
Traiter les appels d’outils
Une fois l’appel de fonction géré, la sortie doit être rétablie au modèle en spécifiant un nouveau message d’outil avec la sortie après le message d’appel. Un message d’outil a le format suivant:
<|start|>{toolname} to=assistant<|channel|>commentary<|message|>{output}<|end|>
Donc dans l’exemple ci-dessus
<|start|>functions.get_weather to=assistant<|channel|>commentary<|message|>{"sunny": true, "temperature": 20}<|end|>
Une fois la sortie recueillie pour les appels d’outils, l’inférence peut être exécutée avec le contenu complet:
<|start|>system<|message|>You are ChatGPT, a large language model trained by OpenAI.
Knowledge cutoff: 2024-06
Current date: 2025-06-28Reasoning: high
# Valid channels: analysis, commentary, final. Channel must be included for every message.
Calls to these tools must go to the commentary channel: 'functions'.<|end|><|start|>developer<|message|># Instructions
Use a friendly tone.
# Tools
## functions
namespace functions {
// Gets the location of the user.
type get_location = () => any;
// Gets the current weather in the provided location.
type get_current_weather = (_: {
// The city and state, e.g. San Francisco, CA
location: string,
format?: "celsius" | "fahrenheit", // default: celsius
}) => any;
// Gets the current weather in the provided list of locations.
type get_multiple_weathers = (_: {
// List of city and state, e.g. ("San Francisco, CA", "New York, NY")
locations: string(),
format?: "celsius" | "fahrenheit", // default: celsius
}) => any;
} // namespace functions<|end|><|start|>user<|message|>What is the weather like in SF?<|end|><|start|>assistant<|channel|>analysis<|message|>Need to use function get_weather.<|end|><|start|>assistant<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"location":"San Francisco"}<|call|> <|start|>functions.get_weather to=assistant<|channel|>commentary<|message|>{"sunny": true, "temperature": 20}<|end|><|start|>assistant
Sortie structurée
Pour contrôler le comportement de sortie du modèle, un format de réponse peut être défini à la fin du message du développeur avec la structure suivante:
# Response Formats## {format name}
// {description or context}
{schema}<|end|>
À titre d’exemple, voici un message de développeur qui définit un schéma pour une liste de courses:
<|start|>developer<|message|># InstructionsYou are a helpful shopping assistant
# Response Formats
## shopping_list
{"properties":{"items":{"type":"array","description":"entries on the shopping list","items":{"type":"string"}}},"type":"object"}<|end|><|start|>user<|message|>I need to buy coffee, soda and eggs<|end|><|start|>assistant
