Pengantar LMQL: Jembatan Antara SQL dan Model Bahasa Skala Besar

Structured Query Language, atau SQL (sering diucapkan “sequel”), adalah bahasa pemrograman deklaratif yang digunakan untuk menyimpan, mengambil, mengelola, dan memanipulasi data dalam sistem manajemen basis data.

Bahasa ini dikembangkan oleh peneliti IBM Raymond Boyce dan Donald Chamberlain pada awal 1970-an, namun baru tersedia secara komersial pada 1979 ketika Relational Software, Inc., yang kini berganti nama menjadi Oracle, memperkenalkan implementasinya.

Saat ini, SQL diterima luas sebagai standar sistem manajemen basis data relasional (RDBMS) karena kesederhanaannya dan kemampuannya untuk secara efisien mengelola serta menganalisis kumpulan data besar, menjadikannya tak tergantikan di dunia yang semakin digerakkan oleh data.

Namun, dunia yang digerakkan oleh data terus berkembang.

Kecerdasan buatan dengan cepat meraih popularitas, dan model bahasa skala besar muncul sebagai alat yang sangat kuat untuk berbagai tugas. Satu-satunya masalah adalah berinteraksi dengan model-model bahasa ini terkadang terasa seperti berbicara dalam bahasa asing. Di sinilah LMQL hadir.

LMQL dikembangkan oleh SRI Lab di ETH Zürich dan berperan sebagai penerjemah pribadi antara pengembang dan model bahasanya. Secara khusus, LMQL membawa kekuatan SQL ke ranah model bahasa, sehingga interaksi dengannya menjadi lebih mulus, efisien, dan menyenangkan.

Pada sisa tutorial ini, kita akan membahas:

• Apa itu LMQL?
• Mengapa LMQL?
• Cara menyiapkan LMQL
• Aplikasi praktis LMQL
• Keterbatasan LMQL
• Praktik terbaik

Apa itu LMQL?

LMQL, singkatan dari Language Models Query Language, adalah bahasa pemrograman inovatif untuk Large Language Models (LLM). Bahasa ini memadukan elemen deklaratif mirip SQL dengan sintaks skrip imperatif untuk menyediakan cara yang lebih terstruktur dan intuitif guna mengekstrak informasi atau menghasilkan respons dari LLM.

Selain itu, LMQL adalah superset Python, artinya LMQL bertindak sebagai ekstensi yang memperkenalkan fitur baru dan memperluas kapabilitas Python. Ini memungkinkan pengembang membuat prompt bahasa alami yang berisi teks dan kode, sehingga meningkatkan fleksibilitas dan daya ungkap kueri.

Menurut dokumentasi, “LMQL menawarkan cara baru untuk menganyam pemrograman tradisional dengan kemampuan memanggil LLM dalam kode Anda. LMQL melampaui bahasa templating tradisional dengan mengintegrasikan interaksi LLM secara native pada tingkat kode program Anda.”

Bahasa pemrograman ini dipresentasikan oleh para penciptanya dalam makalah riset berjudul Prompting is Programming: A Query Lnague for Large Language Models sebagai solusi untuk memungkinkan fenomena yang mereka sebut “LMP,” yaitu Language Model Prompting.

Sebagai konteks, model bahasa skala besar telah menunjukkan kinerja luar biasa di berbagai tugas, seperti tanya jawab dan pembuatan kode. Secara mendasar, LLM mahir secara otomatis menghasilkan urutan logis berdasarkan masukan yang diberikan menggunakan kemungkinan statistik.

Dengan memanfaatkan kapabilitas ini, pengguna dapat memberi instruksi atau contoh berbahasa alami kepada LLM untuk memicu eksekusi berbagai tugas hilir. Teknik prompting tingkat lanjut bahkan memungkinkan interaksi antara pengguna, model bahasa, dan alat eksternal seperti kalkulator.

Tantangannya adalah mencapai performa mutakhir atau menyesuaikan LLM untuk tugas tertentu, yang biasanya memerlukan implementasi program kompleks spesifik tugas yang masih bergantung pada interaksi spontan.

Prompting model bahasa adalah disiplin yang tengah berkembang dan semakin mendapat perhatian untuk mengatasi masalah ini. LMQL mematuhi prinsip LMP, termasuk menyediakan kombinasi intuitif antara text prompting dan scripting untuk LLM serta memungkinkan pengguna menentukan kendala atas keluaran model bahasa.

