So erstellen Sie einen einfachen Rechtschreibprüfern mit Chatgpt

In diesem Tutorial lernen wir mit Chatgpt, wie Sie einen Rechtschreibprüfungsfunktion in einer Cloud -Funktion erstellen.

OpenAIs großes Sprachmodell Chapgpt ist viel mehr als nur eine Chat -Oberfläche. Es ist ein leistungsstarkes Tool für eine Reihe von Aufgaben, einschließlich Übersetzung, Codegenerierung und, wie wir unten sehen werden, sogar beim Rechtschreibpunkt. ChatGPT bietet über seine REST -API eine einfache und äußerst effektive Möglichkeit, ein Projekt mit Sprachanalysen und Erzeugungsfunktionen zu erweitern.

Sie finden den gesamten Code für dieses Tutorial auf GitHub.

Key Takeaways

1. Verwenden von ChatGPT für erweiterte Rechtschreibprüfung: Dieses Tutorial zeigt, wie ChatGPT über die OpenAI-API effektiv für Rechtschreibaufgaben verwendet werden kann und über die einfache Fehlererkennung hinausgeht, um kontextbasierte grammatikalische Nuancen zu verstehen und zu korrigieren.
.
Integration von KI in Cloud-Funktionen: Der Artikel zeigt die Integration von KI-Funktionen in Cloud-Funktionen, insbesondere die Verwendung von AWS Lambda und bietet eine schrittweise Anleitung zum Aufbau eines Rechtschreibprüfers, der in einer Cloud-basierten Umgebung arbeitet.
Erkundungsfunktion Aufruf in OpenAI: Ein wesentlicher Bestandteil dieses Tutorials ist die Erforschung der Funktionsaufruf-Funktion in OpenAI .

Die Wolkenfunktion

Hier ist der Code für eine Cloud -Funktion:

<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>

Diese TypeScript -Funktion ist der Handler von AWS Lambda, wodurch eine HTTP -Anforderung als Eingabe akzeptiert und eine HTTP -Antwort zurückgegeben wird. Im obigen Beispiel dekonstruieren wir das Körperfeld aus der eingehenden HTTP -Anfrage, analysieren es an JSON und lesen Sie einen texttocheck aus der Anfrage.

Das OpenAI -Paket

Um die Beschwerdeschlüsselfunktion zu implementieren, senden wir TextToCheck nach Openai und bitten Sie das KI -Modell, alle Rechtschreibfehler für uns zu korrigieren. Um dies einfach zu machen, können wir das OpenAI -Paket auf NPM verwenden. Dieses Paket wird von OpenAI als praktischer JavaScript/TypeScript -Wrapper um die OpenAI -REST -API verwaltet. Es enthält alle Typenskriptypen, die wir benötigen, und macht das Aufrufen von Chatgpt zum Kinderspiel.

installieren Sie das OpenAI -Paket wie SO:

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

Wir können dann eine Instanz der OpenAI -Klasse in unserem Funktionshandler importieren und erstellen und in unseren OpenAI -API -Schlüssel weitergeben, der in diesem Beispiel in einer Umgebungsvariablen mit dem Namen OpenAI_Key gespeichert ist. (Sie finden Ihren API -Schlüssel in Ihren Benutzereinstellungen, sobald Sie sich für OpenAI angemeldet haben.)

<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>

Beispieltext

Zuletzt möchten wir einen Beispieltext mit Rechtschreibfehlern, mit denen man es testen kann, und welchen besseren Ort gibt, um einige zu bekommen, als Chatgpt selbst zu fragen!

Dieser Text ist ein guter Test unseres Rechtschreibprüfers, da er offensichtliche Fehlzüge wie „Essense“, aber auch einige komplexere grammatikalische Fehler wie „Prinzip“ anstelle von „Principal“ enthält. Fehler wie diese werden unseren Rechtschreibprüfung jenseits der Bereiche testen, nur nach Wörtern zu suchen, die nicht im Wörterbuch erscheinen. Prinzip und Principal sind beide gültige englische Wörter, sodass unser Rechtschreibfeld den Kontext verwenden muss, in dem sie erscheinen, um diesen Fehler korrekt zu erkennen. Ein echter Test!

text, text

text

Der einfachste Weg, um nach Rechtschreibfehlern in unserer texttoCheck -Eingabe zu suchen, besteht darin, eine Eingabeaufforderung zu erstellen, die Chatgpt auffordert, die Rechtschreibprüfung durchzuführen und die korrigierte Version an uns zurückzugeben. Später in diesem Tutorial werden wir eine viel leistungsfähigere Art und Weise untersuchen, wie wir zusätzliche Daten von der OpenAI -API zurückerhalten können, aber vorerst wird dieser einfache Ansatz eine gute erste Iteration sein.

Wir benötigen dafür zwei Eingabeaufforderungen. Das erste ist eine Benutzerumforderungs

, die Chatgpt anweist, auf Rechtschreibfehler zu suchen:

Korrigieren Sie die Rechtschreib- und Grammatikfehler im folgenden Text:

Wir benötigen auch eine System -Eingabeaufforderung

, die das Modell so leitet, dass nur den korrigierten Text zurückgegeben wird.

