Redéfinir l'IA générative : utiliser la structure pour améliorer la précision des résultats

L'IA générative structurée permet aux modèles d'IA générative de générer des résultats dans des formats spécifiques. Cette approche évite les erreurs de syntaxe en limitant la sélection de jetons aux options valides, garantissant ainsi des requêtes exécutables et des structures de données analysables. De plus, une tokenisation cohérente de la ponctuation et des mots-clés simplifie les modèles que les modèles doivent apprendre, réduisant ainsi le temps de formation et améliorant la précision. En exploitant la connaissance des structures de sortie, l’IA générative structurée fournit un outil puissant pour traduire le langage naturel dans divers formats structurés.

Redefining Generative AI: Embracing Structure for Enhanced Output Precision

Redéfinir l'IA générative : adopter une structure pour une précision de sortie améliorée

Introduction

Introduction

Generative AI, a transformative technology revolutionizing natural language processing, has made significant strides in generating coherent and grammatically sound text. However, when it comes to producing structured output, such as SQL queries or JSON data, generative AI often falters, succumbing to errors that hinder the execution or parsing of the generated code.

L'IA générative, une technologie transformatrice qui révolutionne le traitement du langage naturel, a fait des progrès significatifs dans la génération de textes cohérents et grammaticalement corrects. Cependant, lorsqu’il s’agit de produire des sorties structurées, telles que des requêtes SQL ou des données JSON, l’IA générative échoue souvent, succombant à des erreurs qui entravent l’exécution ou l’analyse du code généré.

Enter Structured Generative AI

Entrez dans l’IA générative structurée

To overcome this limitation, we introduce the concept of "structured generative AI," a powerful technique that constrains the generative process within predefined formats, virtually eliminating syntax errors and ensuring the validity of the output. By leveraging the knowledge of the output language's structure, structured generative AI ensures that only legitimate tokens are considered during generation, effectively eliminating syntactical errors.

Pour surmonter cette limitation, nous introduisons le concept « d'IA générative structurée », une technique puissante qui contraint le processus génératif dans des formats prédéfinis, éliminant pratiquement les erreurs de syntaxe et garantissant la validité du résultat. En tirant parti de la connaissance de la structure du langage de sortie, l'IA générative structurée garantit que seuls les jetons légitimes sont pris en compte lors de la génération, éliminant ainsi efficacement les erreurs syntaxiques.

Mechanism of Token Generation

Mécanisme de génération de jetons

Generative AI models, such as transformer architectures, generate tokens sequentially, relying on the input and previously generated tokens to determine the next selection. At each step, a classifier assigns probability values to all tokens in the vocabulary, guiding the selection of the next token.

Les modèles d'IA génératifs, tels que les architectures de transformateur, génèrent des jetons de manière séquentielle, en s'appuyant sur l'entrée et les jetons générés précédemment pour déterminer la sélection suivante. À chaque étape, un classificateur attribue des valeurs de probabilité à tous les jetons du vocabulaire, guidant la sélection du jeton suivant.

Constraining Token Generation

Contraindre la génération de jetons

Structured generative AI incorporates knowledge of the output language's structure to limit token generation. Illegitimate tokens, such as incorrect punctuation or invalid keywords, have their probabilities set to infinity (negative infinity), effectively excluding them from consideration. For instance, if a valid SQL query requires a comma after "SELECT name," all other token probabilities are set to infinity, ensuring that only a comma can be selected.

L'IA générative structurée intègre la connaissance de la structure du langage de sortie pour limiter la génération de jetons. Les jetons illégitimes, tels qu'une ponctuation incorrecte ou des mots-clés invalides, ont leurs probabilités fixées à l'infini (infini négatif), ce qui les exclut effectivement de toute considération. Par exemple, si une requête SQL valide nécessite une virgule après « SELECT nom », toutes les autres probabilités de jeton sont définies sur l'infini, garantissant que seule une virgule peut être sélectionnée.

Implementation with Hugging Face

Mise en œuvre avec Hugging Face

Hugging Face, a leading provider of pretrained models and tools for natural language processing, offers a convenient way to implement structured generative AI through its "logits processor" feature. This feature allows users to define a custom function that modifies the token probabilities after they have been calculated but before the final selection is made.

Hugging Face, l'un des principaux fournisseurs de modèles et d'outils pré-entraînés pour le traitement du langage naturel, propose un moyen pratique de mettre en œuvre une IA générative structurée grâce à sa fonctionnalité « processeur logits ». Cette fonctionnalité permet aux utilisateurs de définir une fonction personnalisée qui modifie les probabilités des jetons après leur calcul mais avant que la sélection finale ne soit effectuée.

Example: SQL Query Generation

Exemple : génération de requêtes SQL

To demonstrate the power of structured generative AI, let's consider the task of generating SQL queries from natural language. We initialize a pretrained BART model and define a set of rules that specify which tokens are allowed to follow each other in a valid SQL query.

Pour démontrer la puissance de l'IA générative structurée, considérons la tâche consistant à générer des requêtes SQL à partir du langage naturel. Nous initialisons un modèle BART pré-entraîné et définissons un ensemble de règles qui spécifient quels jetons sont autorisés à se suivre dans une requête SQL valide.