Mengapa LMQL?

Generasi terbaru model bahasa dapat dengan mudah diprompt secara konseptual dengan contoh atau instruksi. Namun, memanfaatkan potensi penuhnya dan tetap mengikuti perkembangan saat model baru dirilis memerlukan pemahaman mendalam tentang cara kerja internalnya serta pustaka dan implementasi spesifik vendor.

Sebagai contoh, membatasi proses decoding pada daftar kata atau frasa legal bisa menantang karena model bahasa bekerja dengan token. Baik Anda menggunakan LLM secara lokal maupun melalui API, biayanya cukup tinggi karena jaringan yang sangat besar.

LMQL dapat mengurangi jumlah panggilan invoke model bahasa (LM) dengan memanfaatkan perilaku bawaan dan ruang pencarian yang diperkenalkan oleh kendala.

Alasan lain untuk LMQL adalah banyak teknik prompting yang memerlukan komunikasi bolak-balik antara model bahasa dan pengguna (seperti yang kita lihat pada chatbot seperti ChatGPT) atau antarmuka yang sangat khusus, misalnya yang digunakan untuk melakukan perhitungan aritmetika dengan logika kontrol eksternal.

Menerapkan prompt semacam ini membutuhkan banyak pekerjaan manual dan interaksi dengan prosedur decoding model, yang membatasi generalitas implementasi yang dihasilkan. Terakhir, karena sebuah LM hanya dapat menghasilkan satu token (sub-kata) pada satu waktu, proses penyelesaian dapat memerlukan banyak panggilan.

LM yang ada tidak menyediakan fungsi untuk membatasi keluaran, padahal hal ini sangat penting jika LM digunakan di produksi. Misalnya, bayangkan Anda membangun aplikasi analisis sentimen untuk menandai ulasan negatif. Program akan mengharapkan LLM merespons dengan sesuatu seperti “positif,” “negatif,” atau “netral.”

Namun, cukup sering LLM mungkin mengatakan sesuatu seperti, “The sentiment for the provided customer review is positive,” yang sulit diproses oleh API Anda. Karena itu, kendala sangat bermanfaat.

Dengan LMQL, Anda dapat mengontrol keluaran dengan istilah yang mudah dipahami manusia alih-alih token yang digunakan LLM.

Menyiapkan LMQL

LMQL dapat dipasang secara lokal atau digunakan daring melalui Playground IDE berbasis web. Perhatikan bahwa jika Anda ingin menggunakan model self-hosted melalui Transformers atau llama.cpp, Anda harus memasang LMQL secara lokal. Berikut caranya:

Instalasi dan Penyiapan Lingkungan

Memasang LMQL secara lokal cukup mudah.

Yang perlu Anda lakukan hanyalah menjalankan perintah berikut di lingkungan Python >= 3.10:

pip install lmql

Jika Anda berniat menjalankan model pada GPU lokal, maka Anda harus memasang LMQL di lingkungan dengan instalasi PyTorch >= 1.11 yang mendukung GPU.

Berikut perintah untuk memasang LMQL dengan dependensi GPU melalui pip:

pip install lmql[hf]

Catatan: memasang dependensi di lingkungan virtual adalah praktik yang baik.

Setelah instalasi, Anda memiliki tiga opsi untuk menjalankan program LMQL:

1. Playground
Anda dapat meluncurkan instance lokal Playground IDE

lmql playground

Perintah ini akan meluncurkan Playground IDE berbasis peramban, tetapi jika tidak terbuka otomatis, buka http://localhost:3000.

Perhatikan bahwa metode ini memerlukan instalasi Node.js.

2. Antarmuka baris perintah
Alternatif dari playground adalah alat baris perintah. Ini dapat digunakan untuk mengeksekusi file .lmql lokal. Untuk menggunakannya, cukup jalankan perintah berikut:

lmql run

3. Integrasi Python
Karena merupakan superset, LMQL dapat dijalankan langsung dari dalam program Python. Yang perlu Anda lakukan adalah mengimpor paket lmql. Seluruh kode kueri harus dijalankan melalui lmql.run atau dengan dekorator @lmql.query.

Saat menggunakan model Transformer lokal di Playground IDE atau alat baris perintah, Anda harus terlebih dahulu meluncurkan instance LMQL Inference API untuk model yang bersangkutan dengan mengeksekusi perintah lmql serve-model.

