OpenAI / GPT-OSS: GPT-OSS-120B et GPT-OSS-20B sont deux modèles de langue ouverte par OpenAI

Essayez GPT-ASS ·
Guides ·
Carte modèle ·
Blog Openai

Téléchargez GPT-OSS-120B et GPT-OSS-20B sur le visage des câlins

Bienvenue dans la série GPT-OSS, les modèles ouverts d'Openai conçus pour un raisonnement puissant, des tâches agentiques et des cas d'utilisation des développeurs polyvalents.

Nous publions deux saveurs de ces modèles ouverts:

• gpt-oss-120b – Pour la production, usage général, des cas d'utilisation de raisonnement élevé qui s'adaptent dans un seul GPU de 80 Go (comme NVIDIA H100 ou AMD MI300X) (paramètres 117b avec des paramètres actifs 5.1b)
• gpt-oss-20b – Pour une latence plus faible et des cas d'utilisation locaux ou spécialisés (paramètres 21b avec des paramètres actifs 3,6b)

Les deux modèles ont été formés à l'aide de notre format de réponse Harmony et ne doivent être utilisés qu'avec ce format; Sinon, ils ne fonctionneront pas correctement.

• Licence APACHE 2.0 permissive: Construisez librement sans restrictions de copyleft ni risque de brevet – idéal pour l'expérimentation, la personnalisation et le déploiement commercial.
• Effort de raisonnement configurable: Ajustez facilement l'effort de raisonnement (faible, moyen, élevé) en fonction de votre cas d'utilisation spécifique et de vos besoins de latence.
• Chaîne complète de pensées: Fournit un accès complet au processus de raisonnement du modèle, facilitant un débogage plus facile et une plus grande confiance dans les résultats. Ces informations ne sont pas destinées à être affichées pour mettre fin aux utilisateurs.
• Tournable fin: Personnalisez entièrement les modèles à votre cas d'utilisation spécifique via le réglage des paramètres.
• Capacités agentiques: Utilisez les capacités natives des modèles pour l'appel de fonction, la navigation Web, l'exécution du code Python et les sorties structurées.
• Quantification MXFP4: Les modèles étaient post-formés avec une quantification MXFP4 des poids MOE, faisant gpt-oss-120b Exécutez sur un seul GPU de 80 Go (comme NVIDIA H100 ou AMD MI300X) et le gpt-oss-20b Modèle exécuté dans les 16 Go de la mémoire. Tous les évals ont été effectués avec la même quantification MXFP4.

Vous pouvez utiliser gpt-oss-120b et gpt-oss-20b avec la bibliothèque Transformers. Si vous utilisez le modèle de chat de Transformers, il appliquera automatiquement le format de réponse Harmony. Si vous utilisez model.generate Directement, vous devez appliquer le format Harmony manuellement à l'aide du modèle de chat ou utiliser notre openai-harmony emballer.

from transformers import pipeline
import torch

model_id = "openai/gpt-oss-120b"

pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Explain quantum mechanics clearly and concisely."},
]

outputs = pipe(
    messages,
    max_new_tokens=256,
)
print(outputs[0]["generated_text"][-1])

En savoir plus sur la façon d'utiliser GPT-ASS avec Transformers.

VLLM recommande d'utiliser uv pour la gestion de la dépendance Python. Vous pouvez utiliser VLLM pour faire tourner un serveur Web compatible OpenAI. La commande suivante téléchargera automatiquement le modèle et démarrera le serveur.

uv pip install --pre vllm==0.10.1+gptoss \
    --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
    --extra-index-url https://download.pytorch.org/whl/nightly/cu128 \
    --index-strategy unsafe-best-match

vllm serve openai/gpt-oss-20b

En savoir plus sur la façon d'utiliser GPT-ASS avec VLLM.

Ces implémentations sont en grande partie des implémentations de référence à des fins éducatives et ne devraient pas être gérées en production.

En savoir plus ci-dessous.

Si vous essayez de courir gpt-oss Sur le matériel des consommateurs, vous pouvez utiliser Olllama en exécutant les commandes suivantes après l'installation d'Olllama.

# gpt-oss-20b
ollama pull gpt-oss:20b
ollama run gpt-oss:20b

# gpt-oss-120b
ollama pull gpt-oss:120b
ollama run gpt-oss:120b

En savoir plus sur la façon d'utiliser GPT-ASS avec Olllama.

Si vous utilisez LM Studio, vous pouvez utiliser les commandes suivantes pour télécharger.

# gpt-oss-20b
lms get openai/gpt-oss-20b
# gpt-oss-120b
lms get openai/gpt-oss-120b

