หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

ประกาศจดหมายเหตุ

สูตรอาหารในที่เก็บนี้ได้ย้ายไปอัจฉริยะและได้รับการดูแลที่นั่น ในไม่ช้าพวกเขาจะได้รับการอัพเกรดด้วยการถือกำเนิดของการสนับสนุน Spacy-LLM ซึ่งมีการแจ้งเตือนที่ดีกว่าและผู้ให้บริการ LLM หลายราย นั่นคือเหตุผลที่เราเลือกที่จะเก็บถาวร repo นี้เพื่อเราจะได้มุ่งเน้นไปที่การบำรุงรักษาสูตรเหล่านี้เป็นส่วนหนึ่งของ Spacy และอัจฉริยะโดยตรง

คุณสามารถเรียนรู้เพิ่มเติมได้โดยการตรวจสอบส่วนโมเดลภาษาขนาดใหญ่บนเอกสาร

สูตร Openai อัจฉริยะ

พื้นที่เก็บข้อมูลนี้มีรหัสตัวอย่างเกี่ยวกับวิธีการรวม การเรียนรู้แบบศูนย์และไม่กี่ครั้งกับความพยายามในการเพิ่มความคิดเห็นเล็ก ๆ เพื่อให้ได้ ชุดข้อมูลคุณภาพสูงที่มีประสิทธิภาพสูงสุด โดยเฉพาะเราใช้แบบจำลองภาษาขนาดใหญ่ที่มีให้จาก OpenAI เพื่อให้เรามีชุดการคาดการณ์เริ่มต้นจากนั้นหมุนอินสแตนซ์อัจฉริยะบนเครื่องในท้องถิ่นของเราเพื่อผ่านการคาดการณ์เหล่านี้และดูแลพวกเขา สิ่งนี้ช่วยให้เราได้รับชุดข้อมูลมาตรฐานทองคำได้อย่างรวดเร็วและฝึกอบรมโมเดลขนาดเล็กที่ได้รับการดูแลซึ่งเหมาะกับความต้องการและกรณีการใช้งานที่แน่นอนของเรา

openai_prodigy.mp4

⏳การตั้งค่าและติดตั้ง

ตรวจสอบให้แน่ใจว่าได้ติดตั้งอัจฉริยะรวมถึงการพึ่งพา Python เพิ่มเติมสองสามครั้ง: 

python -m pip install prodigy -f https://[email protected]
python -m pip install -r requirements.txt

ด้วย XXXX-XXXX-XXXX-XXXX เป็นรหัสลิขสิทธิ์อัจฉริยะส่วนตัวของคุณ

จากนั้นสร้างคีย์ API ใหม่จาก openai.com หรือดึงรหัสที่มีอยู่ บันทึกคีย์ลับเช่นเดียวกับคีย์องค์กรและตรวจสอบให้แน่ใจว่าสิ่งเหล่านี้มีอยู่เป็นตัวแปรด้านสิ่งแวดล้อม ตัวอย่างเช่นตั้งค่าไว้ในไฟล์ .env ในไดเรกทอรีรูท: 

 OPENAI_ORG = "org-..."
OPENAI_KEY = "sk-..."

- การรับรู้เอนทิตี (NER)

ner.openai.correct : คำอธิบายประกอบที่มีการเรียนรู้แบบศูนย์หรือไม่กี่

สูตรนี้ทำนายการทำนายเอนทิตีที่ได้จากแบบจำลองภาษาขนาดใหญ่และช่วยให้คุณตั้งค่าสถานะให้ถูกต้องหรือเพื่อดูแลพวกเขาด้วยตนเอง สิ่งนี้ช่วยให้คุณสามารถรวบรวมชุดข้อมูลมาตรฐานทองคำได้อย่างรวดเร็วผ่านการเรียนรู้แบบศูนย์หรือการเรียนรู้ไม่กี่ครั้ง มันเหมือนกับการใช้สูตร ner.correct มาตรฐานใน prodi.gy แต่เราใช้ GPT-3 เป็นแบบจำลองแบ็กเอนด์เพื่อทำการคาดการณ์ 

python -m prodigy ner.openai.correct dataset filepath labels [--options] -F ./recipes/openai_ner.py
การโต้แย้ง พิมพ์ คำอธิบาย ค่าเริ่มต้น
dataset str ชุดข้อมูลอัจฉริยะเพื่อบันทึกคำอธิบายประกอบเป็น
filepath เส้นทาง พา ธ ไปยัง .jsonl data ไปยังคำอธิบายประกอบ อย่างน้อยข้อมูลควรมีฟิลด์ "text"
labels str รายการที่คั่นด้วยเครื่องหมายจุลภาคกำหนดป้ายกำกับ NER ที่แบบจำลองควรทำนาย
--lang , -l str ภาษาของข้อมูลอินพุต - จะถูกใช้เพื่อรับโทเค็นที่เกี่ยวข้อง "en"
--segment , -S บูล ตั้งค่าสถานะเพื่อตั้งค่าเมื่อตัวอย่างควรแบ่งออกเป็นประโยค โดยค่าเริ่มต้นบทความอินพุตแบบเต็มจะปรากฏขึ้น False
--model , -m str แบบจำลอง GPT-3 เพื่อใช้สำหรับการทำนายเบื้องต้น "text-davinci-003"
--prompt_path , -p เส้นทาง เส้นทางไปยังเทมเพลตพรอมต์ .jinja2 ./templates/ner_prompt.jinja2
--examples-path , -e เส้นทาง เส้นทางสู่ตัวอย่างเพื่อช่วยกำหนดงาน ไฟล์สามารถเป็น. yml, .yaml หรือ. json หากตั้งค่าเป็น None การใช้การเรียนรู้แบบไม่มีการยิง None
--max-examples , -n int จำนวนตัวอย่างสูงสุดที่จะรวมไว้ในพรอมต์ไปยัง openai หากตั้งค่าเป็น 0 การเรียนรู้แบบไม่มีการยิงจะถูกนำไปใช้เสมอแม้ว่าจะมีตัวอย่างก็ตาม 2
--batch-size -b int ขนาดแบทช์ของแบบสอบถามเพื่อส่งไปยัง OpenAI API 10
--verbose , -v บูล ตั้งค่าสถานะเพื่อพิมพ์ข้อมูลเพิ่มเติมไปยังเทอร์มินัล False