Memahami Sintaks LMQL

Program LMQL terdiri dari lima bagian fundamental, masing-masing berperan penting dalam menentukan perilaku sebuah kueri. Komponen tersebut meliputi:

• Kueri
• Decoder
• Model
• Kendala
• Distribusi

Mari kita bahas masing-masing lebih dalam.

Kueri

Sarana utama komunikasi antara model bahasa dan pengguna adalah blok kueri.

Berikut kueri LMQL dasar:

# Source: https://lmql.ai/docs/
"Say 'this is a test':[RESPONSE]" where len(TOKENS(RESPONSE)) < 25

—-- Model Output—--
"""
Say 'this is a test': RESPONSE This is a test
"""

Blok kueri memperlakukan setiap string tingkat atas sebagai kueri langsung ke model bahasa. Mirip dengan f-string Python, string kueri ini mendukung dua sub-bidang escape khusus.

Perhatikan frasa yang akan dihasilkan model bahasa direpresentasikan menggunakan [varname]. Ini juga dikenal sebagai hole — kita akan bahas klausa where sebentar lagi.

Pengambilan nilai variabel dari lingkup saat ini juga dapat dilakukan menggunakan {varname}.

Contohnya:

# Source: https://lmql.ai/docs/language/overview.html
# review to be analyzed
review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""

# use prompt statements to pass information to the model
"Review: {review}"

Decoder

Berbagai algoritma decoding yang digunakan untuk menghasilkan teks dari distribusi token model bahasa didukung oleh LMQL. Ini memungkinkan algoritma decoding ditentukan di awal kueri.

Ada dua cara untuk menentukan algoritma decoding yang akan digunakan:

1. Sebagai bagian dari kueri - di sini Anda menentukan algoritma dan parameternya sebagai bagian dari kueri. Menurut dokumentasi LMQL, “Hal ini sangat berguna jika pilihan decoder Anda relevan dengan program konkret yang Anda tulis.” Berikut tampilan kodenya:

# Source: https://lmql.ai/docs/language/decoding.html
# use beam search with beam width 2 for
# the entire program
beam(n=2)

# uses beam search to generate RESPONSE 
"This is a query with a specified decoder: [RESPONSE]"

2. Secara eksternal - di sini algoritma dan parameter decoding ditentukan secara eksternal, yaitu terpisah dari program aktual. Perhatikan ini hanya dimungkinkan ketika LMQL digunakan dari konteks Python

# Source: https://lmql.ai/docs/language/decoding.htmlimport lmql

@lmql.query(model="openai/text-davinci-003", decoder="sample", temperature=1.8)
def tell_a_joke():
    '''lmql
    """A list good dad joke. A indicates the punchline:
    Q:[JOKE]
    A:[PUNCHLINE]""" where STOPS_AT(JOKE, "?") and  STOPS_AT(PUNCHLINE, "\n")
    '''

tell_a_joke() # uses the decoder specified in @lmql.query(...)
tell_a_joke(decoder="beam", n=2) # uses a beam search decoder with n=2

Model

LMQL didefinisikan oleh pengembangnya sebagai “bahasa front-end tingkat tinggi untuk pembuatan teks.” Artinya, LMQL tidak spesifik pada satu model pembuatan teks. Alih-alih, berbagai model pembuatan teks didukung di backend, seperti OpenAI model, llama.cpp dan HuggingFace Transformers.

Memuat model cukup mudah. Anda dapat menggunakan fungsi lmql.model(...), yang menghasilkan objek lmql.LMM.

Berikut tampilannya:

# Source: https://lmql.ai/docs/models/
lmql.model("openai/gpt-3.5-turbo-instruct") # OpenAI API model
lmql.model("random", seed=123) # randomly sampling model
lmql.model("llama.cpp:<YOUR_WEIGHTS>.gguf") # llama.cpp model

lmql.model("local:gpt2") # load a `transformers` model in-process
lmql.model("local:gpt2", cuda=True, load_in_4bit=True) # load a `transformers` model in process with additional arguments
lmql.model("gpt2") # access a `transformers` model hosted via `lmql serve-model`

Setelah objek lmql.LLM dibuat, Anda dapat meneruskan model ke program kueri menggunakan salah satu dari dua metode:

1. Menentukan model secara eksternal

# Source: https://lmql.ai/docs/models/
import lmql

