Utiliser l'IA générative avec Python

L'IA est l'avenir, et en tant qu'ingénieur logiciel, c'est le domaine le plus brûlant dans lequel se lancer. L'exploitation des LLM dans votre code vous permet de créer des applications plus intelligentes qui gèrent des tâches complexes telles que l'analyse des sentiments en temps réel ou l'interprétation du contenu généré par les utilisateurs. L'intégration de LLM rend votre logiciel plus réactif et plus performant, améliorant l'expérience utilisateur et l'automatisation.

Cet article est une introduction sur la façon d'effectuer des appels LLM à l'aide de Python afin que vous puissiez commencer à ajouter ces puissantes fonctionnalités à votre propre code.

Nous commencerons par créer un chatbot pour le personnage de votre choix. Ensuite, vous apprendrez à résumer des textes plus petits, et même à résumer des livres entiers. Enfin, vous apprendrez à ré-inviter et à analyser les résultats fournis par le LLM.

Faire notre première demande de LLM

Pour les demandes LLM, nous utiliserons Groq. Si vous y créez un compte, vous pouvez utiliser leur API et faire des demandes LLM gratuitement.

Afin d'utiliser Python pour ces requêtes, installez le package Groq python en exécutant pip install groq. Ensuite, nous l'importerons dans notre code comme ceci :

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

Assurez-vous de définir la clé API comme variable d'environnement.

Une simple demande de LLM peut être faite en ajoutant :

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Dans ce cas, nous demandons au LLM de nous expliquer ce qu'est la formule 1. La sortie de llama3-8b doit être imprimée une fois que vous avez exécuté le programme dans votre console. Vous pouvez jouer avec cela et changer de modèle, ainsi que l'invite.

Créer un chatbot personnalisé

Maintenant, créons un chatbot pour n'importe quel personnage que vous aimez, Mario, par exemple. Pour l’instant, le LLM répond sur un ton neutre/informatif. Cependant, en donnant au LLM un rôle système, nous pouvons nous assurer qu'il répond comme le ferait Mario, ajoutant de la personnalité et du plaisir à la conversation. Cela donne le ton aux interactions, vous obtiendrez donc des réponses ludiques et emblématiques comme « C'est un moi, Mario ! » pour que les choses restent engageantes.

Ajoutons un rôle système à notre demande :

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a super mario chatbot. Always answer in his style, and create witty responses."
        },
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Maintenant, le LLM va vous expliquer ce qu'est la Formule 1 en terme de Mario Kart !

Les rôles système sont également parfaits pour d'autres cas d'utilisation, comme les agents de support client virtuel, les tuteurs pédagogiques ou les assistants en écriture créative, en veillant à ce que le LLM réponde d'une manière qui correspond à l'ambiance et aux besoins spécifiques de chaque rôle.

Résumer le texte

Maintenant que nous savons un peu comment effectuer des requêtes LLM avec une invite et un rôle système spécifiques, essayons de créer un outil de synthèse.

Créez un fichier texte dans le même répertoire appelé article.txt et collez-le dans n'importe quel article de votre choix. Pour cette étape, assurez-vous que l'article n'est pas trop long.

Dans le code, chargeons d'abord ce texte.

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

Maintenant, créons une invite que nous pouvons envoyer au LLM, lui disant de résumer le texte sous forme de puces.

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Nous rédigeons d'abord l'invite, donnant au LLM des instructions claires et concises. Ensuite, nous fournissons le texte qu'il doit résumer.

Maintenant, tout ce que nous avons à faire est d'appeler le LLM avec cette invite que nous venons de créer :

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a super mario chatbot. Always answer in his style, and create witty responses."
        },
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Exécutez ceci et vous devriez voir un résumé à puces de l'article que vous avez donné au LLM !

Maintenant, essayez de coller un très long article, ou peut-être même un livre entier – comme la Métamorphose de Franz Kafka.

Remarquez que le LLM revient avec une erreur. Vous en avez trop donné pour résumer tout d'un coup.

Résumer un livre

La fenêtre contextuelle dans un LLM fait référence à la quantité de texte qu'il peut traiter et mémoriser en un seul appel. Cela signifie que même s'il est idéal pour résumer un article en une seule fois, il ne peut pas traiter un livre entier à la fois car le texte dépasse sa capacité à absorber et à générer une réponse cohérente.