ตัวอย่างการใช้งาน

สมมติว่าเราต้องการรับรู้อาหารส่วนผสมและอุปกรณ์ทำอาหารจากข้อความที่เราได้รับจาก subreddit การปรุงอาหาร เราจะส่งข้อความไปยัง GPT-3 โฮสต์โดย OpenAI และให้คำอธิบายประกอบคำอธิบายประกอบเพื่ออธิบายรูปแบบภาษาประเภทของการคาดการณ์ที่เราต้องการ บางอย่างชอบ: 

 From the text below, extract the following entities in the following format:
dish: <comma delimited list of strings>
ingredient: <comma delimited list of strings>
equipment: <comma delimited list of strings>

Text:
...

เรากำหนดคำจำกัดความของพรอมต์นี้ในไฟล์. jinja2 ซึ่งอธิบายถึงวิธีการต่อท้ายตัวอย่างสำหรับการเรียนรู้ไม่กี่ครั้ง คุณสามารถสร้างเทมเพลตของคุณเองและมอบให้กับสูตรด้วยตัวเลือก --prompt-path หรือ -p นอกจากนี้ด้วย --examples-path หรือ -e คุณสามารถตั้งค่าเส้นทางไฟล์ของไฟล์. y (a) ml หรือ. json ที่มีตัวอย่างเพิ่มเติม: 

python -m prodigy ner.openai.correct my_ner_data ./data/reddit_r_cooking_sample.jsonl " dish,ingredient,equipment " -p ./templates/ner_prompt.jinja2 -e ./examples/ner.yaml -n 2 -F ./recipes/openai_ner.py

หลังจากได้รับผลลัพธ์จาก OpenAI API สูตรอัจฉริยะจะแปลงการคาดการณ์เป็นงานคำอธิบายประกอบที่สามารถแสดงผลได้ด้วยอัจฉริยะ งานยังแสดงพรอมต์ดั้งเดิมรวมถึงคำตอบดิบที่เราได้รับจากรูปแบบภาษา

ที่นี่เราเห็นว่าแบบจำลองสามารถจดจำอาหารส่วนผสมและอุปกรณ์ทำอาหารได้อย่างถูกต้องตั้งแต่เริ่มต้น!

สูตรยังมีตัวเลือก --verbose หรือ -v ซึ่งมีพรอมต์ที่แน่นอนและการตอบสนองของเทอร์มินัลเมื่อได้รับการรับส่งข้อมูล โปรดทราบว่าเนื่องจากคำขอไปยัง API นั้นเป็นแบตช์คุณอาจต้องเลื่อนกลับเล็กน้อยเพื่อค้นหาพรอมต์ปัจจุบัน

ปรับตัวอย่างแบบโต้ตอบแบบโต้ตอบ

ในบางจุดคุณอาจสังเกตเห็นความผิดพลาดในการคาดการณ์ของโมเดลภาษา OpenAI ตัวอย่างเช่นเราสังเกตเห็นข้อผิดพลาดในการรับรู้อุปกรณ์ทำอาหารในตัวอย่างนี้:

หากคุณเห็นข้อผิดพลาดอย่างเป็นระบบประเภทนี้คุณสามารถคัดท้ายการคาดการณ์ในทิศทางที่ถูกต้องโดยแก้ไขตัวอย่างจากนั้นเลือกไอคอน "ธง" ขนาดเล็กที่ด้านบนขวาของ UI อัจฉริยะ:

เมื่อคุณเข้าชม การยอมรับ ในอินเทอร์เฟซอัจฉริยะตัวอย่างที่ถูกตั้งค่าสถานะจะถูกหยิบขึ้นมาโดยอัตโนมัติและเพิ่มลงในตัวอย่างที่ส่งไปยัง OpenAI API ซึ่งเป็นส่วนหนึ่งของพรอมต์

บันทึก
เนื่องจากแบทช์อัจฉริยะคำขอเหล่านี้พรอมต์จะได้รับการอัปเดตด้วยความล่าช้าเล็กน้อยหลังจากที่มีการส่งพรอมต์ชุดถัดไปไปที่ OpenAI คุณสามารถทดลองใช้ขนาดแบทช์ ( --batch-size หรือ -b ) เพื่อให้การเปลี่ยนแปลงมีผลเร็วขึ้น แต่สิ่งนี้อาจส่งผลเสียต่อความเร็วของเวิร์กโฟลว์คำอธิบายประกอบ

