Dans ce tutoriel, nous apprendrons à construire un vérificateur orthographique dans une fonction cloud à l'aide de chatppt.

Le modèle du modèle grand langage d'Openai est bien plus qu'une simple interface de chat. C'est un outil puissant pour une gamme de taches, notamment la traduction, la génération de code et, comme nous le verrons ci-dessous, même le vérification orthographique. Grace à son API REST, ChatGpt fournit un moyen simple et extrêmement efficace d'ajouter l'analyse du langage AI et les capacités de génération dans un projet.

Vous pouvez trouver tout le code de ce tutoriel sur github.

Les plats clés

1. Utilisation du chatppt pour avancé orthographique: ce tutoriel montre comment le chatgpt, via l'API OpenAI, peut être utilisé efficacement pour les taches de vérification orthographique, allant au-delà de la détection d'erreur simple pour comprendre et corriger les nuances grammaticales contextuelles.
2. Intégration de l'IA avec les fonctions cloud: L'article présente l'intégration des capacités d'IA dans les fonctions cloud, en utilisant spécifiquement AWS Lambda, fournissant un guide étape par étape pour construire un correcteur orthographique qui fonctionne dans un environnement basé sur le cloud.
3. Exploration de la fonction appelant Openai: un élément clé de ce tutoriel est l'exploration de la fonction d'appel de fonction dans les modèles OpenAI, qui permet des réponses JSON structurées au lieu de texte brut, permettant le développement d'applications plus sophistiquées et interactives alimentées par AI .

la fonction cloud

Voici le code d'une fonction cloud:

<span>// Entry point for AWS Lambda.
</span><span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>// Read the text from the request body.
</span>    <span>const { textToCheck } = <{ textToCheck: string }>JSON.parse(body);
</span>
    <span>//... perform spellchecking
</span>
    <span>// Return an HTTP OK response
</span>    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: JSON.stringify(...)
</span>    <span>};
</span><span>}
</span>

Cette fonction TypeScript sera le gestionnaire d'AWS Lambda, acceptant une demande HTTP en entrée et renvoyant une réponse HTTP. Dans l'exemple ci-dessus, nous déconstruisons le champ corporel à partir de la demande HTTP entrante, l'analysant à JSON et lisant une propriété TextTocheck à partir du corps de la demande.

Le package OpenAI

Pour implémenter la fonction de vérification orthographique, nous allons envoyer TextTocheck à Openai et demander au modèle d'IA de corriger les erreurs d'orthographe pour nous. Pour le rendre facile, nous pouvons utiliser le package OpenAI sur NPM. Ce package est maintenu par OpenAI en tant que wrapper JavaScript / TypeScript pratique autour de l'API Openai REST. Il inclut tous les types de typeScript dont nous avons besoin et fait de l'appel Chatgpt un jeu d'enfant.

Installez le package OpenAI comme SO:

<span>npm install --save openai
</span>

Nous pouvons alors importer et créer une instance de la classe OpenAI dans notre gestionnaire de fonctions, transmettant notre clé API OpenAI qui, dans cet exemple, est stockée dans une variable d'environnement appelée Openai_Key. (Vous pouvez trouver votre clé API dans les paramètres de vos utilisateurs une fois que vous vous êtes inscrit à Openai.)

<span>// Import the OpenAI package
</span><span>import OpenAI from "openai";
</span>
<span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>const { textToCheck }: { textToCheck: string } = JSON.parse(body);
</span>
    <span>// Create a new instance of OpenAI...
</span>    <span>const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
</span>
    <span>//... perform spellchecking
</span>
    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: JSON.stringify(...)
</span>    <span>};
</span><span>}
</span>

Exemple de texte

Enfin, nous voulons un exemple de texte avec des erreurs d'orthographe pour le tester, et quel meilleur endroit pour en obtenir qu'en demandant à Chatgpt lui-même!

Ce texte est un bon test de notre vérificateur orthographique, car il contient des inculpations erronées évidentes telles que ?Essense?, mais aussi des erreurs grammaticales plus complexes telles que ?principe? au lieu de ?directeur?. Des erreurs comme celle-ci testeront notre vérificateur orthographique au-delà des domaines de simplement chercher des mots qui n'apparaissent pas dans le dictionnaire; Principe et Les principaux sont tous deux des mots anglais valides, donc notre vérificateur orthographique devra utiliser le contexte dans lequel ils apparaissent pour détecter correctement cette erreur. Un vrai test!

texte dans, texte out

