benchllm

?️‍♂️ BangkuLLM ?️‍♀️

? Integrasi Berkelanjutan untuk aplikasi yang didukung LLM ???

BenchLLM adalah pustaka sumber terbuka berbasis Python yang menyederhanakan pengujian Model Bahasa Besar (LLM) dan aplikasi yang didukung AI. Ini mengukur keakuratan model, agen, atau rantai Anda dengan memvalidasi respons pada sejumlah pengujian melalui LLM.

BenchLLM secara aktif digunakan di V7 untuk meningkatkan aplikasi LLM kami dan sekarang bersumber terbuka di bawah Lisensi MIT untuk berbagi dengan komunitas luas

Dapatkan bantuan tentang Discord atau Tweet di kami

---

Gunakan BenchLLM untuk:

• Uji tanggapan LLM Anda di sejumlah permintaan.
• Integrasi berkelanjutan untuk rantai seperti Langchain, agen seperti AutoGPT, atau model LLM seperti Llama atau GPT-4.
• Hilangkan rantai yang tidak stabil dan ciptakan kepercayaan pada kode Anda.
• Temukan tanggapan dan halusinasi yang tidak akurat dalam aplikasi Anda di setiap versi.

---

️ CATATAN: BenchLLM sedang dalam tahap awal pengembangan dan dapat berubah dengan cepat.

Untuk pelaporan bug, permintaan fitur, atau kontribusi, silakan buka masalah atau kirimkan permintaan tarik (PR) di halaman GitHub kami.

? Metodologi Pengujian BenchLLM

BenchLLM menerapkan metodologi dua langkah yang berbeda untuk memvalidasi model pembelajaran mesin Anda:

1. Pengujian : Tahap ini melibatkan menjalankan kode Anda terhadap sejumlah respons yang diharapkan dan menangkap prediksi yang dihasilkan oleh model Anda tanpa penilaian atau perbandingan langsung.

2. Evaluasi : Prediksi yang direkam dibandingkan dengan keluaran yang diharapkan menggunakan LLM untuk memverifikasi kesamaan faktual (atau secara opsional secara manual). Laporan perbandingan terperinci, termasuk status lulus/gagal dan metrik lainnya, dihasilkan.

Pemisahan metodis ini menawarkan gambaran komprehensif tentang performa model Anda dan memungkinkan kontrol dan penyempurnaan yang lebih baik pada setiap langkah.

Memasang

Untuk menginstal BenchLLM kami menggunakan pip

 pip install benchllm

Penggunaan

Mulailah dengan mengimpor perpustakaan dan gunakan dekorator @benchllm.test untuk menandai fungsi yang ingin Anda uji:

 import benchllm

# Your custom model implementation
def run_my_model ( input ):
    # Your model's logic goes here.
    return some_result

@ benchllm . test ( suite = "/path/to/test/suite" ) # If the tests are in the same directory, just use @benchllm.test.
def invoke_model ( input : str ):
    return run_my_model ( input )

Selanjutnya, persiapkan tes Anda. Ini adalah file YAML/JSON yang disusun sebagai berikut:

 input : What's 1+1? Be very terse, only numeric output
expected :
  - 2
  - 2.0

Dalam contoh di atas, input adalah kueri atau instruksi yang akan diproses oleh model Anda, dan expected berisi respons potensial yang harus dihasilkan oleh model Anda. Penting untuk dicatat bahwa input dapat berupa str sederhana atau kamus bertingkat yang lebih kompleks; BenchLLM akan mengekstrak jenis argumen input dalam kode Python dan memuat kolom input dari file YAML yang sesuai.

Secara default, BenchLLM menggunakan model GPT-3 OpenAI untuk evaluator semantic . Ini memerlukan pengaturan variabel lingkungan OPENAI_API_KEY . Jika Anda tidak ingin menggunakan evaluator default ini, Anda dapat menentukan evaluator alternatif (dibahas secara lebih rinci di bawah):

 export OPENAI_API_KEY= ' your-api-key '

Ganti 'kunci-api-Anda' dengan kunci API OpenAI Anda yang sebenarnya.

Untuk memulai pengujian, gunakan perintah bench run :

$ bench run

Secara default, perintah bench run mencari file Python yang mengimplementasikan dekorator @test di direktori saat ini. Untuk menargetkan file atau folder tertentu, tentukan secara langsung:

$ bench run path/to/my/file.py or/path/to/folder/with/files

Parameter --retry-count memungkinkan BenchLLM menjalankan pengujian beberapa kali, berguna untuk model yang mungkin memiliki variabilitas dalam keluarannya:

$ bench run --retry-count 5

BenchLLM menawarkan beberapa metode evaluasi untuk menentukan apakah prediksi sesuai dengan nilai yang diharapkan dari kasus uji. Anda dapat menggunakan parameter --evaluator untuk menentukan metode evaluasi:

Ada beberapa cara untuk mengevaluasi apakah prediksi fungsi pengujian cocok dengan nilai yang diharapkan dari kasus pengujian. Secara default, GPT-3 digunakan untuk membandingkan keluaran. Anda dapat menggunakan --evaluator untuk menggunakan metode lain

• semantic , memeriksa kesamaan semantik menggunakan model bahasa seperti GPT-3, GPT-3.5, atau GPT-4 ( --model parameter). Harap diperhatikan, untuk evaluator ini, Anda perlu menyetel variabel lingkungan OPENAI_API_KEY .
• embedding , menggunakan jarak kosinus antara vektor yang disematkan. Harap diperhatikan, untuk evaluator ini, Anda perlu menyetel variabel lingkungan OPENAI_API_KEY .
• string-match , memeriksa apakah string cocok (tidak peka huruf besar-kecil)
• interactive , pengguna secara manual menerima atau gagal dalam pengujian di terminal
• web , menggunakan pywebio untuk antarmuka web lokal yang sederhana