ner.openai.fetch : ดึงตัวอย่างล่วงหน้า

สูตร ner.openai.correct ดึงตัวอย่างจาก openai ในขณะที่คำอธิบายประกอบ แต่เรายังรวมสูตรที่สามารถดึงตัวอย่างชุดใหญ่ล่วงหน้า 

python -m prodigy ner.openai.fetch input_data.jsonl predictions.jsonl " dish,ingredient,equipment " -F ./recipes/ner.py

สิ่งนี้จะสร้างไฟล์ predictions.jsonl ที่สามารถโหลดได้ด้วยสูตร ner.manual

โปรดทราบว่า OpenAI API อาจส่งคืนข้อผิดพลาด "429 มากเกินไป" เมื่อร้องขอข้อมูลมากเกินไปในครั้งเดียว - ในกรณีนี้ดีที่สุดเพื่อให้แน่ใจว่าคุณขอตัวอย่าง 100 หรือมากกว่านั้นในแต่ละครั้ง

การส่งออกคำอธิบายประกอบและการฝึกอบรมแบบจำลอง NER

หลังจากที่คุณได้รับการดูแลชุดการคาดการณ์แล้วคุณสามารถส่งออกผลลัพธ์ด้วย db-out : 

python -m prodigy db-out my_ner_data  > ner_data.jsonl

รูปแบบของคำอธิบายประกอบที่ส่งออกมีข้อมูลทั้งหมดที่คุณต้องการในการฝึกอบรมแบบดาวน์สตรีมขนาดเล็ก แต่ละตัวอย่างในชุดข้อมูลมีข้อความต้นฉบับโทเค็นขยายคำอธิบายประกอบที่แสดงถึงเอนทิตี ฯลฯ

นอกจากนี้คุณยังสามารถส่งออกข้อมูลไปยังรูปแบบไบนารีของ Spacy โดยใช้ data-to-spacy รูปแบบนี้ช่วยให้คุณโหลดคำอธิบายประกอบเป็นวัตถุ Doc Spacy ซึ่งสามารถสะดวกสำหรับการแปลงเพิ่มเติม คำสั่ง data-to-spacy ยังทำให้ง่ายต่อการฝึกอบรมแบบจำลอง NER ด้วย Spacy ก่อนอื่นคุณส่งออกข้อมูลระบุข้อมูลรถไฟเป็น 20% ของทั้งหมด: 

python -m prodigy data-to-spacy ./data/annotations/ --ner my_ner_data -es 0.2

จากนั้นคุณสามารถฝึกอบรมนางแบบด้วยเครื่องรางหรืออัจฉริยะ: 

python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o ner-model

สิ่งนี้จะบันทึกโมเดลไปยัง ner-model/ Directory

นอกจากนี้เรายังรวมสคริปต์ทดลองเพื่อโหลดในรูปแบบไบนารี .spacy และฝึกอบรมโมเดลด้วยไลบรารี HuggingFace transformers คุณสามารถใช้ข้อมูลเดียวกันกับที่คุณเพิ่งส่งออกและเรียกใช้สคริปต์เช่นนี้: 

 # First you need to install the HuggingFace library and requirements
pip install -r requirements_train.txt
python ./scripts/train_hf_ner.py ./data/annotations/train.spacy ./data/annotations/dev.spacy -o hf-ner-model

รูปแบบผลลัพธ์จะถูกบันทึกลงใน hf-ner-model/ directory

- การจัดหมวดหมู่ข้อความ (textcat)

textcat.openai.correct

สูตรนี้ช่วยให้เราสามารถจำแนกข้อความได้เร็วขึ้นด้วยความช่วยเหลือของรูปแบบภาษาขนาดใหญ่ นอกจากนี้ยังมี "เหตุผล" เพื่ออธิบายว่าทำไมเลือกฉลากเฉพาะ 

python -m prodigy textcat.openai.correct dataset filepath labels [--options] -F ./recipes/openai_textcat.py
การโต้แย้ง พิมพ์ คำอธิบาย ค่าเริ่มต้น
dataset str ชุดข้อมูลอัจฉริยะเพื่อบันทึกคำอธิบายประกอบเป็น
filepath เส้นทาง พา ธ ไปยัง .jsonl data ไปยังคำอธิบายประกอบ อย่างน้อยข้อมูลควรมีฟิลด์ "text"
labels str รายการที่คั่นด้วยเครื่องหมายจุลภาคที่กำหนดฉลากการจัดหมวดหมู่ข้อความที่โมเดลควรทำนาย
--lang , -l str ภาษาของข้อมูลอินพุต - จะถูกใช้เพื่อรับโทเค็นที่เกี่ยวข้อง "en"
--segment , -S บูล ตั้งค่าสถานะเพื่อตั้งค่าเมื่อตัวอย่างควรแบ่งออกเป็นประโยค โดยค่าเริ่มต้นบทความอินพุตแบบเต็มจะปรากฏขึ้น False
--model , -m str แบบจำลอง GPT-3 เพื่อใช้สำหรับการทำนายเบื้องต้น "text-davinci-003"
--prompt-path , -p เส้นทาง เส้นทางไปยังเทมเพลตพรอมต์ .jinja2 ./templates/textcat_prompt.jinja2
--examples-path , -e เส้นทาง เส้นทางสู่ตัวอย่างเพื่อช่วยกำหนดงาน ไฟล์สามารถเป็น. yml, .yaml หรือ. json หากตั้งค่าเป็น None การใช้การเรียนรู้แบบไม่มีการยิง None
--max-examples , -n int จำนวนตัวอย่างสูงสุดที่จะรวมไว้ในพรอมต์ไปยัง openai หากตั้งค่าเป็น 0 การเรียนรู้แบบไม่มีการยิงจะถูกนำไปใช้เสมอแม้ว่าจะมีตัวอย่างก็ตาม 2
--batch-size -b int ขนาดแบทช์ของแบบสอบถามเพื่อส่งไปยัง OpenAI API 10
--exclusive-classes , -E บูล ตั้งค่าสถานะเพื่อให้งานจำแนกประเภทพิเศษ False
--verbose , -v บูล ตั้งค่าสถานะเพื่อพิมพ์ข้อมูลเพิ่มเติมไปยังเทอร์มินัล False