# uses 'chatgpt' by default
@lmql.query(model="chatgpt")
def tell_a_joke():
    '''lmql
    """A great good dad joke. A indicates the punchline
    Q:[JOKE]
    A:[PUNCHLINE]""" where STOPS_AT(JOKE, "?") and \
                           STOPS_AT(PUNCHLINE, "\n")
    '''

tell_a_joke() # uses chatgpt
tell_a_joke(model=lmql.model("openai/text-davinci-003")) # uses text-davinci-003

2. Menggunakan kueri dengan klausa from

# Source: https://lmql.ai/docs/models/
argmax
    "This is a query with a specified 'from'-clause: [RESPONSE]"
from
    "openai/text-ada-001"

Kendala

Salah satu daya tarik utama LMQL adalah komponen kendalanya. Secara khusus, LMQL memungkinkan pengguna menentukan kendala pada keluaran model bahasa. Ini membantu dalam scripted prompting dengan menjamin keluaran model berakhir di titik yang dimaksud dan juga memberi pengguna kendali atas model selama decoding.

Kendala yang didukung meliputi:

• Stopping Phrases
• Number Type Constraints
• Choice From Set
• Character Length
• Token Length
• Regex Constraints Preview
• Mengombinasikan Kendala
• Custom

Lihat halaman Constraints dalam dokumentasi LMQL untuk mempelajari lebih lanjut.

Distribusi

Instruksi distribusi adalah komponen kunci dalam LMQL. Ini memberikan kendali atas format dan struktur keluaran dengan mendefinisikan bagaimana hasil yang dihasilkan didistribusikan dan disajikan.

Berikut contoh penggunaannya:

# Source: https://lmql.ai/docs/language/overview.html
argmax
    # review to be analyzed
    review = """We had a great stay. Hiking in the mountains was fabulous and the food is really good."""

    # use prompt statements to pass information to the model
    "Review: {review}"
    "Q: What is the underlying sentiment of this review and why?"
    # template variables like [ANALYSIS] are used to generate text
    "A:[ANALYSIS]" where not "\n" in ANALYSIS

    # use constrained variable to produce a classification
    "Based on this, the overall sentiment of the message can be considered to be[CLS]"
distribution
   CLS in [" positive", " neutral", " negative"]

                  ----- Model Output ------
Review: We had a great stay. Hiking in the mountains was fabulous and the food is really good.
Q: What is the underlying sentiment of this review and why?
A: ANALYSIS The underlying sentiment of this review is positive because the reviewer had a great stay, enjoyed the hiking and found the food to be good.
Based on this, the overall sentiment of the message can be considered to be CLS

Keterbatasan LMQL dan Dukungan Komunitas

Seperti halnya semua teknologi, ada beberapa keterbatasan pada LMQL. Misalnya:

• Pustaka LMQL belum lama hadir dan belum terlalu populer. Akibatnya, komunitasnya cukup kecil dan hanya ada sedikit sumber daya eksternal yang tersedia saat Anda mengalami kendala.
• Dokumentasi pustakanya belum sedetail yang semestinya.
• Keterbatasan pada OpenAI API membuat LMQL tidak dapat dimanfaatkan sepenuhnya dengan ChatGPT karena model yang paling populer dan berkinerja terbaik tidak dapat diakses.

Meskipun ini bisa menjadi penghalang bagi pengguna yang mempertimbangkan untuk menggunakan LMQL, penting untuk dicatat bahwa pustaka ini masih cukup baru dan masih dalam pengembangan — keterbatasan ini mungkin akan teratasi pada versi berikutnya.

Kesimpulan

LMQL adalah bahasa pemrograman mirip SQL yang juga merupakan superset Python. LMQL menyederhanakan proses mengekstrak informasi atau menghasilkan respons dari LLM dengan memadukan elemen deklaratifnya dengan sintaks skrip imperatif. Pengembang dapat memanfaatkan LMQL untuk mengontrol proses generasi teks secara efektif, sehingga menjadi alat yang sangat berharga untuk berbagai aplikasi di industri teknologi.

Untuk melanjutkan pembelajaran Anda, lihat:

• LlamaIndex: Menambahkan Data Pribadi ke LLM
• 10 Alternatif ChatGPT Teratas yang Dapat Anda Coba Hari Ini
• Pengantar ChatGPT
• Cara Melatih LLM dengan PyTorch
• Pengantar LangChain untuk Rekayasa Data & Aplikasi Data
• Menggunakan LLM dengan Cohere API