La fa?on la plus simple de rechercher des erreurs d'orthographe dans notre entrée TextTocheck est de créer une invite qui demandera à Chatgpt pour effectuer la vérification orthographique et renvoyer la version corrigée. Plus tard dans ce tutoriel, nous allons explorer une manière beaucoup plus puissante pour que nous puissions récupérer des données supplémentaires de l'API OpenAI, mais pour l'instant cette approche simple sera une bonne première itération.

Nous aurons besoin de deux invites pour cela. Le premier est une invite utilisateur qui demande à Chatgpt de vérifier les erreurs d'orthographe:

Corrigez l'orthographe et les erreurs grammaticales dans le texte suivant:

Nous aurons également besoin d'une invite système qui guidera le modèle pour retourner uniquement le texte corrigé.

Vous êtes un éditeur de copie qui corrige les éléments de texte, vous répondez toujours avec juste le texte corrigé, aucune explication ou autre description.

Les invites du système sont utiles pour donner au modèle un contexte initial et lui demander de se comporter d'une certaine manière pour toutes les invites utilisateur ultérieures. Dans l'invite du système ici, nous demandons à Chatgpt de retourner seulement le texte corrigé, et de ne pas le habiller avec une description ou un autre texte de premier plan.

Nous pouvons tester le système et les invites utilisateur dans le terrain de jeu OpenAI.

Pour l'appel de l'API, nous utiliserons la méthode openai.chat .....

En mettant le tout, le code ci-dessous enverra ces deux invites avec le texte d'entrée au point de terminaison openai.chat.completions.create ({...}) sur l'API OpenAI. Notez également que nous spécifions le modèle à utiliser comme GPT-3.5-turbo. Nous pouvons utiliser n'importe quel modèle OpenAI pour cela, y compris GPT-4:

<span>// Entry point for AWS Lambda.
</span><span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>// Read the text from the request body.
</span>    <span>const { textToCheck } = <{ textToCheck: string }>JSON.parse(body);
</span>
    <span>//... perform spellchecking
</span>
    <span>// Return an HTTP OK response
</span>    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: JSON.stringify(...)
</span>    <span>};
</span><span>}
</span>

Texte dans, JSON OUT

Jusqu'à présent, nous avons écrit une fonction Cloud Lambda AWS qui enverra du texte à chatgpt et renvoie une version corrigée du texte avec les erreurs d'orthographe supprimées. Mais le package OpenAI nous permet de faire beaucoup plus. Ne serait-il pas agréable de renvoyer des données structurées de notre fonction qui énumèrent réellement les remplacements qui ont été effectués dans le texte? Cela faciliterait l'intégration de cette fonction cloud avec une interface utilisateur frontal.

Heureusement, OpenAI fournit une fonctionnalité sur l'API qui peut réaliser cette chose: Fonction Calling.

Fonction L'appel est une fonctionnalité présente dans certains modèles openai qui permettent à Chatgpt de répondre avec un JSON structuré au lieu d'un simple message. En demandant au modèle d'IA d'appeler une fonction et de fournir des détails sur la fonction qu'il peut appeler (y compris tous les arguments), nous pouvons recevoir une réponse JSON beaucoup plus utile et prévisible de l'API.

Pour utiliser l'appel des fonctions, nous remplissons le tableau des fonctions dans les options de création d'achèvement de chat. Ici, nous disons à Chatgpt qu'une fonction appelée makecorrections existe et qu'il peut appeler avec un argument appelé remplacements:

<span>// Entry point for AWS Lambda.
</span><span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>// Read the text from the request body.
</span>    <span>const { textToCheck } = <{ textToCheck: string }>JSON.parse(body);
</span>
    <span>//... perform spellchecking
</span>
    <span>// Return an HTTP OK response
</span>    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: JSON.stringify(...)
</span>    <span>};
</span><span>}
</span>

Les descriptions de la fonction et de tous les arguments sont importantes ici, car Chatgpt n'aura accès à aucun de notre code, donc tout ce qu'il sait sur la fonction est contenu dans les descriptions que nous lui fournissons. La propriété Paramètres décrit la signature de la fonction que Chatgpt peut appeler, et il suit le schéma JSON pour décrire la structure de données des arguments.

La fonction ci-dessus a un seul argument appelé remplacements, qui s'aligne sur le type de typeScript suivant:

<span>npm install --save openai
</span>

La définition de ce type dans le schéma JSON s'assurera que le JSON que nous récupérons de Chatgpt s'adaptera à cette forme prévisible, et nous pouvons utiliser le JSON.Parse () pour le désérialiser dans un objet de ce type:

<span>// Import the OpenAI package
</span><span>import OpenAI from "openai";
</span>
<span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>const { textToCheck }: { textToCheck: string } = JSON.parse(body);
</span>
    <span>// Create a new instance of OpenAI...