ตัวอย่างการใช้งาน

สูตร textcat สามารถใช้สำหรับการจัดหมวดหมู่ข้อความแบบไบนารี multiclass และ multilabel คุณสามารถตั้งค่าได้โดยผ่านจำนวนฉลากที่เหมาะสมในพารามิเตอร์ --labels ; ตัวอย่างเช่นการผ่านฉลากเดียวจะเปลี่ยนเป็นการจำแนกประเภทไบนารีและอื่น ๆ เราจะพูดคุยเกี่ยวกับแต่ละคนในส่วนการดำเนินการ

การจัดหมวดหมู่ข้อความไบนารี

สมมติว่าเราต้องการทราบว่าความคิดเห็นของ Reddit โดยเฉพาะพูดถึงสูตรอาหารหรือไม่ เราจะส่งข้อความไปยัง GPT-3 และให้พรอมต์ที่สั่งการคาดการณ์ที่เราต้องการ 

 From the text below, determine wheter or not it contains a recipe. If it is a 
recipe, answer "accept." If it is not a recipe, answer "reject."

Your answer should only be in the following format:
answer: <string>
reason: <string>

Text:

สำหรับการจำแนกแบบไบนารีเราต้องการให้ GPT-3 กลับ "ยอมรับ" หากข้อความที่กำหนดเป็นสูตรอาหารและ "ปฏิเสธ" มิฉะนั้น ข้อเสนอแนะของ GPT-3 จะแสดงอย่างเด่นชัดใน UI เราสามารถกดปุ่ม Accept (Check Mark) เพื่อรวมข้อความเป็นตัวอย่างที่เป็นบวกหรือกดปุ่ม ปฏิเสธ (Cross Mark) หากเป็นตัวอย่างเชิงลบ 

python -m prodigy textcat.openai.correct my_binary_textcat_data data/reddit_r_cooking_sample.jsonl --labels recipe -F recipes/openai_textcat.py

การจัดหมวดหมู่ข้อความ Multilabel และ Multiclass

ตอนนี้สมมติว่าเราต้องการจำแนกความคิดเห็น reddit เป็นสูตรคำติชมหรือคำถาม เราสามารถเขียนพรอมต่อไปนี้: 

 Classify the text below to any of the following labels: recipe, feedback, question.
The task is exclusive, so only choose one label from what I provided.

Your answer should only be in the following format:
answer: <string>
reason: <string>

Text:

จากนั้นเราสามารถใช้สูตรนี้เพื่อจัดการกรณี multilabel และ multiclass โดยส่งผ่านป้ายสามป้ายไปยังพารามิเตอร์ --labels เราควรตั้งค่าธง --exclusive-classes เพื่อแสดง UI ตัวเลือกเดียว: 

python -m prodigy textcat.openai.correct my_multi_textcat_data data/reddit_r_cooking_sample.jsonl 
    --labels recipe,feedback,question 
    --exclusive-classes 
    -F recipes/openai_textcat.py

เทมเพลตการเขียน

เราเขียนพรอมต์เหล่านี้เป็นเทมเพลต. jinja2 ที่สามารถนำตัวอย่างสำหรับการเรียนรู้ไม่กี่นัด คุณสามารถสร้างเทมเพลตของคุณเองและมอบให้กับสูตรด้วยตัวเลือก --prompt-path หรือ -p นอกจากนี้ด้วย --examples-path หรือ -e คุณสามารถตั้งค่าเส้นทางไฟล์ของไฟล์. y (a) ml หรือ. json ที่มีตัวอย่างเพิ่มเติม นอกจากนี้คุณยังสามารถเพิ่มบริบทในตัวอย่างเหล่านี้ในขณะที่เราสังเกตเพื่อปรับปรุงผลลัพธ์: 

python -m prodigy textcat.openai.correct my_binary_textcat_data 
    ./data/reddit_r_cooking_sample.jsonl 
    --labels recipe 
    --prompt-path ./templates/textcat_prompt.jinja2 
    --examples-path ./examples/textcat_binary.yaml -n 2 
    -F ./recipes/openai_textcat.py