Sie sind ein Kopiereditor, der Textstücke korrigiert. Sie antworten immer nur mit dem korrigierten Text, ohne Erklärungen oder einer anderen Beschreibung.

Systemaufforderungen sind nützlich, um dem Modell einen anfänglichen Kontext zu geben und es zu wiet, eine bestimmte Möglichkeit für alle nachfolgenden Benutzeranforderungen zu verhalten. In der Systemaufforderung hier weisen wir Chatgpt an, nur den korrigierten Text zurückzugeben und ihn nicht mit einer Beschreibung oder einem anderen führenden Text zu verkleiden.

Wir können das System- und Benutzeraufforderungen auf dem OpenAI -Spielplatz testen.

Für den API -Anruf werden wir die Methode openai.chat.completions.create ({...}) in der OpenAI -Klasse verwenden, die wir oben instanziiert haben und die Antwortnachricht zurückgeben.

alles zusammenfügen, der folgende Code sendet diese beiden Eingabeaufforderungen zusammen mit dem Eingabetxt an den Endpunkt der OpenAi.Chat.completions.create ({...}) auf der OpenAI -API. Beachten Sie auch, dass wir das Modell als GPT-3.5-Turbo angeben. Wir können jedes OpenAI-Modell dafür verwenden, einschließlich 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>

text in, json out

Bisher haben wir eine AWS -Lambda -Cloud -Funktion geschrieben, die einen Text an ChatGPT sendet und eine korrigierte Version des Textes mit entferntem Rechtschreibfehlern zurückgibt. Das OpenAI -Paket ermöglicht es uns jedoch, so viel mehr zu tun. Wäre es nicht schön, einige strukturierte Daten aus unserer Funktion zurückzugeben, in denen tatsächlich die im Text vorgenommenen Ersetzungen aufgeführt sind? Das würde es viel einfacher machen, diese Cloud -Funktion in eine Frontend -Benutzeroberfläche zu integrieren.

Zum Glück bietet OpenAI eine Funktion zur API, die genau dieses Ding erreichen kann: Funktionsaufruf.

Funktionsaufruf ist eine Funktion, die in einige OpenAI -Modelle vorhanden ist, mit denen ChatGPT mit einigen strukturierten JSON anstelle einer einfachen Nachricht antworten kann. Indem wir das KI -Modell anweisen, eine Funktion aufzurufen und Details der Funktion zu liefern, die es aufrufen kann (einschließlich aller Argumente), können wir eine viel nützlichere und vorhersehbare JSON -Antwort von der API zurückerhalten.

Um das Funktionsaufruf zu verwenden, füllen wir das Funktionsarray in den Erstellungsoptionen der Chat Completion. Hier sagen wir Chatgpt, dass eine Funktion namens Makecorrections existiert und dass sie mit einem Argument namens Ersatz anrufen kann:

<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>

Die Beschreibungen der Funktion und alle Argumente sind hier wichtig, da Chatgpt keinen Zugriff auf einen unserer Code hat. Die Eigenschaft der Parameter beschreibt die Funktionssignatur, die ChatGPT aufrufen kann, und folgt dem JSON -Schema, um die Datenstruktur der Argumente zu beschreiben.

Die obige Funktion verfügt

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

Definieren dieses Typs im JSON -Schema wird sicherstellen, dass der JSON, den wir von ChatGPT zurückholen

alles zusammenfügen

<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>

Hier ist der endgültige Code für unsere AWS Lambda -Funktion. Es ruft Chatgpt auf und gibt eine

list

Korrekturen in einen Text zurück. Ein paar zusätzliche Dinge, die hier zu beachten sind. Wie bereits erwähnt, unterstützen nur wenige OpenAI -Modelle die Funktionsanrufe. Eines dieser Modelle ist GPT-3,5-Turbo-0613, daher wurde dies im Anruf zum Endpunkt des Abschlusses angegeben. Wir haben auch Funktion_Call: {Name: 'makecorrections'} zum Anruf hinzugefügt. Diese Eigenschaft ist eine Anweisung für das Modell, dass wir erwarten, dass es die Argumente zurückgibt, die für die Aufruf unserer Makecorrections -Funktion erforderlich sind, und dass wir nicht erwarten, dass sie eine Chat -Nachricht zurückgibt:

Diese Funktion kann in AWS Lambda bereitgestellt und über HTTP über die folgende Anforderungsbehörde aufgerufen werden:

<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>

Es wird die Liste der Korrekturen als JSON -Array wie folgt zurückgegeben:

<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>

Schlussfolgerung

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

Durch die Nutzung der OpenAI -API und einer Cloud -Funktion können Sie Anwendungen erstellen, die nicht nur Rechtschreibfehler identifizieren, sondern auch den Kontext verstehen, wodurch komplizierte grammatikalische Nuancen erfasst werden, die typische Rechtschreibschalter übersehen könnten. Dieses Tutorial bietet eine Grundlage, aber die potenziellen Anwendungen von ChatGPT in der Sprachanalyse und Korrektur sind groß. Während sich die KI weiterentwickelt, werden auch die Fähigkeiten solcher Tools.

Sie finden den gesamten Code für dieses Tutorial auf GitHub.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie einen einfachen Rechtschreibprüfern mit Chatgpt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!