Cara Membina Pemotongan Ejaan Sederhana Dengan ChatGPT

Dalam tutorial ini, kami akan belajar bagaimana untuk membina pemotongan ejaan di dalam fungsi awan menggunakan chatgpt.

Model Bahasa Besar Openai ChapGPT adalah lebih daripada sekadar antara muka sembang. Ia adalah alat yang berkuasa untuk pelbagai tugas termasuk terjemahan, penjanaan kod, dan, seperti yang akan kita lihat di bawah, walaupun ejaan. Melalui API REST, ChatGPT menyediakan cara yang mudah dan sangat berkesan untuk menambah analisis bahasa AI dan keupayaan generasi ke dalam projek.

Anda boleh mencari semua kod untuk tutorial ini di GitHub.

Takeaways Key

Menggunakan CHATGPT untuk SpellChecking Advanced: Tutorial ini menunjukkan bagaimana CHATGPT, melalui API OpenAI, boleh digunakan dengan berkesan untuk tugas-tugas ejaan, melampaui pengesanan kesilapan mudah untuk memahami dan membetulkan nuansa tatabahasa berasaskan konteks.
1. Mengintegrasikan AI dengan Fungsi Awan: Artikel ini mempamerkan integrasi keupayaan AI ke dalam fungsi awan, khususnya menggunakan AWS Lambda, menyediakan panduan langkah demi langkah untuk membina pemotongan ejaan yang beroperasi dalam persekitaran berasaskan awan.
meneroka fungsi yang memanggil di OpenAI: Bahagian utama tutorial ini adalah penerokaan ciri-ciri panggilan fungsi dalam model terbuka, yang membolehkan tindak balas JSON berstruktur dan bukannya teks biasa, membolehkan pembangunan aplikasi AI yang lebih canggih dan interaktif .
3. Fungsi awan

inilah kod untuk fungsi awan:

Fungsi TypeScript ini akan menjadi pengendali untuk AWS Lambda, menerima permintaan HTTP sebagai input dan mengembalikan respons HTTP. Dalam contoh di atas, kami sedang membina semula medan badan dari permintaan HTTP yang masuk, menghuraikannya ke JSON dan membaca tekstopheck harta dari badan permintaan.

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

Pakej Terbuka

Untuk melaksanakan fungsi SpellChecker, kami akan menghantar TextTocheck ke OpenAI dan minta model AI untuk membetulkan sebarang kesilapan ejaan untuk kami. Untuk menjadikannya mudah, kita boleh menggunakan pakej Openai pada npm. Pakej ini dikekalkan oleh OpenAI sebagai pembungkus JavaScript/Typescript yang berguna di sekitar API REST OpenAI. Ia merangkumi semua jenis jenis yang kita perlukan dan membuat panggilan chatgpt angin.

Pasang pakej OpenAI seperti SO:

kemudian kita boleh mengimport dan membuat contoh kelas Openai dalam pengendali fungsi kami, yang melewati kunci API Openai kami yang, dalam contoh ini, disimpan dalam pemboleh ubah persekitaran yang dipanggil OpenAI_Key. (Anda boleh mencari kunci API anda dalam tetapan pengguna anda sebaik sahaja anda telah mendaftar ke OpenAI.)

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

teks contoh

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

Akhir sekali, kami mahukan beberapa teks sampel dengan kesilapan ejaan untuk mengujinya, dan tempat yang lebih baik untuk mendapatkan beberapa daripada dengan meminta chatgpt sendiri!

Teks ini adalah ujian yang baik dari pemotongan ejaan kami, kerana ia mengandungi mis-spellings yang jelas seperti "essense", tetapi juga beberapa kesilapan tatabahasa yang lebih kompleks seperti "prinsip" dan bukannya "prinsipal". Kesilapan seperti ini akan menguji ejaan kami di luar alam semata -mata mencari kata -kata yang tidak muncul dalam kamus;

Prinsip dan prinsipal adalah kedua -dua kata -kata Inggeris yang sah, jadi pelukis ejaan kami perlu menggunakan konteks yang mereka tampilkan untuk mengesan kesilapan ini dengan betul. Ujian sebenar!

teks masuk, teks keluar

Cara paling mudah untuk mencari kesilapan ejaan dalam input TextToCheck kami adalah untuk membuat petikan yang akan meminta Chatgpt untuk melakukan ejaan dan mengembalikan versi yang diperbetulkan kembali kepada kami. Kemudian dalam tutorial ini, kami akan meneroka cara yang lebih kuat, kami dapat mendapatkan data tambahan dari API Openai, tetapi sekarang pendekatan mudah ini akan menjadi lelaran pertama yang baik.

Kami memerlukan dua arahan untuk ini. Yang pertama adalah

pengguna prompt yang mengarahkan chatgpt untuk memeriksa kesilapan ejaan:

Betulkan kesilapan ejaan dan tatabahasa dalam teks berikut:

kami juga memerlukan

sistem prompt yang akan membimbing model untuk mengembalikan hanya teks yang diperbetulkan.

Anda adalah editor salinan yang membetulkan kepingan teks, anda selalu membalas dengan hanya teks yang diperbetulkan, tidak ada penjelasan atau penerangan lain.

