Menggunakan AI Generatif dengan Python

AI ialah masa depan, dan sebagai jurutera perisian, ia adalah bidang yang paling menarik untuk diceburi. Memanfaatkan LLM dalam kod anda membolehkan anda membina aplikasi yang lebih pintar yang mengendalikan tugas yang rumit seperti analisis sentimen masa nyata atau mentafsir kandungan yang dijana pengguna. Penyepaduan LLM menjadikan perisian anda lebih responsif dan berkebolehan, meningkatkan pengalaman pengguna dan automasi.

Siaran ini ialah pengenalan tentang cara membuat panggilan LLM menggunakan Python supaya anda boleh mula menambahkan keupayaan hebat ini pada kod anda sendiri.

Kami akan bermula dengan membuat chatbot untuk mana-mana watak pilihan anda. Kemudian, anda akan belajar cara merumuskan teks yang lebih kecil, malah meningkat kepada merumuskan keseluruhan buku. Akhir sekali, anda akan belajar cara mengesa semula dan menganalisis hasil yang disediakan oleh LLM.

Membuat Permintaan LLM pertama kami

Untuk permintaan LLM, kami akan menggunakan Groq. Jika anda membuat akaun di sana, anda boleh menggunakan API mereka dan membuat permintaan LLM secara percuma.

Untuk menggunakan Python untuk permintaan ini, pasang pakej Groq python dengan menjalankan pip install groq. Kemudian, kami akan mengimportnya dalam kod kami seperti:

import os
from groq import Groq

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

Pastikan anda menetapkan kekunci api sebagai pembolehubah persekitaran.

Permintaan LLM mudah boleh dibuat dengan menambah:

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

Dalam kes ini, kami meminta LLM untuk menerangkan apakah formula 1. Output daripada llama3-8b harus dicetak sebaik sahaja anda menjalankan program dalam konsol anda. Anda boleh bermain-main dengan ini dan menukar model, serta gesaan.

Mencipta Chatbot tersuai

Sekarang, mari buat chatbot untuk mana-mana watak yang anda suka—Mario, contohnya. Pada masa ini, LLM bertindak balas dalam nada neutral/bermaklumat. Walau bagaimanapun, dengan memberikan LLM peranan sistem, kami boleh memastikan ia bertindak balas sama seperti Mario, menambahkan keperibadian dan keseronokan pada perbualan. Ini menetapkan nada untuk interaksi, jadi anda akan mendapat respons yang suka bermain dan ikonik seperti "Ini-saya, Mario!" untuk memastikan perkara menarik.

Mari tambahkan peranan sistem pada permintaan kami:

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)

Kini, LLM akan menerangkan apa itu Formula 1 dari segi Mario Kart!

Peranan sistem juga bagus untuk kes penggunaan lain, seperti ejen sokongan pelanggan maya, tutor pendidikan atau pembantu penulisan kreatif, memastikan LLM bertindak balas dengan cara yang sesuai dengan getaran dan keperluan khusus setiap peranan.

Merumuskan Teks

Sekarang kita tahu sedikit tentang cara membuat permintaan LLM dengan gesaan & peranan sistem tertentu, mari cuba dan buat alat ringkasan.

Buat fail teks dalam direktori yang sama dipanggil article.txt, dan tampal dalam mana-mana artikel pilihan anda. Untuk langkah ini, pastikan artikel tidak terlalu panjang.

Dalam kod, mari kita muatkan teks itu dahulu.

import os
from groq import Groq

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

Sekarang, mari buat gesaan yang boleh kita hantar ke LLM, memberitahunya untuk meringkaskan teks dalam titik tumpu khas.

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

Kami mula-mula menulis gesaan, memberikan arahan yang jelas dan ringkas kepada LLM. Kemudian, kami menyediakan teks yang harus dirumuskan.

Sekarang, apa yang perlu kita lakukan ialah memanggil LLM dengan gesaan yang baru kita buat:

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)

Jalankan ini, dan anda akan melihat ringkasan titik tumpu artikel yang anda berikan LLM!

Sekarang, cuba tampal dalam artikel yang sangat panjang, atau mungkin keseluruhan buku -- seperti Metamorfosis oleh Franz Kafka.

Perhatikan bahawa LLM datang kembali dengan ralat. Anda memberi terlalu banyak untuk diringkaskan sekaligus.

Merumuskan Buku

Tetingkap konteks dalam LLM merujuk kepada jumlah teks yang boleh diproses dan diingati dalam satu panggilan. Ini bermakna walaupun ia bagus untuk meringkaskan artikel sekali gus, ia tidak dapat mengendalikan keseluruhan buku sekaligus kerana teks melebihi kapasitinya untuk menerima dan menjana respons yang koheren.