คล้ายกับสูตร NER สูตรนี้ยังแปลงการคาดการณ์เป็นงานคำอธิบายประกอบที่สามารถแสดงผลด้วยอัจฉริยะ สำหรับการจำแนกประเภทไบนารีเราใช้อินเทอร์เฟซ classification กับองค์ประกอบ HTML ที่กำหนดเองในขณะที่สำหรับการจัดหมวดหมู่ข้อความ multilabel หรือ multiclass เราใช้อินเตอร์เฟสคำอธิบายประกอบ choice ขอให้สังเกตว่าเรารวมการตอบสนองดั้งเดิมและการตอบสนอง OpenAI ใน UI

สุดท้ายคุณสามารถใช้ธง --verbose หรือ -v เพื่อแสดงพรอมต์และการตอบสนองที่แน่นอนบนเทอร์มินัล โปรดทราบว่าเนื่องจากคำขอไปยัง API นั้นเป็นแบตช์คุณอาจต้องเลื่อนกลับเล็กน้อยเพื่อค้นหาพรอมต์ปัจจุบัน

ปรับตัวอย่างแบบโต้ตอบแบบโต้ตอบ

คล้ายกับสูตร NER คุณยังสามารถคัดท้ายการทำนายในทิศทางที่ถูกต้องโดยการแก้ไขตัวอย่างจากนั้นเลือกไอคอน "ธง" ขนาดเล็กที่ด้านบนขวาของ UI อัจฉริยะ:

เมื่อคุณกดปุ่ม Accept บนอินเทอร์เฟซอัจฉริยะตัวอย่างที่ถูกตั้งค่าสถานะจะถูกหยิบขึ้นมาและเพิ่มลงในตัวอย่างไม่กี่นัดที่ส่งไปยัง OpenAI API ซึ่งเป็นส่วนหนึ่งของพรอมต์

บันทึก
เนื่องจากแบทช์อัจฉริยะคำขอเหล่านี้พรอมต์จะได้รับการอัปเดตด้วยความล่าช้าเล็กน้อยหลังจากที่มีการส่งพรอมต์ชุดถัดไปไปที่ OpenAI คุณสามารถทดลองใช้ขนาดแบทช์ ( --batch-size หรือ -b ) เพื่อให้การเปลี่ยนแปลงมีผลเร็วขึ้น แต่สิ่งนี้อาจส่งผลเสียต่อความเร็วของเวิร์กโฟลว์คำอธิบายประกอบ

textcat.openai.fetch : ดึงตัวอย่างการจัดหมวดหมู่ข้อความล่วงหน้าล่วงหน้า

สูตร textcat.openai.fetch ช่วยให้เราสามารถดึงตัวอย่างจำนวนมากล่วงหน้า สิ่งนี้มีประโยชน์เมื่อคุณอยู่กับข้อมูลที่มีการปรับปรุงสูงและสนใจในตัวอย่างที่หายากเท่านั้น 

python -m prodigy textcat.openai.fetch input_data.jsonl predictions.jsonl --labels Recipe -F ./recipes/openai_textcat.py

สิ่งนี้จะสร้างไฟล์ predictions.jsonl ที่สามารถโหลดได้ด้วยสูตร textcat.manual

โปรดทราบว่า OpenAI API อาจส่งคืนข้อผิดพลาด "429 มากเกินไป" เมื่อร้องขอข้อมูลมากเกินไปในทันที - ในกรณีนี้เป็นการดีที่สุดที่จะให้แน่ใจว่าคุณขอตัวอย่าง 100 หรือมากกว่านั้นในแต่ละครั้งและดูที่ขีด จำกัด อัตราของ API

การทำงานกับข้อมูลที่ไม่สมดุล

สูตร textcat.openai.fetch เหมาะสำหรับการทำงานกับชุดข้อมูลที่มีความไม่สมดุลของคลาสที่รุนแรง โดยปกติคุณต้องการค้นหาตัวอย่างของคลาสที่หายากแทนที่จะใส่คำอธิบายประกอบตัวอย่างสุ่ม จากตรงนั้นคุณต้องการที่จะยกตัวอย่างพวกเขาเพื่อฝึกอบรมแบบจำลองที่ดีและอื่น ๆ

นี่คือที่รุ่นภาษาขนาดใหญ่เช่น OpenAI อาจช่วยได้

ด้วยการใช้ชุดข้อมูล Reddit R/Cooking เราแจ้งให้ Openai มองหาความคิดเห็นที่คล้ายกับสูตรอาหาร แทนที่จะใส่คำอธิบายประกอบ 10,000 ตัวอย่างเราวิ่ง textcat.openai.fetch และได้รับ 145 ชั้นเรียนบวก จากตัวอย่าง 145 ตัวอย่างเหล่านั้น 114 กลายเป็นข้อดีที่แท้จริง (ความแม่นยำ 79%) จากนั้นเราตรวจสอบตัวอย่างเชิงลบ 1,000 ตัวอย่างและพบกรณีติดลบ 12 กรณี (เรียกคืน 98%)

ตามหลักการแล้วเมื่อเราใส่คำอธิบายประกอบชุดข้อมูลอย่างเต็มที่เราสามารถฝึกอบรมแบบจำลองภายใต้การดูแลที่ดีกว่าที่จะใช้มากกว่าพึ่งพาการทำนายแบบศูนย์ช็อตสำหรับการผลิต ค่าใช้จ่ายในการวิ่งต่ำและง่ายต่อการจัดการ