Consultez notre liste impressionnante pour une collection plus large de ressources GPT-ASS et de partenaires d'inférence.

Ce référentiel fournit une collection d'implémentations de référence:

• Inférence:
  • torch – Une mise en œuvre non optimisée Pytorch à des fins éducatives uniquement. Nécessite au moins 4 × GPU H100 en raison du manque d'optimisation.
  • triton – Une implémentation plus optimisée utilisant Pytorch & Triton incl. Utilisation de graphiques CUDA et de mise en cache de base
  • metal – Une implémentation spécifique au métal pour l'exécution des modèles sur le matériel d'Apple Silicon
• Outils:
  • browser – Une mise en œuvre de référence de l'outil de navigateur sur lequel les modèles ont été formés
  • python – Une implémentation de référence sans état de l'outil Python sur lequel le modèle a été formé
• Exemples du client:
  • chat – Une application de chat terminale de base qui utilise les implémentations Pytorch ou Triton pour l'inférence avec les outils de python et de navigateur
  • responses_api – Un exemple de serveur compatible API de réponses qui implémente l'outil de navigateur avec d'autres fonctionnalités compatibles avec les réponses

• Python 3.12
• Sur macOS: installez les outils CLI Xcode -> xcode-select --install
• Sur Linux: ces implémentations de référence nécessitent CUDA
• Sur Windows: ces implémentations de référence n'ont pas été testées sur Windows. Essayez d'utiliser des solutions comme Olllama si vous essayez d'exécuter le modèle localement.

Si vous souhaitez essayer l'un des code, vous pouvez l'installer directement à partir de PYPI

# if you just need the tools
pip install gpt-oss
# if you want to try the torch implementation
pip install gpt-oss[torch]
# if you want to try the triton implementation
pip install gpt-oss[triton]

Si vous souhaitez modifier le code ou essayer l'implémentation de métal, définissez le projet localement:

git clone https://github.com/openai/gpt-oss.git
GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"

Vous pouvez télécharger les poids du modèle à partir du hub de face étreint directement à partir de CLI Face CLI:

# gpt-oss-120b
hf download openai/gpt-oss-120b --include "original/*" --local-dir gpt-oss-120b/

# gpt-oss-20b
hf download openai/gpt-oss-20b --include "original/*" --local-dir gpt-oss-20b/

Nous incluons une implémentation de Pytorch de référence inefficace dans gpt_oss / torch / model.py. Ce code utilise des opérateurs de base Pytorch pour montrer l'architecture du modèle exact, avec un petit ajout de parallélisme du tenseur de support dans le MOE afin que le modèle plus grand puisse fonctionner avec ce code (par exemple, sur 4xh100 ou 2xh200). Dans cette implémentation, nous avons mis en œuvre tous les poids à BF16 et exécuté le modèle dans BF16.

Pour exécuter l'implémentation de référence, installez les dépendances:

pip install -e ".[torch]"

Puis courez:

# On 4xH100:
torchrun --nproc-per-node=4 -m gpt_oss.generate gpt-oss-120b/original/

Nous incluons également une implémentation de référence optimisée qui utilise un noyau Triton MOE optimisé qui prend en charge MXFP4. Il a également une certaine optimisation sur le code d'attention pour réduire le coût de la mémoire. Pour exécuter cette implémentation, la version nocturne de Triton et Torch sera installée. Cette version peut être exécutée sur un seul GPU de 80 Go pour gpt-oss-120b.

Pour installer l'exécution de l'implémentation de Triton de référence

# You need to install triton from source to use the triton implementation
git clone https://github.com/triton-lang/triton
cd triton/
pip install -r python/requirements.txt
pip install -e . --verbose --no-build-isolation
pip install -e python/triton_kernels

# Install the gpt-oss triton implementation
pip install -e ".[triton]"

Puis courez:

# On 1xH100
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
python -m gpt_oss.generate --backend triton gpt-oss-120b/original/

Si vous rencontrez torch.OutOfMemoryErrorassurez-vous d'allumer l'allocateur extensible pour éviter les collisions lors du chargement des poids du point de contrôle.

De plus, nous fournissons une implémentation de référence pour que le métal fonctionne sur le silicium Apple. Cette implémentation n'est pas prête pour la production mais est exacte pour l'implémentation de Pytorch.

L'implémentation sera compilée automatiquement lors de l'exécution du .[metal] Installation sur un appareil en silicium Apple:

GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"

Pour effectuer une inférence, vous devrez d'abord convertir les poids de Safettensor de l'étreinte Face au bon format en utilisant:

