L’Outil Surpuissant pour Exploser ton Chiffre d'Affaires en 2024 !
Comment créer un correcteur orthographique simple avec ChatGPT —
Dans ce didacticiel, nous apprendrons comment créer un correcteur orthographique dans une fonction cloud à l’aide de ChatGPT.
Le grand modèle de langage d’OpenAI, ChapGPT, est bien plus qu’une simple interface de discussion. Il s’agit d’un outil puissant pour toute une série de tâches, notamment la traduction, la génération de code et, comme nous le verrons ci-dessous, même la vérification orthographique. Grâce à son API REST, ChatGPT fournit un moyen simple et extrêmement efficace d’ajouter des capacités d’analyse et de génération de langage IA dans un projet.
Vous pouvez tout trouver le code de ce tutoriel sur GitHub.
La fonction cloud
Voici le code d’une fonction cloud :
export async function spellcheck({ body }: { body: string }) {
const { textToCheck } = <{ textToCheck: string }>JSON.parse(body);
return {
statusCode: 200,
body: JSON.stringify(...)
};
}
Cette fonction Typescript sera le gestionnaire d’AWS Lambda, acceptant une requête HTTP en entrée et renvoyant une réponse HTTP. Dans l’exemple ci-dessus, nous déconstruisons le body champ de la requête HTTP entrante, en l’analysant en JSON et en lisant une propriété textToCheck du corps de la demande.
Le forfait openai
Pour implémenter la fonction du correcteur orthographique, nous allons envoyer textToCheck rendez-vous sur OpenAI et demandez au modèle d’IA de corriger les fautes d’orthographe pour nous. Pour rendre cela plus facile, nous pouvons utiliser le paquet openai sur NPM. Ce package est maintenu par OpenAI en tant que wrapper Javascript/Typescript pratique autour de l’API REST OpenAI. Il inclut tous les types Typescript dont nous avons besoin et facilite l’appel de ChatGPT.
Installez le package openai comme ceci :
npm install --save openai
Nous pouvons ensuite importer et créer une instance du OpenAI classe dans notre gestionnaire de fonctions, en 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 vos paramètres utilisateur une fois que vous êtes inscrit à OpenAI.)
import OpenAI from "openai";
export async function spellcheck({ body }: { body: string }) {
const { textToCheck }: { textToCheck: string } = JSON.parse(body);
const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
return {
statusCode: 200,
body: JSON.stringify(...)
};
}
Exemple de texte
Enfin, nous voulons un exemple de texte avec des fautes 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 correcteur orthographique, car il contient des fautes d’orthographe évidentes telles que « essense », mais aussi des erreurs grammaticales plus complexes telles que « principe ».le» au lieu de « principeAl« . Des erreurs comme celle-ci testeront notre correcteur orthographique au-delà de la simple recherche de mots qui n’apparaissent pas dans le dictionnaire ; principe et principal sont tous deux des mots anglais valides, notre correcteur orthographique devra donc utiliser le contexte dans lequel ils apparaissent pour détecter correctement cette erreur. Un vrai test !
Texte entrant, texte sortant
La manière la plus simple de rechercher les fautes d’orthographe dans notre textToCheck La saisie consiste à créer une invite qui demandera à ChatGPT d’effectuer la vérification orthographique et de nous renvoyer la version corrigée. Plus loin dans ce didacticiel, nous allons explorer un moyen beaucoup plus puissant de récupérer des données supplémentaires à partir de l’API OpenAI, mais pour l’instant, cette approche simple constituera une bonne première itération.
Nous aurons besoin de deux invites pour cela. Le premier est un invite utilisateur qui demande à ChatGPT de vérifier les fautes d’orthographe :
Corrigez les fautes d’orthographe et de grammaire dans le texte suivant :
Nous aurons également besoin d’un invite du système cela guidera le modèle pour renvoyer uniquement le texte corrigé.
Vous êtes un rédacteur qui corrige des morceaux de texte, vous répondez toujours avec uniquement le texte corrigé, sans explications ni autre description.
Les invites système sont utiles pour donner au modèle un certain contexte initial et lui demander de se comporter d’une certaine manière pour toutes les invites utilisateur ultérieures. Dans l’invite système ici, nous demandons à ChatGPT de revenir seulement le texte corrigé, et ne pas l’habiller d’une description ou d’un autre texte principal.
Nous pouvons tester le système et les invites utilisateur dans le Terrain de jeu OpenAI.
Pour l’appel API, nous utiliserons le openai.chat.completions.create({...}) méthode sur le OpenAI classe que nous avons instanciée ci-dessus et renvoyant le message de réponse.
En mettant tout cela ensemble, le code ci-dessous enverra ces deux invites ainsi que le texte saisi au openai.chat.completions.create({...}) point de terminaison 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 :
import OpenAI from "openai";
export async function spellcheck({ body }: { body: string }) {
const { textToCheck }: { textToCheck: string } = JSON.parse(body);
const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
const userPrompt = 'Correct the spelling and grammatical errors in the following text:\n\n';
const gptResponse = await openai.chat.completions.create({
model: "gpt-3.5-turbo",
messages: [
{
role: "system",
content: "You are a copy editor that corrects pieces of text, you always reply with just the corrected text, no explanations or other description"
},
{
role: "user",
content: userPrompt + textToCheck
}
]
});
const correctedText = gptResponse.choices[0].message.content;
return {
statusCode: 200,
body: correctedText
};
}
Entrée de texte, sortie JSON
Jusqu’à présent, nous avons écrit une fonction cloud AWS Lambda qui enverra du texte à ChatGPT et renverra une version corrigée du texte avec les fautes d’orthographe supprimées. Mais le openai Le package nous permet de faire bien plus. Ne serait-il pas agréable de renvoyer des données structurées de notre fonction qui répertorient les remplacements effectués dans le texte ? Cela rendrait beaucoup plus facile l’intégration de cette fonction cloud avec une interface utilisateur frontale.
Heureusement, OpenAI fournit une fonctionnalité sur l’API qui peut réaliser exactement ceci : Appel de fonction.
Appel de fonction est une fonctionnalité présente dans quelques Modèles OpenAI qui permettent à ChatGPT de répondre avec du JSON structuré au lieu d’un simple message. En demandant au modèle d’IA d’appeler une fonction et en fournissant 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 de fonction, nous remplissons le functions tableau dans les options de création de complétion de discussion. Ici, nous disons à ChatGPT qu’une fonction appelée makeCorrections existe et qu’il peut appeler avec un argument appelé replacements:
const gptResponse = await openai.chat.completions.create({
model: "gpt-3.5-turbo-0613",
messages: [ ... ],
functions: [
{
name: "makeCorrections",
description: "Makes spelling or grammar corrections to a body of text",
parameters: {
type: "object",
properties: {
replacements: {
type: "array",
description: "Array of corrections",
items: {
type: "object",
properties: {
changeFrom: {
type: "string",
description: "The word or phrase to change"
},
changeTo: {
type: "string",
description: "The new word or phrase to replace it with"
},
reason: {
type: "string",
description: "The reason this change is being made",
enum: ["Grammar", "Spelling"]
}
}
}
}
}
}
}
], });
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. Le parameters La propriété décrit la signature de fonction que ChatGPT peut appeler, et elle suit Schéma JSON pour décrire la structure des données des arguments.
La fonction ci-dessus a un seul argument appelé replacementsqui s’aligne sur le type TypeScript suivant :
type ReplacementsArgType = {
changeFrom: string,
changeTo: string,
reason: "Grammar" | "Spelling"
}[]
La définition de ce type dans le schéma JSON garantira que le JSON que nous recevrons de ChatGPT correspondra à cette forme prévisible, et nous pourrons utiliser le JSON.parse() pour le désérialiser en un objet de ce type :
const args = <ReplacementsArgType>JSON.parse(responseChoice.message.function_call!.arguments);
Mettre tous ensemble
Voici le code final de notre fonction AWS Lambda. Il appelle ChatGPT et renvoie un liste de corrections à un morceau de texte.
Quelques choses supplémentaires à noter ici. Comme mentionné précédemment, seuls quelques modèles OpenAI prennent en charge les appels de fonctions. L’un de ces modèles est gpt-3.5-turbo-0613, cela a donc été spécifié dans l’appel au point de terminaison des complétions. Nous avons également ajouté function_call: { name: 'makeCorrections' } à l’appel. Cette propriété est une instruction adressée au modèle selon laquelle nous attendons qu’il renvoie les arguments nécessaires pour appeler notre makeCorrections fonction, et que nous ne nous attendons pas à ce qu’elle renvoie un message de discussion :
import OpenAI from "openai";
import { APIGatewayEvent } from "aws-lambda";
type ReplacementsArgType = {
changeFrom: string,
changeTo: string,
reason: "Grammar" | "Spelling"
}[]
export async function main({ body }: { body: string }) {
const { textToCheck }: { textToCheck: string } = JSON.parse(body);
const openai = new OpenAI({ apiKey: process.env.OPENAI_KEY });
const prompt = 'Correct the spelling and grammatical errors in the following text:\n\n';
const gptResponse = await openai.chat.completions.create({
model: "gpt-3.5-turbo-0613",
messages: [
{
role: "user",
content: prompt + textToCheck
}
],
functions: [
{
name: "makeCorrections",
description: "Makes spelling or grammar corrections to a body of text",
parameters: {
type: "object",
properties: {
replacements: {
type: "array",
description: "Array of corrections",
items: {
type: "object",
properties: {
changeFrom: {
type: "string",
description: "The word or phrase to change"
},
changeTo: {
type: "string",
description: "The new word or phrase to replace it with"
},
reason: {
type: "string",
description: "The reason this change is being made",
enum: ["Grammar", "Spelling"]
}
}
}
}
}
}
}
],
function_call: { name: 'makeCorrections' }
});
const [responseChoice] = gptResponse.choices;
const args = <ReplacementsArgType>JSON.parse(responseChoice.message.function_call!.arguments);
return {
statusCode: 200,
body: JSON.stringify(args)
};
}
Cette fonction peut être déployée sur AWS Lambda et appelé via HTTP en utilisant le corps de requête suivant :
{
"textToCheck": "Thier journey to the nearby city was quite the experience. If you could of seen the way people reacted when they first saw the castle, it was as if they were taken back to a era long forgotten. The architecture, with it's grand spires and ancient motifs, captured the essense of a time when knights roamed the land. The principle reason for visiting, however, was the art exhibition showcasing several peices from renowned artists of the past."
}
Il renverra la liste des corrections sous forme de tableau JSON comme ceci :
[
{
"changeFrom": "Thier",
"changeTo": "Their",
"reason": "Spelling"
},
{
"changeFrom": "could of",
"changeTo": "could have",
"reason": "Grammar"
},
{
"changeFrom": "a",
"changeTo": "an",
"reason": "Grammar"
},
]
Conclusion
En tirant parti de l’API OpenAI et d’une fonction cloud, vous pouvez créer des applications qui non seulement identifient les fautes d’orthographe, mais comprennent également le contexte, capturant des nuances grammaticales complexes que les correcteurs orthographiques classiques pourraient ignorer. Ce didacticiel fournit une base, mais les applications potentielles de ChatGPT dans l’analyse et la correction du langage sont vastes. À mesure que l’IA continue d’évoluer, les capacités de ces outils évolueront également.
Vous pouvez tout trouver le code de ce tutoriel sur GitHub.
Source link