การส่งออกคำอธิบายประกอบและการฝึกอบรมรูปแบบการจัดหมวดหมู่ข้อความ

หลังจากที่คุณได้รับการดูแลชุดการคาดการณ์แล้วคุณสามารถส่งออกผลลัพธ์ด้วย db-out : 

python -m prodigy db-out my_textcat_data  > textcat_data.jsonl

รูปแบบของคำอธิบายประกอบที่ส่งออกมีข้อมูลทั้งหมดที่คุณต้องการในการฝึกอบรมแบบดาวน์สตรีมขนาดเล็ก แต่ละตัวอย่างในชุดข้อมูลมีข้อความต้นฉบับโทเค็นขยายคำอธิบายประกอบที่แสดงถึงเอนทิตี ฯลฯ

นอกจากนี้คุณยังสามารถส่งออกข้อมูลไปยังรูปแบบไบนารีของ Spacy โดยใช้ data-to-spacy รูปแบบนี้ช่วยให้คุณโหลดคำอธิบายประกอบเป็นวัตถุ Doc Spacy ซึ่งสามารถสะดวกสำหรับการแปลงเพิ่มเติม คำสั่ง data-to-spacy ยังทำให้ง่ายต่อการฝึกอบรมรูปแบบการจัดหมวดหมู่ข้อความด้วย Spacy ก่อนอื่นคุณส่งออกข้อมูลระบุข้อมูลรถไฟเป็น 20% ของทั้งหมด: 

 # For binary textcat
python -m prodigy data-to-spacy ./data/annotations/ --textcat my_textcat_data -es 0.2
# For multilabel textcat
python -m prodigy data-to-spacy ./data/annotations/ --textcat-multilabel my_textcat_data -es 0.2

จากนั้นคุณสามารถฝึกอบรมนางแบบด้วยเครื่องรางหรืออัจฉริยะ: 

python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o textcat-model

สิ่งนี้จะบันทึกโมเดลไปยัง textcat-model/ Directory

- คำศัพท์

terms.openai.fetch : ดึงวลีและข้อกำหนดตามแบบสอบถาม

สูตรนี้สร้างคำศัพท์และวลีที่ได้จากแบบจำลองภาษาขนาดใหญ่ ข้อกำหนดเหล่านี้สามารถดูแลและกลายเป็นไฟล์รูปแบบซึ่งสามารถช่วยงานคำอธิบายประกอบดาวน์สตรีมได้ 

python -m prodigy terms.openai.fetch query filepath [--options] -F ./recipes/openai_terms.py
การโต้แย้ง พิมพ์ คำอธิบาย ค่าเริ่มต้น
query str แบบสอบถามเพื่อส่งไปยัง openai
output_path เส้นทาง เส้นทางเพื่อบันทึกเอาต์พุต
--seeds , -s str วลีเมล็ดพันธุ์ที่คั่นด้วยเครื่องหมายจุลภาคอย่างน้อยหนึ่งวลี ""
--n , -n int จำนวนรายการขั้นต่ำที่จะสร้าง 100
--model , -m str รุ่น GPT-3 ที่จะใช้เพื่อความสำเร็จ "text-davinci-003"
--prompt-path , -p เส้นทาง เส้นทางไปยังเทมเพลตพรอมต์ Jinja2 templates/terms_prompt.jinja2
--verbose , -v บูล พิมพ์ข้อมูลเพิ่มเติมไปยังเทอร์มินัล False
--resume , -r บูล ดำเนินการต่อโดยการโหลดตัวอย่างข้อความจากไฟล์เอาต์พุต False
--progress -pb บูล พิมพ์ความคืบหน้าของสูตร False
--temperature , -t ลอย อุณหภูมิอุณหภูมิ openai 1.0
--top-p , --tp ลอย openai top_p param 1.0
--best-of -bo int openai best_of param " 10
--n-batch , -nb int openai batch size size 10
--max-tokens , -mt int โทเค็นสูงสุดเพื่อสร้างต่อการโทร 100

ตัวอย่างการใช้งาน

สมมติว่าคุณสนใจที่จะตรวจจับเทคนิคสเก็ตบอร์ดเป็นข้อความจากนั้นคุณอาจต้องการเริ่มต้นด้วยรายการคำศัพท์ที่รู้จัก คุณอาจต้องการเริ่มต้นด้วยการสืบค้นต่อไปนี้: 

 # Base behavior, fetch at least 100 terms/phrases
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 100 --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py

สิ่งนี้จะสร้างพรอมต์ให้ Openai ที่ขอให้ลองและสร้างตัวอย่างอย่างน้อย 100 ตัวอย่างของ "เทคนิคสเก็ตบอร์ด" มีขีด จำกัด สูงสุดถึงปริมาณโทเค็นที่สามารถสร้างได้โดย OpenAI แต่สูตรนี้จะพยายามเก็บคำศัพท์จนกว่าจะถึงจำนวนเงินที่ระบุ