Sistem arahan berguna untuk memberikan model beberapa konteks awal dan mengarahkannya untuk berkelakuan cara tertentu untuk semua pengguna berikutnya. Dalam sistem yang cepat di sini, kami mengarahkan Chatgpt untuk kembali

hanya teks yang diperbetulkan, dan tidak berpakaian dengan keterangan atau teks terkemuka lain.

kita boleh menguji sistem dan pengguna yang meminta di taman permainan terbuka.

Untuk panggilan API, kami akan menggunakan kaedah openai.chat.completions.create ({...}) pada kelas OpenAI yang kami instantiated di atas dan mengembalikan mesej respons.

meletakkan semuanya bersama -sama, kod di bawah akan menghantar kedua -dua arahan ini bersama -sama dengan teks input ke openai.chat.completions.create ({...}) endpoint pada API OpenAI. Perhatikan juga bahawa kami menentukan model untuk digunakan sebagai GPT-3.5-Turbo. Kita boleh menggunakan mana-mana model OpenAI untuk ini, termasuk GPT-4:

teks masuk, json keluar

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

Setakat ini, kami telah menulis fungsi awan AWS Lambda yang akan menghantar beberapa teks kepada CHATGPT dan mengembalikan versi teks yang diperbetulkan dengan kesilapan ejaan yang dikeluarkan. Tetapi pakej Openai membolehkan kami melakukan lebih banyak lagi. Bukankah lebih baik untuk mengembalikan beberapa data berstruktur dari fungsi kami yang sebenarnya menyenaraikan penggantian yang dibuat dalam teks? Itu akan menjadikannya lebih mudah untuk mengintegrasikan fungsi awan ini dengan antara muka pengguna frontend.

bernasib baik, OpenAI menyediakan ciri pada API yang boleh mencapai perkara ini: fungsi panggilan.

Panggilan fungsi adalah ciri yang ada dalam beberapa model OpenAI yang membolehkan CHATGPT bertindak balas dengan beberapa JSON berstruktur dan bukan mesej mudah. Dengan mengarahkan model AI untuk memanggil fungsi, dan membekalkan butiran fungsi yang dapat dipanggil (termasuk semua argumen), kami dapat menerima respons JSON yang lebih berguna dan dapat diramal dari API.

Untuk menggunakan fungsi panggilan, kami mengisi pelbagai fungsi dalam pilihan penciptaan penyelesaian sembang. Di sini kita memberitahu Chatgpt bahawa fungsi yang dipanggil makeCorrections wujud dan ia boleh memanggil dengan satu hujah yang dipanggil pengganti:

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

Deskripsi fungsi dan semua hujah adalah penting di sini, kerana ChatGPT tidak akan mempunyai akses kepada mana -mana kod kami, jadi semua yang tahu mengenai fungsi itu terkandung dalam deskripsi yang kami berikan. Harta parameter menggambarkan tandatangan fungsi yang boleh dipanggil oleh Chatgpt, dan ia mengikuti skema JSON untuk menggambarkan struktur data argumen.

Fungsi di atas mempunyai hujah tunggal yang dipanggil penggantian, yang sejajar dengan jenis jenis berikut:

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

Mendefinisikan jenis ini dalam skema JSON akan memastikan bahawa JSON yang kita dapat kembali dari CHATGPT akan sesuai dengan bentuk yang boleh diramal ini, dan kita boleh menggunakan json.parse () untuk menghilangkannya ke dalam objek jenis ini:

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

meletakkan semuanya bersama

Berikut adalah kod akhir untuk fungsi AWS Lambda kami. Ia memanggil chatgpt dan mengembalikan senarai pembetulan ke sekeping teks.

Beberapa perkara tambahan yang perlu diperhatikan di sini. Seperti yang dinyatakan sebelum ini, hanya beberapa model OpenAI yang menyokong fungsi panggilan. Salah satu daripada model ini ialah GPT-3.5-Turbo-0613, jadi ini telah ditentukan dalam panggilan ke titik akhir penyelesaian. Kami juga telah menambah function_call: {name: 'makeCorrections'} ke panggilan. Harta ini adalah arahan kepada model yang kami harapkan untuk mengembalikan hujah -hujah yang diperlukan untuk memanggil fungsi makeCorrections kami, dan kami tidak mengharapkan ia mengembalikan mesej sembang:

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

Fungsi ini boleh digunakan untuk AWS Lambda dan dipanggil Over HTTP menggunakan badan permintaan berikut:

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

ia akan mengembalikan senarai pembetulan sebagai array JSON seperti ini:

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

Kesimpulan

Dengan memanfaatkan API OpenAI dan fungsi awan, anda boleh membuat aplikasi yang bukan sahaja mengenal pasti kesilapan ejaan tetapi juga memahami konteks, menangkap nuansa tatabahasa yang rumit yang mungkin diabaikan. Tutorial ini menyediakan asas, tetapi potensi aplikasi CHATGPT dalam analisis bahasa dan pembetulan adalah luas. Oleh kerana AI terus berkembang, begitu juga keupayaan alat tersebut.

Anda boleh mencari semua kod untuk tutorial ini di GitHub.

Atas ialah kandungan terperinci Cara Membina Pemotongan Ejaan Sederhana Dengan ChatGPT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!