Evaluator non interaktif juga mendukung --workers N untuk menjalankan evaluasi secara paralel

$ bench run --evaluator string-match --workers 5

Untuk mempercepat proses evaluasi, BenchLLM menggunakan cache. Jika pasangan (prediksi, yang diharapkan) telah dievaluasi di masa lalu dan cache digunakan, keluaran evaluasi akan disimpan untuk evaluasi di masa mendatang. Ada beberapa jenis cache:

• memory , hanya menyimpan nilai keluaran selama proses saat ini. Ini sangat berguna ketika menjalankan dengan --retry-count N
• file , menyimpan cache di akhir proses sebagai file JSON di output/cache.json. Ini adalah perilaku default.
• none , tidak menggunakan cache apa pun.

$ bench run examples --cache memory

Saat mengembangkan model rantai atau agen pelatihan, mungkin ada saat di mana model ini perlu berinteraksi dengan fungsi eksternal — misalnya, membuat kueri ramalan cuaca atau menjalankan kueri SQL. Dalam skenario seperti itu, BenchLLM memfasilitasi kemampuan untuk meniru fungsi-fungsi ini. Hal ini membantu Anda membuat pengujian lebih mudah diprediksi dan memungkinkan penemuan panggilan fungsi yang tidak terduga.

 input : I live in London, can I expect rain today?
expected : ["no"]
calls :
  - name : forecast.get_n_day_weather_forecast
    returns : It's sunny in London.
    arguments :
      location : London
      num_days : 1

Pada contoh di atas, fungsi get_n_day_weather_forecast di modul forecast diolok-olok. Dengan kata lain, setiap kali fungsi ini dipanggil, model akan menerima "It's sunny in London" . BenchLLM juga memberikan peringatan jika fungsi dipanggil dengan nilai argumen yang berbeda dari get_n_day_weather_forecast(location=London, num_days=1) . Perlu diketahui, pemberian parameter argumen ini bersifat opsional.

? Evaluasi

Meskipun bench run menjalankan setiap fungsi pengujian dan kemudian mengevaluasi outputnya, seringkali bermanfaat untuk memisahkannya menjadi dua langkah. Misalnya, jika Anda ingin seseorang melakukan evaluasi secara manual atau jika Anda ingin mencoba beberapa metode evaluasi pada fungsi yang sama.

$ bench run --no-eval

Ini akan menghasilkan file json dalam output/latest/predictions Kemudian nanti Anda dapat mengevaluasinya

$ bench eval output/latest/predictions

? API

Untuk kontrol lebih detail, BenchLLM menyediakan API. Anda tidak perlu menambahkan pengujian YML/JSON untuk dapat mengevaluasi model Anda. Sebagai gantinya, Anda dapat:

• Buat instance objek Test
• Gunakan objek Tester untuk menghasilkan prediksi
• Gunakan objek Evaluator untuk mengevaluasi model Anda

 from benchllm import StringMatchEvaluator , Test , Tester

# Instantiate your Test objects
tests = [
    Test ( input = "What's 1+1?" , expected = [ "2" , "It's 2" ]),
    Test ( input = "First rule of fight club?" , expected = [ "Do not talk about fight club" ]),
]

# Use a Tester object to generate predictions using any test functions
tester = Tester ( my_test_function )
tester . add_tests ( tests )
predictions = tester . run ()

# Use an Evaluator object to evaluate your model
evaluator = StringMatchEvaluator ()
evaluator . load ( predictions )
results = evaluator . run ()

print ( results )

Jika Anda ingin menggabungkan caching dan menjalankan beberapa tugas evaluasi paralel, Anda dapat memodifikasi evaluator Anda sebagai berikut:

 from benchllm . cache import FileCache

...

evaluator = FileCache ( StringMatchEvaluator ( workers = 2 ), Path ( "path/to/cache.json" ))
evaluator . load ( predictions )
results = evaluator . run ()

Dalam contoh ini, FileCache digunakan untuk mengaktifkan caching, dan parameter workers StringMatchEvaluator diatur ke 2 untuk memungkinkan evaluasi paralel. Hasil cache disimpan dalam file yang ditentukan oleh Path("path/to/cache.json") .

☕️ Perintah

• bench add : Tambahkan tes baru ke suite.
• bench tests : Daftar semua tes di suite.
• bench run : Jalankan semua atau target rangkaian pengujian.
• bench eval : Menjalankan evaluasi uji coba yang ada.

? Menyumbang

BenchLLM dikembangkan untuk Python 3.10, meskipun mungkin juga berfungsi dengan versi Python lainnya. Kami merekomendasikan penggunaan lingkungan Python 3.10 dan pip >= 23. Anda dapat menggunakan conda atau pengelola lingkungan lainnya untuk menyiapkan lingkungan:

$ conda create --name benchllm python=3.10
$ conda activate benchllm
$ pip install -e " .[dev] "

Untuk menjalankan semua contoh, pertama-tama instal dependensi tambahan contoh

$ pip install -e " .[examples] "

Langkah-langkah kontribusi:

1. Cabangkan repositori.
2. Buat cabang baru untuk perubahan Anda.
3. Buat perubahan Anda.
4. Uji perubahan Anda.
5. Kirimkan permintaan tarik.

Kami mematuhi panduan gaya PEP8. Silakan ikuti panduan ini saat berkontribusi.

Jika Anda memerlukan dukungan apa pun, jangan ragu untuk membuka masalah di halaman GitHub kami.