rules = {'': ['SELECT', 'DELETE'], # beginning of the generation
règles = {'
         'SELECT': ['name', 'email', 'id'],  # names of columns in our schema
'SELECT' : ['name', 'email', 'id'], # noms de colonnes dans notre schéma
         'DELETE': ['name', 'email', 'id'],
'DELETE' : ['nom', 'email', 'id'],
         'name': [',', 'FROM'],
'nom' : [',', 'DE'],
         'email': [',', 'FROM'],
'email de'],
         'id': [',', 'FROM'],
'identifiant' : [',', 'DE'],
         ',': ['name', 'email', 'id'],
',' : ['nom', 'e-mail', 'identifiant'],
         'FROM': ['customers', 'vendors'],  # names of tables in our schema
'FROM' : ['clients', 'fournisseurs'], # noms de tables dans notre schéma
         'customers': [''],
'clients': ['
         'vendors': [''],  # end of the generation}

Using these rules, we create a logits processor that converts the rules into token IDs and modifies the token probabilities accordingly.

'vendeurs': ['

Results: Enhanced SQL Query Generation

Résultats : génération de requêtes SQL améliorée

Running the BART model with the logits processor yields significant improvements in the quality of generated SQL queries. The model now adheres to the predefined rules, producing syntactically correct queries that can be executed without errors.

L'exécution du modèle BART avec le processeur logits entraîne des améliorations significatives dans la qualité des requêtes SQL générées. Le modèle adhère désormais aux règles prédéfinies, produisant des requêtes syntaxiquement correctes qui peuvent être exécutées sans erreurs.

to_translate = 'customers emails from the us'
to_translate = 'e-mails des clients en provenance des États-Unis'
words = to_translate.split()
mots = to_translate.split()
tokenized_text = tokenizer([words], is_split_into_words=True, return_offsets_mapping=True)
tokenized_text = tokenizer([mots], is_split_into_words=True, return_offsets_mapping=True)
logits_processor = LogitsProcessorList([SQLLogitsProcessor(tokenizer)])
logits_processor = LogitsProcessorList([SQLLogitsProcessor(tokenizer)])
out = pretrained_model.generate(
out = pretrained_model.generate(
    torch.tensor(tokenized_text["input_ids"]),
torch.tensor(tokenized_text["input_ids"]),
    max_new_tokens=20,
max_new_tokens=20,
    logits_processor=logits_processor)

The Significance of Tokenization

logits_processor=logits_processor)L'importance de la tokenisation

Tokenization, the process of converting text into a sequence of tokens, plays a crucial role in structured generative AI. Consistent tokenization ensures that similar concepts and punctuation are represented by the same token, simplifying the model's learning process. For instance, adding spaces before words and punctuation enhances consistency and reduces the complexity of patterns that the model needs to learn.

La tokenisation, le processus de conversion de texte en une séquence de jetons, joue un rôle crucial dans l'IA générative structurée. Une tokenisation cohérente garantit que les concepts et les signes de ponctuation similaires sont représentés par le même jeton, simplifiant ainsi le processus d'apprentissage du modèle. Par exemple, l'ajout d'espaces avant les mots et la ponctuation améliore la cohérence et réduit la complexité des modèles que le modèle doit apprendre.

Applications of Structured Generative AI

Applications de l'IA générative structurée

The applications of structured generative AI extend far beyond SQL query generation. It empowers various tasks, including:

Les applications de l’IA générative structurée s’étendent bien au-delà de la génération de requêtes SQL. Il autorise diverses tâches, notamment :

• JSON Data Extraction: Generating structured JSON data from natural language, enabling seamless data parsing and storage.
• Query Generation: Creating executable queries for various database systems, facilitating efficient information retrieval.
• Code Generation: Producing valid code snippets in different programming languages, accelerating software development.

Conclusion

Extraction de données JSON : génération de données JSON structurées à partir d'un langage naturel, permettant une analyse et un stockage transparents des données. Génération de requêtes : création de requêtes exécutables pour divers systèmes de bases de données, facilitant une récupération efficace des informations. Génération de code : production d'extraits de code valides dans différents langages de programmation, accélérant le développement de logiciels .Conclusion

Structured generative AI is a groundbreaking technique that dramatically enhances the precision and applicability of generative AI models. By incorporating knowledge of the output language's structure, structured generative AI eliminates syntax errors and guarantees the executability of generated code. This breakthrough enables a wide range of applications, empowering users to extract information, generate queries, and produce code more efficiently and accurately.

L'IA générative structurée est une technique révolutionnaire qui améliore considérablement la précision et l'applicabilité des modèles d'IA générative. En intégrant la connaissance de la structure du langage de sortie, l'IA générative structurée élimine les erreurs de syntaxe et garantit l'exécutabilité du code généré. Cette avancée permet une large gamme d'applications, permettant aux utilisateurs d'extraire des informations, de générer des requêtes et de produire du code de manière plus efficace et plus précise.