คุณสามารถเลือกที่จะทำให้แบบสอบถามมีความซับซ้อนมากขึ้นหากคุณต้องการพยายามแม่นยำยิ่งขึ้น แต่คุณสามารถเลือกที่จะเพิ่มคำบางคำผ่าน --seeds สิ่งเหล่านี้จะทำหน้าที่เป็นตัวอย่างเริ่มต้นเพื่อช่วยคัดท้าย Openai ในทิศทางที่ถูกต้อง 

 # Base behavior but with seeds
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 100 --seeds " kickflip,ollie " --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py

การรวบรวมตัวอย่างมากมายอาจใช้เวลาสักครู่ดังนั้นจึงเป็นประโยชน์ในการแสดงความคืบหน้าผ่าน --progress เมื่อส่งคำขอ 

 # Adding progress output as we wait for 500 examples
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 500 --progress --seeds " kickflip,ollie " --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py

หลังจากรวบรวมตัวอย่างบางส่วนคุณอาจต้องการสร้างเพิ่มเติม คุณสามารถเลือกที่จะดำเนินการต่อจากไฟล์เอาต์พุตก่อนหน้า สิ่งนี้จะนำตัวอย่างเหล่านั้นกลับมาใช้ใหม่อย่างมีประสิทธิภาพเป็นเมล็ดพันธุ์เพื่อให้ Openai 

 # Use the `--resume` flag to re-use previous examples
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 50 --resume --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py

เมื่อสูตรเสร็จสิ้นคุณจะมีไฟล์ tricks.jsonl ที่มีเนื้อหาที่มีลักษณะเช่นนี้: 

{ "text" : " pop shove it " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " switch flip " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " nose slides " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " lazerflip " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " lipslide " , "meta" :{ "openai_query" : " skateboard tricks " }}
...

ไปสู่รูปแบบ

ตอนนี้คุณมีไฟล์ tricks.jsonl บนดิสก์ที่มีเทคนิคสเก็ตบอร์ด แต่คุณไม่สามารถสันนิษฐานได้ว่าสิ่งเหล่านี้จะถูกต้อง ขั้นตอนต่อไปคือการตรวจสอบข้อกำหนดและคุณสามารถใช้สูตร textcat.manual ที่มาพร้อมกับอัจฉริยะสำหรับสิ่งนั้น 

 # The tricks.jsonl was fetched from OpenAI beforehand
python -m prodigy textcat.manual skateboard-tricks-list tricks.jsonl --label skateboard-tricks

สิ่งนี้สร้างอินเทอร์เฟซที่มีลักษณะเช่นนี้:

คุณสามารถยอมรับหรือปฏิเสธแต่ละตัวอย่างด้วยตนเองและเมื่อคุณทำคำอธิบายประกอบเสร็จแล้วคุณสามารถส่งออกข้อความที่ใส่คำอธิบายประกอบลงในไฟล์รูปแบบผ่านสูตร terms.to-patterns 

 # Generate a `patterns.jsonl` file.
python -m prodigy terms.to-patterns skateboard-tricks-list patterns.jsonl --label skateboard-tricks --spacy-model blank:en

เมื่อสูตรเสร็จสิ้นคุณจะมีไฟล์ patterns.jsonl ที่มีเนื้อหาที่มีลักษณะเช่นนี้: 

{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " pop " },{ "lower" : " shove " },{ "lower" : " it " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " switch " },{ "lower" : " flip " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " nose " },{ "lower" : " slides " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " lazerflip " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " lipslide " }]} 
...

ข้อ จำกัด ที่รู้จัก

Openai มีขีด จำกัด อย่างหนักเกี่ยวกับขนาดที่รวดเร็ว คุณไม่สามารถมีโทเค็นที่มีขนาดใหญ่กว่า 4079 น่าเสียดายที่หมายความว่ามีข้อ จำกัด ในขนาดของรายการคำที่คุณสามารถสร้างได้ สูตรจะรายงานข้อผิดพลาดเมื่อสิ่งนี้เกิดขึ้น แต่ก็เป็นการดีที่จะรับรู้ถึงข้อ จำกัด นี้

- แจ้งการประเมิน A/B

ab.openai.prompts : การประเมิน A/B ของพรอมต์

เป้าหมายของสูตรนี้คือการอนุญาตให้ใครบางคนเปรียบเทียบคุณภาพของเอาต์พุตจากสองพรอมต์ในแบบเชิงปริมาณและตาบอด 

python -m prodigy ab.openai.prompts dataset inputs_path display_template_path prompt1_template_path prompt2_template_path [--options] -F ./recipes/openai_ab.py
การโต้แย้ง พิมพ์ คำอธิบาย ค่าเริ่มต้น
dataset str ชุดข้อมูลอัจฉริยะเพื่อบันทึกคำตอบลงใน
inputs_path เส้นทาง เส้นทางไปยังอินพุต JSONL
display_template_path เส้นทาง เทมเพลตสำหรับสรุปอาร์กิวเมนต์
prompt1_template_path เส้นทาง เส้นทางไปยังเทมเพลตพรอมต์ Jinja2 แรก
prompt2_template_path เส้นทาง เส้นทางไปยังเทมเพลตพรอมต์ Jinja2 ที่สอง
--model , -m str รุ่น GPT-3 ที่จะใช้เพื่อความสำเร็จ "text-davinci-003"
--batch-size -b int ขนาดแบทช์เพื่อส่งไปยัง Openai API 10
--verbose , -v บูล พิมพ์ข้อมูลเพิ่มเติมไปยังเทอร์มินัล False
--no-random -NR บูล อย่าสุ่มคำอธิบายประกอบใดที่แสดงว่าถูกต้อง False
--repeat , -r int ส่งพรอมต์เดียวกันไปยัง openai บ่อยแค่ไหน 1

