Introduire des sorties structurées dans l’API OpenAI
OpenAI a introduit des sorties structurées dans l’API, conçues pour renforcer le respect strict des schémas JSON fournis par les développeurs.
Cela s’appuie sur les fondations posées par le mode JSON précédent, qui fournissait un cadre pour générer des sorties JSON valides.
Bien que le mode JSON ait amélioré la fiabilité des sorties, il ne garantissait pas que la réponse du modèle soit conforme à un schéma spécifique.
Les sorties structurées remédient à ce problème en donnant aux développeurs l’assurance que les sorties générées par le modèle correspondront exactement aux schémas JSON spécifiés.
Cette fonctionnalité est particulièrement importante pour les développeurs qui travaillent sur des applications exigeant un traitement précis et cohérent des données, où tout écart par rapport au format de sortie attendu peut entraîner des problèmes d’intégration ou des erreurs dans les processus en aval.
Grâce aux sorties structurées, les modèles OpenAI peuvent désormais produire des réponses qui sont des JSON valides et précisément structurées selon les exigences définies par les développeurs, ce qui élimine la nécessité d’un post-traitement étendu ou d’une validation manuelle, rationalise le processus de développement et réduit le risque d’erreurs.
Résoudre les défis du monde réel avec les sorties structurées
Les sorties structurées sont conçues pour relever le défi complexe de la génération de données structurées à partir d’entrées non structurées, une tâche de plus en plus courante dans les applications modernes d’intelligence artificielle.
Concrètement, cela signifie que les développeurs peuvent désormais convertir de manière fiable des données désordonnées et de forme libre en formats bien organisés et lisibles par les machines.
Dans les flux de travail plus avancés, tels que les processus agentiques à plusieurs étapes où un modèle d’intelligence artificielle prend des mesures séquentielles basées sur les entrées de l’utilisateur, les sorties structurées offrent un moyen fiable de gérer le flux d’informations entre les différentes étapes.
Les développeurs peuvent maintenir la cohérence du format des données tout au long du processus pour créer des applications plus robustes et plus évolutives, sachant que l’IA traitera les données de manière prévisible.
Rompre avec les anciennes contraintes
Avant l’introduction des sorties structurées, les développeurs étaient confrontés à des difficultés majeures pour s’assurer que les sorties générées par l’IA étaient conformes à des formats spécifiques, ce qui les obligeait généralement à recourir à des outils open-source, à des invites personnalisées et à des appels répétés à l’API pour obtenir les résultats souhaités.
L’absence de mécanisme intégré pour faire respecter la structure de sortie signifiait que même de petites déviations pouvaient entraîner un dépannage et un remaniement fastidieux.
Les sorties structurées résolvent directement ces problèmes en intégrant l’adhésion au schéma dans le modèle lui-même.
OpenAI a entraîné ses modèles à mieux comprendre et à se conformer à des schémas complexes, ce qui simplifie le processus de développement, car les développeurs n’ont plus besoin de recourir à des solutions de contournement pour obtenir le format de sortie souhaité.
Les développeurs peuvent se concentrer davantage sur les fonctionnalités essentielles de leurs applications plutôt que sur la gestion des incohérences dans les résultats de l’IA, ce qui accélère le temps de développement et améliore la fiabilité des applications construites sur les modèles d’OpenAI, car elles sont mieux adaptées aux environnements de production.
Pourquoi les sorties structurées sont-elles plus performantes que les modèles précédents ?
Dans les évaluations qui testent l’adhésion à des schémas JSON complexes, gpt-4o-2024-08-06 a obtenu un score de 100 %, ce qui représente une amélioration considérable par rapport au modèle précédent gpt-4-0613, qui a obtenu un score inférieur à 40 %.
Cette précision est essentielle pour les développeurs qui conçoivent des applications nécessitant un formatage exact des données, car tout écart peut entraîner des erreurs coûteuses ou des défaillances du système.
Comment mettre en œuvre les sorties structurées dans votre flux de travail ?
L’intégration des sorties structurées dans votre flux de travail de développement est simple, avec deux méthodes principales disponibles en fonction de votre cas d’utilisation :
- Appel de fonction : Les sorties structurées peuvent être activées via des outils en définissant le paramètre strict : true dans la définition de la fonction.
Ce paramètre est compatible avec tous les modèles à partir de gpt-4-0613.
Les développeurs peuvent s’assurer que les sorties du modèle seront conformes à la définition de l’outil, ce qui facilite l’intégration des données générées par l’IA dans les systèmes et flux de travail existants.
L’appel de fonction est particulièrement utile pour les scénarios dans lesquels le modèle interagit avec des API ou des services externes, car les résultats sont conformes au format requis sans nécessiter de traitement supplémentaire.
- Paramètre de format de réponse : Pour les cas où le modèle répond directement à l’utilisateur de manière structurée, les développeurs peuvent spécifier un schéma JSON via l’option json_schema dans le paramètre response_format.
Cette option est supportée par les derniers modèles GPT-4o, y compris gpt-4o-2024-08-06 et gpt-4o-mini-2024-07-18.
Elle est particulièrement utile dans les applications où un formatage précis des données est nécessaire, comme dans les soumissions de formulaires, la génération de rapports, etc.
Les deux méthodes permettent aux développeurs de choisir l’implémentation la plus appropriée en fonction de leurs besoins spécifiques.
En tirant parti de ces caractéristiques, les développeurs peuvent élaborer des solutions basées sur l’IA plus fiables, plus évolutives et plus efficaces, qui répondent aux normes rigoureuses des entreprises modernes.
Construire avec des sorties structurées prises en charge par le SDK
Comment les sorties structurées améliorent la sécurité
Les sorties structurées sont conçues de manière à ce que la sécurité soit une priorité absolue.
En pratique, cela signifie que les modèles sont équipés pour traiter les demandes potentiellement dangereuses en refusant de générer des sorties qui pourraient enfreindre ces lignes directrices.
Lorsqu’une demande déclenche un problème de sécurité, la réponse du modèle inclut une chaîne de refus spéciale dans la réponse de l’API, ce qui permet aux développeurs de détecter par programme l’existence d’un refus et d’indiquer clairement que le modèle a décidé de ne pas donner suite à la demande.
Le mécanisme de détection est utile dans les systèmes automatisés où une surveillance humaine immédiate n’est pas toujours possible.
Les développeurs peuvent utiliser cette chaîne de refus pour mettre en œuvre des procédures de repli ou des mécanismes d’alerte, afin que leurs applications restent à la fois sûres et fonctionnelles sans intervention manuelle.
Rationalisez le développement grâce à la prise en charge du SDK natif
OpenAI a rendu plus facile que jamais la mise en œuvre des sorties structurées en introduisant un support natif dans ses SDK Python et Node.
Cela rationalise le processus de développement en permettant aux développeurs de définir des schémas directement dans leur code en utilisant des bibliothèques familières comme Pydantic pour Python et Zod pour Node.js.
Ces bibliothèques sont largement utilisées dans la communauté des développeurs pour définir et valider les structures de données, et sont naturellement adaptées à la gestion des schémas JSON dans le contexte des sorties structurées.
Grâce à la prise en charge native, les développeurs peuvent désormais incorporer les sorties structurées dans leurs applications sans avoir besoin d’un code personnalisé important.
Les SDK se chargent des tâches les plus lourdes, en convertissant automatiquement les types de données, en sérialisant et désérialisant les réponses JSON et en gérant les refus.
Pour les développeurs travaillant dans des environnements rapides, où le temps de mise sur le marché est un facteur clé, une intégration rationalisée fait une grande différence.
Les SDK d’OpenAI permettent aux développeurs de créer des applications conformes aux schémas avec plus d’efficacité et moins de ressources.
Utilisation innovante des sorties structurées
Concevoir des interfaces dynamiques et affiner les réponses plus facilement
Les sorties structurées ouvrent de nouvelles possibilités pour générer dynamiquement des interfaces utilisateur (IU) basées sur les entrées de l’utilisateur.
Les développeurs peuvent créer des systèmes alimentés par l’IA qui réagissent aux actions de l’utilisateur en temps réel, en générant des interfaces utilisateur personnalisées qui correspondent à l’intention de l’utilisateur.
Par exemple, une application peut utiliser les sorties structurées pour générer différents formulaires ou tableaux de bord en fonction des sélections de l’utilisateur ou des données saisies.
Les sorties structurées constituent également un moyen efficace d’améliorer la qualité des réponses en séparant la réponse finale du raisonnement ou des commentaires supplémentaires, ce qui permet aux développeurs de créer des systèmes d’IA qui fournissent des sorties plus soignées et plus cohérentes, dans lesquelles la réponse principale est clairement distinguée de toute information supplémentaire.
Extraire et structurer des données à partir de n’importe quelle source
Dans les entreprises, où les données se présentent sous différentes formes (notes de réunion, courriers électroniques, etc.), les sorties structurées constituent une méthode fiable pour organiser ces informations dans des formats utilisables.
Par exemple, un modèle équipé de sorties structurées peut être chargé d’extraire des détails clés tels que les tâches, les dates d’échéance et les affectations d’un ensemble de notes de réunion.
En traitant le texte non structuré et en l’organisant selon un schéma prédéfini, l’IA aide à transformer des informations éparses en un format structuré qui peut être facilement intégré dans des outils de gestion de projet ou des bases de données.
Qu’il s’agisse d’extraire les mesures à prendre d’une conférence téléphonique ou de classer les commentaires des clients par catégorie, les sorties structurées garantissent que les données importantes sont capturées et organisées de manière systématique, réduisant ainsi le risque d’oubli et améliorant l’efficacité opérationnelle.
La puissance du décodage contraint
Les sorties structurées s’appuient sur une méthode sophistiquée connue sous le nom d’échantillonnage contraint ou de décodage contraint pour garantir que les sorties s’alignent précisément sur le schéma JSON fourni par le développeur.
Le système fonctionne en déterminant dynamiquement quels tokens (les plus petites unités de langage, comme les mots ou les symboles) sont valides à chaque étape du processus de génération.
Après la génération de chaque token, le système évalue le prochain token valide, sur la base du schéma JSON fourni par le développeur, afin d’éviter que l’intelligence artificielle ne commette des erreurs susceptibles d’entraîner des sorties JSON invalides ou mal formées.
Ce qui distingue Structured Outputs, c’est son utilisation de la grammaire sans contexte (CFG) pour guider ce processus d’échantillonnage de jetons.
La CFG est plus avancée et plus flexible que les méthodes traditionnelles telles que les machines à états finis (FSM) ou les expressions régulières (regex).
Alors que les FSM et les regex conviennent aux tâches les plus simples, elles ne permettent pas de gérer les structures de données complexes, imbriquées ou récursives que l’on trouve souvent dans les schémas JSON du monde réel.
CFG, en revanche, peut gérer ces complexités avec facilité, en s’assurant que même les schémas les plus complexes sont respectés sans erreur.
6 limitations des sorties structurées et comment y remédier
Bien que les sorties structurées offrent une solution pour générer des sorties conformes aux schémas, il est important de comprendre les limites et les restrictions associées à cette fonctionnalité afin de gérer les attentes et de garantir une mise en œuvre correcte.
- Sous-ensemble de schéma : Les sorties structurées ne prennent actuellement en charge qu’un sous-ensemble de la spécification complète JSON Schema.
Cette restriction est intentionnelle et vise à optimiser les performances et la fiabilité en se concentrant sur les fonctionnalités les plus couramment utilisées et les plus critiques de JSON Schema.
Les développeurs doivent consulter la documentation pour comprendre quelles caractéristiques du schéma sont prises en charge et planifier leurs implémentations en conséquence.
- Temps de latence : Lors de la première utilisation d’un nouveau schéma, les développeurs peuvent constater une latence supplémentaire pendant que le système traite le schéma, ce qui peut prendre jusqu’à une minute pour les schémas complexes.
Les réponses suivantes sont beaucoup plus rapides, car le système met en cache les composants nécessaires pour accélérer les demandes ultérieures.
La latence initiale doit être prise en compte dans la planification, en particulier pour les applications où le temps de réponse est critique.
- Adhésion au schéma : Dans certains cas, le modèle peut ne pas respecter le schéma.
Cela peut se produire si le modèle refuse une demande jugée dangereuse, s’il atteint le nombre maximal de jetons avant de terminer la sortie, ou s’il rencontre une autre condition d’arrêt prédéfinie.
Les développeurs doivent concevoir leurs applications de manière à gérer ces cas potentiels, éventuellement en mettant en place des mécanismes de repli ou des flux de travail alternatifs.
- Erreurs de modèle : Si les sorties structurées permettent de s’assurer que le format des données est correct, elles n’empêchent pas tous les types d’erreurs.
Le modèle peut toujours commettre des erreurs dans les valeurs des objets JSON, comme des erreurs de calcul ou des entrées de données incorrectes.
Les développeurs doivent valider le contenu des données JSON.
- Appels de fonctions parallèles : Les sorties structurées ne sont pas compatibles avec les appels de fonctions parallèles.
Lorsque des appels de fonctions parallèles sont utilisés, la sortie peut ne pas correspondre aux schémas fournis, ce qui peut entraîner des incohérences dans les données.
Les développeurs doivent désactiver les appels de fonctions parallèles lorsqu’ils utilisent les sorties structurées ou envisager d’autres méthodes pour gérer les tâches parallèles.
- Zéro rétention de données : Les schémas JSON utilisés avec les sorties structurées ne sont pas éligibles pour la rétention zéro des données (ZDR), ce qui signifie que les données associées à ces schémas peuvent être conservées conformément aux politiques de rétention des données de l’OpenAI.
Cette limitation est essentielle à prendre en compte pour les applications traitant des données sensibles ou réglementées où la conformité avec les lois sur la confidentialité des données est une préoccupation majeure.
Les développeurs doivent comprendre ces limites s’ils veulent prendre des décisions éclairées sur le moment et la manière d’utiliser les sorties structurées dans leurs projets.
Tirez le meilleur parti des sorties structurées
Les sorties structurées sont désormais entièrement disponibles dans l’API OpenAI, et sont accessibles pour plusieurs modèles, y compris les dernières séries gpt-4o et gpt-4o-mini, ainsi que les modèles qui sont disponibles depuis gpt-4-0613.
L’une des raisons les plus convaincantes d’opter pour le modèle gpt-4o-2024-08-06 est la réduction des coûts qu’il permet.
Les développeurs peuvent réduire de 50 % les coûts d’entrée, ce qui ramène le prix à 2,50 dollars pour 1 million de jetons d’entrée.
Les coûts de sortie sont également réduits de 33 %, avec un prix de 10,00 $ pour 1 million de jetons de sortie.
En profitant de ces économies, les entreprises peuvent réduire leurs coûts globaux liés à l’IA tout en bénéficiant des capacités avancées des sorties structurées.
La rentabilité fait du nouveau modèle gpt-4o-2024-08-06 une option viable pour les entreprises qui cherchent à optimiser leurs investissements dans l’IA sans compromettre les performances ou la fiabilité.