Alors, comment pouvons-nous résoudre ce problème ? Nous pouvons le faire en « fragmentant » le livre. Nous divisons le livre en « morceaux » gérables pour le LLM et lui demandons de les résumer. Ensuite, une fois que nous avons des résumés pour chacun des morceaux, nous pouvons résumer ces résumés en un seul résumé cohérent.

Vous pouvez diviser la chaîne en morceaux comme ceci (assurez-vous d'importer textwrap) :

with open('article.txt', 'r') as file:
    content = file.read()

Vous pouvez modifier la largeur plus tard, voir ce que vous préférez et vous donner les meilleurs résultats.

Maintenant que nous avons tous ces morceaux, résumons chacun d'eux et enregistrons la réponse dans une variable appelée réponses.

prompt = f"""
Summarize the following text in bullet points for easy reading.

Text:
{content}
"""

Si vous exécutez ce code et imprimez les réponses, vous devriez voir une longue chaîne avec des résumés à puces pour chaque « morceau »/section qu'il a créé.

Il ne nous reste plus qu'à utiliser une nouvelle fois le LLM afin de créer une synthèse cohérente utilisant tous les résumés de sections.

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": prompt,
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Maintenant, lorsque vous exécutez le code, vous devriez voir un résumé de l'ensemble du livre ! Remarquable, non ?

Remarque : en fonction de la taille du livre, vous devrez peut-être le « fragmenter » plusieurs fois/demander au LLM de fournir des réponses plus courtes. S'il y a trop de résumés « fragmentés », l'invite de résumé final risque d'être encore trop volumineuse.

Nouvelle invite

Vous avez peut-être remarqué que, même si nous avons demandé au LLM de répondre par des puces, par exemple, il ne fournit pas toujours la même réponse. Parfois, cela peut ajouter un en-tête ou une petite explication. Parfois, cela peut simplement fournir des puces.

En tant que programmeur, cela peut parfois rendre difficile le traitement des résultats. Comment pouvons-nous nous assurer que le LLM fournit des réponses plus cohérentes dans un format spécifique ?

Créons un outil d'analyse des sentiments. Nous allons nourrir le LLM avec une triste histoire et lui dire d'obtenir un score de sentiment de -1 à 1.

J'aime comme ça :

import os
from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

Si vous exécutez cette opération plusieurs fois, vous pouvez voir que la réponse n'est pas toujours le format que nous avons spécifié. Cependant, si nous voulions nous appuyer sur ce format pour extraire le nombre et effectuer d’autres calculs, c’est frustrant. Une mauvaise manipulation pourrait provoquer le crash de notre programme.

La réinvite est le processus d'ajustement et d'affinement des informations fournies à un LLM pour le guider vers une réponse ou un format souhaité. Pour valider un format pour un outil de sentiment qui nécessite la sortie « Sentiment : 0,5 », vous pouvez réinviter le LLM en modifiant votre invite pour indiquer clairement au modèle de renvoyer uniquement le score de sentiment dans ce format exact, garantissant ainsi la cohérence du réponse.

Nous pouvons créer une fonction qui vérifie si le format attendu a été fourni en utilisant Regex (assurez-vous donc d'importer regex).

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Maintenant, après avoir obtenu la réponse du LLM, nous pouvons appeler cette fonction. Si la fonction renvoie vrai, alors nous savons que nous avons le bon format. S'il renvoie faux, alors nous savons que nous devons réinviter le LLM et réessayer.

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a super mario chatbot. Always answer in his style, and create witty responses."
        },
        {
            "role": "user",
            "content": "Explain formula 1.",
        }
    ],
    model="llama3-8b-8192",
)
print(chat_completion.choices[0].message.content)

Bien sûr, il s’agit d’une nouvelle invite très basique. Le LLM pourrait encore fournir un format incorrect dans ce deuxième appel LLM. Cependant, vous devriez maintenant avoir un taux de réussite beaucoup plus élevé avec une réponse formatée de manière cohérente.

Avec ces outils et techniques, vous êtes désormais équipé pour intégrer des LLM dans votre code Python et valider efficacement les sorties. N'hésitez pas à commenter si vous avez des questions !

Si vous souhaitez voir le code complet, veuillez visiter le référentiel Github.

P.S : Ceci est la version blog d'un atelier que j'ai donné au chapitre ACM de SCU.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!