</span>    <span>const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
</span>
    <span>//... perform spellchecking
</span>
    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: JSON.stringify(...)
</span>    <span>};
</span><span>}
</span>

Mettre tout cela ensemble

Voici le code final de notre fonction AWS Lambda. Il appelle Chatgpt et renvoie une Liste des corrections à un texte.

quelques choses supplémentaires à noter ici. Comme mentionné précédemment, seuls quelques modèles OpenAI prennent en charge les appels de fonction. L'un de ces modèles est GPT-3.5-Turbo-0613, ce qui a été spécifié dans l'appel au point de terminaison des compléments. Nous avons également ajouté function_call: {name: 'makecorrections'} à l'appel. Cette propriété est une instruction au modèle que nous nous attendons à ce qu'elle renvoie les arguments nécessaires pour appeler notre fonction makecorrections, et que nous ne nous attendons pas à ce qu'il renvoie un message de chat:

<span>// Import the OpenAI package
</span><span>import OpenAI from "openai";
</span>
<span>export async function spellcheck({ body }: { body: string }) {
</span>
    <span>const { textToCheck }: { textToCheck: string } = JSON.parse(body);
</span>
    <span>// Create a new instance of OpenAI.
</span>    <span>const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
</span>
    <span>const userPrompt = 'Correct the spelling and grammatical errors in the following text:\n\n';
</span>
    <span>const gptResponse = await openai.chat.completions.create({
</span>        model<span>: "gpt-3.5-turbo",
</span>        messages<span>: [
</span>            <span>{
</span>                role<span>: "system",
</span>                content<span>: "You are a copy editor that corrects pieces of text, you always reply with just the corrected text, no explanations or other description"
</span>            <span>},
</span>            <span>{
</span>                role<span>: "user",
</span>                content<span>: userPrompt + textToCheck
</span>            <span>}
</span>        <span>]
</span>    <span>});
</span>
    <span>// The message.content will contain the corrected text...
</span>    <span>const correctedText = gptResponse.choices[0].message.content;
</span>
    <span>return {
</span>        statusCode<span>: 200,
</span>        body<span>: correctedText
</span>    <span>};
</span><span>}
</span>

Cette fonction peut être déployée sur AWS Lambda et appelée HTTP en utilisant le corps de demande suivant:

<span>const gptResponse = await openai.chat.completions.create({
</span>    model<span>: "gpt-3.5-turbo-0613",
</span>    messages<span>: [ ... ],
</span>    functions<span>: [
</span>        <span>{
</span>            name<span>: "makeCorrections",
</span>            description<span>: "Makes spelling or grammar corrections to a body of text",
</span>            parameters<span>: {
</span>                type<span>: "object",
</span>                properties<span>: {
</span>                    replacements<span>: {
</span>                        type<span>: "array",
</span>                        description<span>: "Array of corrections",
</span>                        items<span>: {
</span>                            type<span>: "object",
</span>                            properties<span>: {
</span>                                changeFrom<span>: {
</span>                                    type<span>: "string",
</span>                                    description<span>: "The word or phrase to change"
</span>                                <span>},
</span>                                changeTo<span>: {
</span>                                    type<span>: "string",
</span>                                    description<span>: "The new word or phrase to replace it with"
</span>                                <span>},
</span>                                reason<span>: {
</span>                                    type<span>: "string",
</span>                                    description<span>: "The reason this change is being made",
</span>                                    <span>enum: ["Grammar", "Spelling"]
</span>                                <span>}                                    
</span>                            <span>}
</span>                        <span>}
</span>                    <span>}
</span>                <span>}
</span>            <span>}
</span>        <span>}
</span>    <span>],    });
</span>

Il renverra la liste des corrections comme un tableau JSON comme ceci:

<span>type ReplacementsArgType = {
</span>    changeFrom<span>: string,
</span>    changeTo<span>: string,
</span>    reason<span>: "Grammar" | "Spelling"
</span><span>}[]
</span>

Conclusion

En tirant parti de l'API OpenAI et d'une fonction cloud, vous pouvez créer des applications qui non seulement identifier les erreurs d'orthographe mais aussi comprendre le contexte, capturant des nuances grammaticales complexes que les vérificateurs orthographiques typiques pourraient négliger. Ce tutoriel fournit une base, mais les applications potentielles de Chatgpt dans l'analyse et la correction du langage sont vastes. Comme l'IA continue d'évoluer, les capacités de ces outils aussi.

Vous pouvez trouver tout le code de ce tutoriel sur github.

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!