python gpt_oss/metal/scripts/create-local-model.py -s <model_dir> -d <output_file>

Ou téléchargez les poids pré-convertis:

hf download openai/gpt-oss-120b --include "metal/*" --local-dir gpt-oss-120b/metal/
hf download openai/gpt-oss-20b --include "metal/*" --local-dir gpt-oss-20b/metal/

Pour le tester, vous pouvez courir:

python gpt_oss/metal/examples/generate.py gpt-oss-20b/metal/model.bin -p "why did the chicken cross the road?"

Avec le modèle, nous publions également une nouvelle bibliothèque de format de chat harmony pour interagir avec le modèle. Consultez ce guide pour plus d'informations sur l'harmonie.

Nous incluons également deux outils système pour le modèle: navigation et conteneur Python. Vérifiez GPT_OSS / TOOLLS pour l'implémentation de l'outil.

L'application Terminal Chat est un exemple de base de la façon d'utiliser le format Harmony avec les implémentations Pytorch, Triton et VLLM. Il expose également à la fois l'outil Python et le navigateur comme des outils facultatifs qui peuvent être utilisés.

usage: python -m gpt_oss.chat [-h] [-r REASONING_EFFORT] [-a] [-b] [--show-browser-results] [-p] [--developer-message DEVELOPER_MESSAGE] [-c CONTEXT] [--raw] [--backend {triton,torch,vllm}] FILE

Chat example

positional arguments:
  FILE                  Path to the SafeTensors checkpoint

options:
  -h, --help            show this help message and exit
  -r REASONING_EFFORT, --reasoning-effort REASONING_EFFORT
                        Reasoning effort (default: low)
  -a, --apply-patch     Make apply_patch tool available to the model (default: False)
  -b, --browser         Use browser tool (default: False)
  --show-browser-results
                        Show browser results (default: False)
  -p, --python          Use python tool (default: False)
  --developer-message DEVELOPER_MESSAGE
                        Developer message (default: )
  -c CONTEXT, --context CONTEXT
                        Max context length (default: 8192)
  --raw                 Raw mode (does not render Harmony encoding) (default: False)
  --backend {triton,torch,vllm}
                        Inference backend (default: triton)

Nous incluons également un exemple de serveur API de réponses. Ce serveur n'implémente pas toutes les fonctionnalités et événements de l'API de réponses, mais doit être compatible avec la plupart des cas d'utilisation de base et servir d'inspiration à toute personne qui construit son propre serveur. Certains de nos partenaires d'inférence offrent également leur propre API de réponses.

Vous pouvez démarrer ce serveur avec les backends d'inférence suivants:

• triton – utilise l'implémentation de Triton
• metal – utilise la mise en œuvre du métal sur le silicium Apple uniquement
• ollama – utilise l'API Olllama / API / Générer comme solution d'inférence
• vllm – utilise votre version VllM installée pour effectuer l'inférence
• transformers – Utilise votre version de Transformers installée pour effectuer une inférence locale

usage: python -m gpt_oss.responses_api.serve [-h] [--checkpoint FILE] [--port PORT] [--inference-backend BACKEND]

Responses API server

options:
  -h, --help                    show this help message and exit
  --checkpoint FILE             Path to the SafeTensors checkpoint
  --port PORT                   Port to run the server on
  --inference-backend BACKEND   Inference backend to use

Nous prenons en charge Codex en tant que client pour GPT-ASS. Pour exécuter la version 20B, définissez ceci sur ~/.codex/config.toml:

disable_response_storage = true
show_reasoning_content = true

[model_providers.local]
name = "local"
base_url = "http://localhost:11434/v1"

[profiles.oss]
model = "gpt-oss:20b"
model_provider = "local"

Cela fonctionnera avec tous les serveur compatible de CHAT Competions-API écoutant sur le port 11434, comme Olllama. Démarrez le serveur et le codex point sur le modèle OSS:

ollama run gpt-oss:20b
codex -p oss

Les deux modèles GPT-OSS ont été formés avec la capacité de parcourir browser outil qui expose les trois méthodes suivantes:

• search pour rechercher des phrases clés
• open Pour ouvrir une page particulière
• find Pour rechercher le contenu sur une page

Pour activer l'outil de navigateur, vous devrez placer la définition dans le system Message de votre invite formatée sur l'harmonie. Vous pouvez soit utiliser le with_browser_tool() Méthode si votre outil implémente l'interface complète ou modifiez la définition en utilisant with_tools(). Par exemple:

import datetime
from gpt_oss.tools.simple_browser import SimpleBrowserTool
from gpt_oss.tools.simple_browser.backend import ExaBackend
from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

