pyaskit
1.0.0
AskIt ทำหน้าที่เป็นไลบรารีเฉพาะหรือภาษาเฉพาะโดเมนที่ออกแบบมาเพื่อปรับปรุงการใช้งาน Large Language Models (LLM) เช่น GPT-4, Gemini, Claude, COHERE และ LLama2 ลดความซับซ้อนของวิศวกรรมที่รวดเร็วและขจัดข้อกำหนดในการแยกวิเคราะห์การตอบสนองจาก LLM ทำให้งานการเขียนโปรแกรมราบรื่นยิ่งขึ้น
เมื่อใช้ AskIt คุณสามารถปรับใช้ LLM สำหรับงานต่างๆ มากมาย เช่น:
pyaskit สามารถใช้ GPT, Gemini, Claude, COHERE หรือ LLama2 เป็นแบ็กเอนด์ได้ pyaskit ทำงานผ่าน OpenAI API, Gemini API, Claude API และ COHERE API หรือ LLama2 API นอกจาก Python แล้ว AskIt ยังถูกนำไปใช้ใน TypeScript อีกด้วย คุณสามารถเข้าถึงเวอร์ชัน TypeScript ts-askit
from pyaskit import ask
# Automatically parses the response to an integer
sum = ask ( int , "add 1 + 1" )
# `sum` is an integer with a value of 2 from typing import TypedDict , List
from pyaskit import ask
# Define a typed dictionary for programming languages
class PL ( TypedDict ):
name : str
year_created : int
# Automatically extracts structured information into a list of dictionaries
langs = ask ( List [ PL ], "List the two oldest programming languages." )
# `langs` holds information on the oldest programming languages in a structured format like
# [{'name': 'Fortran', 'year_created': 1957},
# {'name': 'Lisp', 'year_created': 1958}] from pyaskit import function
@ function ( codable = False )
def translate ( s : str , lang : str ) -> str :
"""Translate {{s}} into {{lang}} language."""
s = translate ( "こんにちは世界。" , "English" )
# `s` would be "Hello, world." from pyaskit import function
@ function ( codable = True )
def get_html ( url : str ) -> str :
"""Get the webpage from {{url}}."""
# When `codable` is set to True, the body of the function is automatically coded by an LLM.
html = get_html ( "https://github.com/katsumiok/pyaskit/blob/main/README.md" )
# `html` contains the HTML version of this README.md หากต้องการติดตั้ง AskIt ให้รันคำสั่งนี้ในเทอร์มินัลของคุณ:
pip install pyaskitหรือ
pip install git+https://github.com/katsumiok/pyaskit.gitก่อนที่จะใช้ AskIt คุณต้องตั้งค่าคีย์ API ของคุณเป็นตัวแปรสภาพแวดล้อมที่เหมาะสม:
OPENAI_API_KEYGOOGLE_API_KEYANTHROPIC_API_KEYCO_API_KEYGROQ_API_KEY ตัวอย่างเช่น หากต้องการใช้ OpenAI API คุณต้องตั้งค่าคีย์ OpenAI API เป็นตัวแปรสภาพแวดล้อม OPENAI_API_KEY :
export OPENAI_API_KEY= < your OpenAI API key > <your OpenAI API key> เป็นสตริงที่มีลักษณะดังนี้: sk-<your key> คุณสามารถค้นหาคีย์ OpenAI API ของคุณได้ในแดชบอร์ด OpenAI
คุณต้องระบุชื่อรุ่นเป็นตัวแปรสภาพแวดล้อม ASKIT_MODEL :
export ASKIT_MODEL= < model name > <model name> คือชื่อของรุ่นที่คุณต้องการใช้ AskIt ล่าสุดได้รับการทดสอบด้วย gpt-4 , gpt-3.5-turbo-16k , gemini-pro , claude-2.1 และ cohere-2.0 คุณสามารถดูรายการโมเดลที่มีอยู่ในเอกสาร OpenAI API, เอกสาร Gemini API, เอกสาร Claude API และเอกสารประกอบ COHERE API คุณยังสามารถค้นหารุ่นที่มีอยู่ในไฟล์ models.py
ก่อนที่จะใช้ AskIt กับ Llama 2 คุณต้องติดตั้งก่อน หากต้องการติดตั้ง Llama 2 ให้รันคำสั่งนี้ในเทอร์มินัลของคุณ:
pip install git+https://github.com/facebookresearch/llama.gitคุณต้องดาวน์โหลดโมเดลโทเค็นและจุดตรวจสอบของโมเดลที่คุณต้องการใช้ด้วย โปรดดูเอกสาร Llama 2 สำหรับรายละเอียดเพิ่มเติม
เรามีตัวอย่างการใช้ AskIt กับ Llama 2 ในไดเร็กทอรีตัวอย่าง หากต้องการรันตัวอย่าง ให้รันคำสั่งนี้ในเทอร์มินัลของคุณ:
torchrun --nproc_per_node 1 examples/use_llama2.py
--ckpt_dir llama-2-7b-chat/
--tokenizer_path tokenizer.model
--max_seq_len 512 --max_batch_size 6นี่คือตัวอย่างพื้นฐานบางส่วนที่จะช่วยให้คุณคุ้นเคยกับ AskIt :
import pyaskit as ai
s = ai . ask ( str , 'Paraphrase "Hello World!"' )
print ( s ) หากต้องการใช้ AskIt ให้เริ่มด้วยการนำเข้าโมดูล pyaskit ask API ซึ่งรับสองอาร์กิวเมนต์ - ประเภทเอาต์พุตและพร้อมท์ - สร้างเอาต์พุตของ LLM ในรูปแบบที่กำหนด ในกรณีนี้ ประเภทเอาต์พุตคือ str และพร้อมต์คือ Paraphrase "Hello World!" - คำอธิบายที่ครอบคลุมเกี่ยวกับประเภทใน AskIt มีให้ในส่วนประเภท การดำเนินการโค้ดนี้จะทำให้สามารถถอดความข้อความแจ้งได้ เช่น:
Greetings, Planet!
function มัณฑนากร มัณฑนากร function ช่วยให้สามารถกำหนดฟังก์ชันด้วยเทมเพลตพร้อมท์ พารามิเตอร์ของฟังก์ชันที่กำหนดสามารถใช้เป็นพารามิเตอร์ของเทมเพลตพร้อมต์ได้ ตัวอย่างเช่น,
from pyaskit import function
@ function ( codable = False )
def paraphrase ( text : str ) -> str :
"""Paraphrase {{text}}"""
s = paraphrase ( 'Hello World!' )
print ( s ) โดยที่ {{text}} แสดงถึงพารามิเตอร์เทมเพลตและสอดคล้องกับพารามิเตอร์ฟังก์ชัน
define API define API อนุญาตให้กำหนดพารามิเตอร์พร้อมต์โดยใช้ไวยากรณ์เทมเพลต:
import pyaskit as ai
paraphrase = ai . define ( str , 'Paraphrase {{text}}' )
s = paraphrase ( text = 'Hello World!' )
# s = paraphrase('Hello World!') # This is also valid
print ( s ) ในกรณีนี้ define API จะสร้างฟังก์ชันเทมเพลตที่สั่งให้ LLM ถอดความข้อความที่ระบุ เรียกใช้ฟังก์ชัน paraphrase ด้วย 'Hello World!' จะส่งกลับข้อความนี้ในเวอร์ชันถอดความ การรันโค้ดนี้อาจแสดงผลเช่น "Greetings, Planet!"
define API ช่วยให้สามารถสร้างฟังก์ชันที่กำหนดเองได้โดยตรงเพื่อควบคุมความสามารถของโมเดลภาษาขนาดใหญ่สำหรับงานที่หลากหลาย ตัวอย่างเพิ่มเติมสามารถพบได้ในไดเร็กทอรีตัวอย่าง
งานบางอย่าง เช่น งานที่ต้องการข้อมูลแบบเรียลไทม์ ทรัพยากรภายนอก เช่น การเข้าถึงเครือข่าย การเข้าถึงไฟล์ หรือการเข้าถึงฐานข้อมูล ไม่เหมาะสำหรับการดำเนินการ LLM อย่างไรก็ตาม AskIt สามารถจัดการงานเหล่านี้ได้โดยการแปลงพรอมต์เป็นโปรแกรม Python ในเบื้องหลัง
ตัวอย่างต่อมาสาธิตการใช้ AskIt เพื่อจัดการกับงานที่จำเป็นต้องมีการเข้าถึงเครือข่าย:
import pyaskit as ai
get_html = ai . define ( str , 'Get the webpage from {{url}}' ). compile ()
html = get_html ( url = 'https://csail.mit.edu' )
print ( html ) ในสถานการณ์สมมตินี้ คุณเพียงแค่ต้องเรียก compile() บนฟังก์ชันที่ส่งคืนโดย define API ฟังก์ชัน compile แปลงพรอมต์เป็นโปรแกรม Python และส่งกลับฟังก์ชันที่รันโค้ดนี้ โดยมีพฤติกรรมเหมือนกับฟังก์ชัน Python ทั่วไป
แม้ว่าตัวอย่างด้านบนจะไม่ได้ระบุประเภทของพารามิเตอร์ url แต่ AskIt ก็จัดเตรียม defun API ให้ดำเนินการดังกล่าว รหัสต่อไปนี้สาธิตวิธีการกำหนดฟังก์ชันที่ระบุประเภทของพารามิเตอร์ url เป็น str :
import pyaskit as ai
get_html = ai . defun ( str , { "url" : str }, 'Get the webpage from {{url}}' ). compile ()
html = get_html ( url = 'https://csail.mit.edu' )
print ( html ) อาร์กิวเมนต์ที่สองของ defun API คือพจนานุกรมที่จับคู่ชื่อพารามิเตอร์กับประเภท
เราสามารถทำสิ่งเดียวกันได้โดยใช้รหัสต่อไปนี้:
from pyaskit import function
@ function ( codable = True )
def get_html ( url : str ) -> str :
"""Get the webpage from {{url}}"""
html = get_html ( url = 'https://csail.mit.edu' )
print ( html )โมเดลการเรียนรู้ภาษา (LLM) นำเสนอข้อได้เปรียบของการเรียนรู้แบบไม่กี่ช็อต ซึ่งเป็นความสามารถที่ AskIt ใช้ในงานการเขียนโปรแกรม AskIt ช่วยให้คุณสามารถแก้ไขงานโดยใช้เทคนิคการเขียนโปรแกรมตามตัวอย่าง (PBE) โดยที่คุณให้ตัวอย่างของอินพุตและเอาต์พุตที่ต้องการ
ลองพิจารณาสร้างฟังก์ชันเพื่อเพิ่มเลขฐานสองสองตัว (แสดงเป็นสตริง) ฟังก์ชันนี้ยอมรับเลขฐานสองสองตัวและส่งกลับผลรวมในรูปแบบไบนารีเช่นกัน รหัสต่อไปนี้สาธิตการกำหนดฟังก์ชันดังกล่าวโดยใช้ตัวอย่างที่แสดงให้เห็น
from pyaskit import define
training_examples = [
{ "input" : { "x" : "1" , "y" : "0" }, "output" : "1" },
{ "input" : { "x" : "1" , "y" : "1" }, "output" : "10" },
{ "input" : { "x" : "101" , "y" : "11" }, "output" : "1000" },
{ "input" : { "x" : "1001" , "y" : "110" }, "output" : "1111" },
{ "input" : { "x" : "1111" , "y" : "1" }, "output" : "10000" },
]
add_binary_numbers = define ( str , "Add {{x}} and {{y}}" , training_examples = training_examples )
sum_binary = add_binary_numbers ( x = "101" , y = "11" )
print ( sum_binary ) # Output: "1000" ในตัวอย่างนี้ define API รับสามอาร์กิวเมนต์: ประเภทเอาต์พุต พรอมต์ และตัวอย่างการฝึก แต่ละรายการในรายการตัวอย่างการฝึกอบรมคือพจนานุกรมที่ประกอบด้วยพจนานุกรม 'อินพุต' (พร้อมชื่อตัวแปรและค่า) และ 'เอาต์พุต' ที่แสดงถึงเอาต์พุตของฟังก์ชันที่คาดหวังเมื่อได้รับอินพุต define API จะส่งคืนฟังก์ชันที่ยอมรับตัวแปรอินพุตเป็นอาร์กิวเมนต์ของคีย์เวิร์ดและส่งออกเอาต์พุตของ LLM ในประเภทที่ระบุ
ฟังก์ชัน add_binary_numbers ซึ่งเพิ่มเลขฐานสองสองตัว จะทำงานเหมือนกับฟังก์ชัน Python ทั่วไป
คุณสามารถใช้ฟังก์ชัน compile เพื่อทดสอบฟังก์ชันที่สร้างขึ้นโดยใช้รายการตัวอย่างการทดสอบเพิ่มเติมได้
รหัสต่อไปนี้สาธิตวิธีการทดสอบฟังก์ชันที่กำหนดไว้ข้างต้นด้วยตัวอย่างการทดสอบใหม่:
test_examples = [
{ "input" : { "x" : "0" , "y" : "1" }, "output" : "1" },
{ "input" : { "x" : "10" , "y" : "0" }, "output" : "10" },
{ "input" : { "x" : "110" , "y" : "10" }, "output" : "1000" },
]
f = add_binary_numbers . compile ( test_examples = test_examples )
sum_binary = f ( x = "101" , y = "11" )
print ( sum_binary ) # Output: "1000" ในที่นี้ f คือฟังก์ชันที่สร้างขึ้นซึ่งทำงานคล้ายกับ add_binary_numbers ด้วยการเปรียบเทียบเอาต์พุตของฟังก์ชันที่สร้างขึ้นกับเอาต์พุตที่คาดหวังสำหรับตัวอย่างการทดสอบแต่ละตัวอย่าง AskIt จะทำให้แน่ใจว่าฟังก์ชันที่สร้างขึ้นจะทำงานตามที่คาดไว้ หากเกิดความคลาดเคลื่อน AskIt จะพยายามแปลอีกครั้ง หลังจากพยายามแปลไม่สำเร็จหลายครั้ง AskIt ก็ทำให้เกิดข้อยกเว้น
AskIt เสนอ API เพื่อกำหนดประเภทเอาต์พุตสำหรับโมเดลการเรียนรู้ภาษา (LLM) การระบุประเภทเหล่านี้เป็นอาร์กิวเมนต์แรกในการ ask และ define API ทำให้คุณสามารถจัดการรูปแบบเอาต์พุตของ LLM ได้ คุณยังสามารถใช้คำแนะนำประเภทที่ให้มากับ Python ได้
ตารางต่อไปนี้อธิบายประเภทต่างๆ ที่ AskIt รองรับ:
| พิมพ์ | คำอธิบาย | พิมพ์ตัวอย่าง | ตัวอย่างค่า |
|---|---|---|---|
int | จำนวนเต็ม | t.int | 123 |
float | หมายเลขจุดลอยตัว | t.float | 1.23 |
bool | บูลีน | t.bool | จริง |
str | สตริง | t.str | "สวัสดีชาวโลก!" |
literal | ตัวอักษร | t.literal(123) | 123 |
list | รายการ | t.list(t.int) | [1, 2, 3] |
dict | พจนานุกรม | t.dict({'a': t.int,'b': t.str}) | {'a': 1, 'b': "abc"} |
record | พจนานุกรม | t.record(t.str, t.int) | {'a': 1, 'b': 2} |
tuple | ทูเพิล | t.tuple(t.int, t.str) | (1, "เอบีซี") |
union | ยูเนี่ยน (ค่าที่เป็นไปได้หลายค่า) | t.union(t.literal('yes'), t.literal('no')) | "ใช่" หรือ "ไม่" |
t.literal('yes') | t.literal('no') | "ใช่" หรือ "ไม่" | ||
t.literal('yes', 'no') | "ใช่" หรือ "ไม่" | ||
None | ไม่มี | None | ไม่มี |
โปรดทราบว่าการประกาศแต่ละประเภทช่วย AskIt ในการแยกวิเคราะห์และทำความเข้าใจผลลัพธ์ที่ต้องการ เพื่อให้มั่นใจว่า LLM ของคุณส่งคืนข้อมูลในรูปแบบที่แม่นยำที่คุณต้องการ
เทมเพลตพร้อมต์คือสตริงที่ประกอบด้วยตัวยึดตำแหน่งสำหรับพารามิเตอร์ของฟังก์ชันที่กำลังกำหนด ตัวยึดตำแหน่งจะแสดงด้วยเครื่องหมายปีกกาคู่ {{ และ }} และสามารถมีได้เฉพาะชื่อตัวแปรเท่านั้น ชื่อตัวแปรนี้จะถูกใช้เป็นพารามิเตอร์ในฟังก์ชันที่กำหนด
พารามิเตอร์ฟังก์ชันสามารถกำหนดได้สองวิธี: โดยอาร์กิวเมนต์ของคำหลักหรือตามอาร์กิวเมนต์ตำแหน่ง สำหรับอาร์กิวเมนต์ของคีย์เวิร์ด ชื่อตัวแปรภายในตัวยึดตำแหน่งจะทำหน้าที่เป็นชื่อของอาร์กิวเมนต์ของคีย์เวิร์ด สำหรับอาร์กิวเมนต์ตำแหน่ง ลำดับที่ตัวยึดตำแหน่งปรากฏจะกำหนดลำดับของอาร์กิวเมนต์ตำแหน่ง
พิจารณาตัวอย่างต่อไปนี้ซึ่งสาธิตวิธีการกำหนดฟังก์ชัน add ที่ยอมรับสองอาร์กิวเมนต์ x และ y แล้วส่งคืนผลรวม:
from pyaskit import define
import pyaskit . types as t
add = define ( t . int , '{{x}} + {{y}}' )
print ( add ( x = 1 , y = 2 )) # keyword arguments
print ( add ( 1 , 2 )) # positional arguments ในกรณีนี้ สามารถเรียกใช้ฟังก์ชัน add ได้โดยใช้คำหลักหรืออาร์กิวเมนต์ตำแหน่ง โดยให้ผลรวมของ x และ y ส่งคืนเป็นเอาต์พุต
โดยเฉพาะอย่างยิ่ง หากใช้ชื่อตัวแปรเดียวกันหลายครั้งในเทมเพลตพร้อมท์ การใช้งานในภายหลังจะถูกแมปกับเหตุการณ์เริ่มต้น สังเกตลักษณะการทำงานนี้ในตัวอย่างต่อไปนี้:
from pyaskit import define
import pyaskit . types as t
add = define ( t . int , '{{x}} + {{y}} + {{x}} + {{z}}' )
print ( add ( x = 1 , y = 2 , z = 3 ))
print ( add ( 1 , 2 , 3 )) ที่นี่ {{x}} ปรากฏขึ้นสองครั้งในเทมเพลตพร้อมท์ การเกิดขึ้นครั้งที่สองของแผนที่ {{x}} กลับไปที่ครั้งแรก ดังนั้น แม้ว่า {{z}} จะเป็นตัวยึดตำแหน่งที่สี่ในเทมเพลต แต่ก็สอดคล้องกับอาร์กิวเมนต์ที่สามของฟังก์ชัน
ดูที่ CONTRIBUTING.md สำหรับรายละเอียดเกี่ยวกับจรรยาบรรณของเรา และกระบวนการในการส่งคำขอดึงถึงเรา
โครงการนี้ได้รับอนุญาตภายใต้ใบอนุญาต MIT - ดูรายละเอียดในไฟล์ LICENSE.md
หากคุณใช้ซอฟต์แวร์ของเราในการวิจัย โปรดอ้างอิงรายงานของเรา:
@misc { okuda2023askit ,
title = { AskIt: Unified Programming Interface for Programming with Large Language Models } ,
author = { Katsumi Okuda and Saman Amarasinghe } ,
year = { 2023 } ,
eprint = { 2308.15645 } ,
archivePrefix = { arXiv } ,
primaryClass = { cs.PL }
}