Jadi, bagaimana kita hendak membetulkannya? Kita boleh melakukannya dengan 'memotong' buku. Kami membahagikan buku itu kepada 'ketulan' yang boleh diurus untuk LLM, dan memberitahunya untuk meringkaskannya. Kemudian, setelah kami mempunyai ringkasan untuk setiap bahagian, kami boleh meringkaskan ringkasan tersebut menjadi satu ringkasan yang koheren.

Anda boleh membelah rentetan menjadi kepingan seperti itu (pastikan mengimport pembalut teks):

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

Anda boleh menukar sekitar lebar kemudian, dan lihat perkara yang anda suka dan memberikan anda hasil yang terbaik.

Sekarang kita mempunyai semua bahagian ini, mari kita ringkaskan setiap satu daripadanya dan simpan respons di dalam pembolehubah yang dipanggil jawapan.

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

Text:
{content}
"""

Jika anda menjalankan kod ini dan mencetak jawapan, anda akan melihat rentetan panjang dengan ringkasan titik tumpu bagi setiap 'ketulan'/bahagian yang dibuatnya.

Kini, apa yang perlu kita lakukan ialah menggunakan LLM sekali lagi untuk mencipta satu ringkasan yang koheren menggunakan semua ringkasan bahagian.

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

Sekarang, apabila anda menjalankan kod, anda sepatutnya melihat satu ringkasan keseluruhan buku! Luar biasa, bukan?

Nota: Bergantung pada saiz buku itu, anda mungkin perlu 'membedah' beberapa kali/memberitahu LLM untuk memberikan respons yang lebih pendek. Jika terdapat terlalu banyak ringkasan 'ketulan', gesaan ringkasan akhir mungkin masih terlalu besar.

Mendorong semula

Anda mungkin perasan bahawa, walaupun kami memberitahu LLM untuk membalas dengan titik peluru, contohnya, ia tidak selalu memberikan respons yang sama. Kadangkala, ia mungkin menambah pengepala atau sedikit penjelasan. Kadangkala, ia mungkin hanya memberikan titik tumpu.

Sebagai pengaturcara, ini mungkin menyukarkan kadangkala memproses hasilnya. Bagaimanakah kami memastikan LLM memberikan jawapan yang lebih konsisten dalam format tertentu?

Jom buat alat analisis sentimen. Kami akan memberi LLM cerita sedih, dan memberitahunya untuk menghasilkan skor sentimen dari -1 hingga 1.

Begitu juga:

import os
from groq import Groq

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

Jika anda menjalankan ini beberapa kali, anda dapat melihat bahawa balasan tidak selalunya seperti format yang kami tetapkan. Walau bagaimanapun, jika kami ingin bergantung pada format itu untuk mengekstrak nombor dan melakukan pengiraan selanjutnya, itu mengecewakan. Pengendalian yang tidak betul mungkin menyebabkan program kami ranap.

Gesaan semula ialah proses melaraskan dan memperhalusi input yang diberikan kepada LLM untuk membimbingnya ke arah respons atau format yang diingini. Untuk mengesahkan format alat sentimen yang memerlukan output sebagai "Sentimen: 0.5", anda boleh menggesa semula LLM dengan mengubah suai gesaan anda untuk mengarahkan model dengan jelas untuk mengembalikan hanya skor sentimen dalam format yang tepat itu, memastikan konsistensi dalam jawapan.

Kami boleh mencipta fungsi yang menyemak sama ada format yang dijangkakan telah disediakan menggunakan Regex (jadi pastikan anda mengimport 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)

Kini, selepas kami mendapat respons daripada LLM, kami boleh memanggil fungsi itu. Jika fungsi kembali benar, maka kami tahu kami mempunyai format yang betul. Jika ia mengembalikan palsu, maka kami tahu bahawa kami harus menggesa semula LLM dan cuba lagi.

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)

Sudah tentu, ini adalah dorongan semula yang sangat asas. LLM masih boleh memberikan format yang salah dalam panggilan LLM kedua ini. Walau bagaimanapun, anda sepatutnya mempunyai kadar kejayaan yang lebih tinggi sekarang daripada respons yang diformat secara konsisten.

Dengan alatan dan teknik ini, anda kini bersedia untuk menyepadukan LLM ke dalam kod Python anda dan mengesahkan output dengan berkesan. Sila berasa bebas untuk mengulas dengan sebarang pertanyaan!

Jika anda ingin melihat kod penuh, sila lawati repositori Github.

P.S: Ini ialah versi catatan blog bengkel yang saya berikan kepada bab ACM SCU.

Atas ialah kandungan terperinci Menggunakan AI Generatif dengan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!