# Exa backend requires you to have set the EXA_API_KEY environment variable
backend = ExaBackend(
    source="web",
)
browser_tool = SimpleBrowserTool(backend=backend)

# create a basic system prompt
system_message_content = SystemContent.new().with_conversation_start_date(
    datetime.datetime.now().strftime("%Y-%m-%d")
)

# if you want to use the browser tool
if use_browser_tool:
    # enables the tool
    system_message_content = system_message_content.with_tools(browser_tool.tool_config)
    # alternatively you could use the following if your tool is not stateless
    system_message_content = system_message_content.with_browser_tool()

# construct the system message
system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)

# create the overall prompt
messages = [system_message, Message.from_role_and_content(Role.USER, "What's the weather in SF?")]
conversation = Conversation.from_messages(messages)

# convert to tokens
token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)

# perform inference
# ...

# parse the output
messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
last_message = messages[-1]
if last_message.recipient.startswith("browser"):
  # perform browser call
  response_messages = await browser_tool.process(last_message)

  # extend the current messages and run inference again
  messages.extend(response_messages)

Pour contrôler la taille de la fenêtre de contexte, cet outil utilise une fenêtre de texte défileuse avec laquelle le modèle peut interagir. Il pourrait donc récupérer les 50 premières lignes d'une page, puis faire défiler vers les 20 lignes suivantes après cela. Le modèle a également été formé pour ensuite utiliser les citations de cet outil dans ses réponses.

Pour améliorer les performances, les demandes de caches d'outil afin que le modèle puisse revisiter une partie différente d'une page sans avoir à recharger la page. Pour cette raison, vous devez créer une nouvelle instance de navigateur pour chaque demande.

Le modèle a été formé pour utiliser un outil Python pour effectuer des calculs et d'autres actions dans le cadre de sa chaîne de pensées. Pendant la formation, le modèle a utilisé un outil avec état qui facilite les outils de course entre les boucles de lit Cette implémentation de référence utilise cependant un mode apatride. En conséquence, le Pythontool définit sa propre description d'outil pour remplacer la définition dans openai-harmony.

Pour activer l'outil Python, vous devrez placer la définition dans le system Message de votre invite formatée sur l'harmonie. Vous pouvez soit utiliser le with_python() Méthode si votre outil implémente l'interface complète ou modifiez la définition en utilisant with_tools(). Par exemple:

import datetime
from gpt_oss.tools.python_docker.docker_tool import PythonTool
from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName

encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)

python_tool = PythonTool()

# create a basic system prompt
system_message_content = SystemContent.new().with_conversation_start_date(
    datetime.datetime.now().strftime("%Y-%m-%d")
)

# if you want to use the python tool
if use_python_tool:
    # enables the tool making sure that the prompt gets set with the stateless tool description
    system_message_content = system_message_content.with_tools(python_tool.tool_config)
    # alternatively you could use the following if your tool is not stateless
    system_message_content = system_message_content.with_python()

# construct the system message
system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)

# create the overall prompt
messages = [system_message, Message.from_role_and_content(Role.USER, "What's the square root of 9001?")]
conversation = Conversation.from_messages(messages)

# convert to tokens
token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)

# perform inference
# ...

# parse the output
messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
last_message = messages[-1]
if last_message.recipient == "python":
  # perform python call
  response_messages = await python_tool.process(last_message)

  # extend the current messages and run inference again
  messages.extend(response_messages)

apply_patch Peut être utilisé pour créer, mettre à jour ou supprimer les fichiers localement.

Nous avons publié les modèles avec un support de quantification natif. Plus précisément, nous utilisons MXFP4 pour les poids de projection linéaires dans la couche MOE. Nous stockons le tenseur MOE en deux parties:

• tensor.blocks stocke les valeurs FP4 réelles. Nous emballons toutes les deux valeurs en une uint8 valeur.
• tensor.scales stocke l'échelle de bloc. La mise à l'échelle du bloc se fait parmi la dernière dimension pour tous les tenseurs MXFP4.

Tous les autres tenseurs seront dans BF16. Nous recommandons également d'utiliser BF16 comme précision d'activation du modèle.

Nous vous recommandons d'échantillonner avec temperature=1.0 et top_p=1.0.

Les implémentations de référence dans ce référentiel sont conçues comme un point de départ et une inspiration. En dehors des corrections de bogues, nous n'avons pas l'intention d'accepter de nouvelles contributions de fonctionnalités. Si vous créez des implémentations en fonction de ce code telles que de nouvelles implémentations d'outils, vous êtes invités à les contribuer à la awesome-gpt-oss.md déposer.