ตัวอย่างการใช้งาน

ตัวอย่างเช่นลองสร้างไฮกุที่มีอารมณ์ขัน ในการทำเช่นนั้นก่อนอื่นเราต้องสร้างไฟล์ jinja สองไฟล์ที่แทนพรอมต์เพื่อส่งไปยัง OpenAI

templates/ab/prompt1.jinja2
 Write a haiku about {{topic}}.
templates/ab/prompt2.jinja2
 Write an incredibly hilarious haiku about {{topic}}. So funny!

คุณสามารถให้ตัวแปรสำหรับพรอมต์เหล่านี้โดยการสร้างไฟล์. jsonl ด้วยพารามิเตอร์ที่ต้องการ ในกรณีนี้เราต้องตรวจสอบให้แน่ใจว่า {{topic}} เป็นบัญชี

นี่คือตัวอย่างไฟล์ .jsonl ที่สามารถใช้งานได้

data/ab_example.jsonl
{ "id" : 0 , "prompt_args" : { "topic" : " star wars " }}
{ "id" : 0 , "prompt_args" : { "topic" : " kittens " }}
{ "id" : 0 , "prompt_args" : { "topic" : " the python programming language " }}
{ "id" : 0 , "prompt_args" : { "topic" : " maths " }}

บันทึก

อาร์กิวเมนต์ทั้งหมดภายใต้ prompt_args จะถูกส่งผ่านไปยังเทมเพลต Jinja id เป็นข้อบังคับและสามารถใช้เพื่อระบุกลุ่มในการวิเคราะห์ในภายหลัง

เราเกือบจะพร้อมที่จะประเมิน แต่สูตรนี้ต้องใช้เทมเพลต Jinja2 ขั้นสุดท้ายหนึ่งรายการ อันนี้จะไม่ถูกใช้เพื่อสร้างพรอมต์ แต่มันจะสร้างชื่อที่มีประโยชน์ที่เตือนผู้อธิบายคำอธิบายประกอบของงานปัจจุบัน นี่คือตัวอย่างของเทมเพลตดังกล่าว

templates/ab/input.jinja2
 A haiku about {{topic}}.

เมื่อคุณรวบรวมเทมเพลตทั้งหมดเหล่านี้เข้าด้วยกันคุณสามารถเริ่มต้นคำอธิบายประกอบได้ คำสั่งด้านล่างเริ่มต้นอินเทอร์เฟซคำอธิบายประกอบและยังใช้ตัวเลือก --repeat 4 สิ่งนี้จะช่วยให้มั่นใจได้ว่าแต่ละหัวข้อจะถูกใช้เพื่อสร้างพรอมต์อย่างน้อย 4 ครั้ง 

 python -m prodigy ab.openai.prompts haiku data/ab_example.jsonl templates/ab/input.jinja2 templates/ab/prompt1.jinja2 templates/ab/prompt2.jinja2 --repeat 5 -F recipes/openai_ab.py

นี่คือสิ่งที่อินเทอร์เฟซคำอธิบายประกอบเป็นเช่นนั้น:

เมื่อคุณดูที่อินเทอร์เฟซนี้คุณจะสังเกตเห็นว่าเทมเพลตชื่อจะแสดงผลและคุณสามารถเลือกจากสองตัวเลือกได้ ตัวเลือกทั้งสองเป็นคำตอบจาก OpenAI ที่สร้างขึ้นโดยเทมเพลตพร้อมท์สองแบบ นอกจากนี้คุณยังสามารถดู prompt_args ที่แสดงที่มุมล่างขวาของเมนูตัวเลือก

จากที่นี่คุณสามารถใส่คำอธิบายประกอบตัวอย่างที่คุณชื่นชอบและรวบรวมข้อมูลที่อาจช่วยให้คุณตัดสินใจได้ว่าพรอมต์ใดดีที่สุด

ผลลัพธ์

เมื่อคุณใส่คำอธิบายประกอบเสร็จแล้วคุณจะได้รับภาพรวมของผลลัพธ์ 

 ===========================   Evaluation results ===========================
✔ You preferred prompt1.jinja2

prompt1.jinja2   11
prompt2.jinja2    5

แต่คุณยังสามารถดึงคำอธิบายประกอบดิบจากฐานข้อมูลเพื่อการวิเคราะห์เพิ่มเติม 

 python -m prodigy db-out haiku

❓ต่อไปคืออะไร?

มีการทดลองติดตามผลที่น่าสนใจมากมายและมีวิธีมากมายในการปรับความคิดพื้นฐานให้เข้ากับงานหรือชุดข้อมูลที่แตกต่างกัน เราสนใจที่จะลองพรอมต์ที่แตกต่างกัน ยังไม่ชัดเจนว่ารูปแบบของคำอธิบายประกอบที่ร้องขอในอาจเปลี่ยนการคาดการณ์ของโมเดลหรือไม่ว่าจะมีพรอมต์ที่สั้นกว่าที่อาจทำงานได้เช่นกัน นอกจากนี้เรายังต้องการทำการทดลองแบบ end-to-end

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด