PromptingTools.jl
v0.65.0
ปรับปรุงชีวิตของคุณโดยใช้ PromptingTools.jl แพ็คเกจ Julia ที่ทำให้การโต้ตอบกับโมเดลภาษาขนาดใหญ่ง่ายขึ้น
การแจ้งเตือน tools.jl ไม่ได้มีไว้สำหรับการสร้างระบบขนาดใหญ่ มันหมายถึงการเป็นเครื่องมือไปสู่สภาพแวดล้อมทั่วโลกของคุณที่จะช่วยคุณประหยัด 20 นาทีทุกวัน!
เคล็ดลับ
ข้ามไปที่ เอกสาร
@ai_str และเทมเพลตง่าย ๆ การเริ่มต้นใช้งาน ProftingTools.jl นั้นง่ายพอ ๆ กับการนำเข้าแพ็คเกจและใช้มาโคร @ai_str สำหรับคำถามของคุณ
หมายเหตุ: คุณจะต้องตั้งค่าคีย์ OpenAI API ของคุณเป็นตัวแปรสภาพแวดล้อมก่อนที่จะใช้ PREATCHINGTOOLS.JL (ดูส่วนคีย์การสร้าง OpenAI API ด้านล่าง)
หลังจากการแนะนำการเรียกเก็บเงินแบบเติมเงินคุณจะต้องซื้อเครดิตบางอย่างเพื่อเริ่มต้น (ขั้นต่ำ $ 5) สำหรับการเริ่มต้นอย่างรวดเร็วเพียงแค่ตั้งค่าผ่าน ENV["OPENAI_API_KEY"] = "your-api-key"
ติดตั้ง PromptingTools:
using Pkg
Pkg . add ( " PromptingTools " )และเราพร้อมที่จะไป!
using PromptingTools
ai " What is the capital of France? "
# [ Info: Tokens: 31 @ Cost: $0.0 in 1.5 seconds --> Be in control of your spending!
# AIMessage("The capital of France is Paris.") วัตถุที่ส่งคืนเป็นเครื่องห่อหุ้มด้วยข้อความที่สร้างขึ้นในฟิลด์ :content (เช่น ans.content ) สำหรับการประมวลผลดาวน์สตรีมเพิ่มเติม
เคล็ดลับ
หากคุณต้องการตอบกลับข้อความก่อนหน้าหรือเพียงแค่พูดคุยต่อให้ใช้ @ai!_str (สังเกตเห็นปัง ! ):
ai! " And what is the population of it? "คุณสามารถฉีดตัวแปรใด ๆ ได้อย่างง่ายดายด้วยการแก้ไขสตริง:
country = " Spain "
ai " What is the capital of $ (country)? "
# [ Info: Tokens: 32 @ Cost: $0.0001 in 0.5 seconds
# AIMessage("The capital of Spain is Madrid.") เคล็ดลับ
ใช้ After-String-Flags เพื่อเลือกแบบจำลองที่จะเรียกเช่น ai"What is the capital of France?"gpt4 (ใช้ gpt4t สำหรับรุ่น GPT-4 Turbo ใหม่) เหมาะสำหรับคำถามยาก ๆ เหล่านั้น!
สำหรับเทมเพลตพรอมต์ที่ซับซ้อนมากขึ้นคุณสามารถใช้เทมเพลตสไตล์แฮนด์บาร์และให้ตัวแปรเป็นอาร์กิวเมนต์คำหลัก:
msg = aigenerate ( " What is the capital of {{country}}? Is the population larger than {{population}}? " , country = " Spain " , population = " 1M " )
# [ Info: Tokens: 74 @ Cost: $0.0001 in 1.3 seconds
# AIMessage("The capital of Spain is Madrid. And yes, the population of Madrid is larger than 1 million. As of 2020, the estimated population of Madrid is around 3.3 million people.") เคล็ดลับ
ใช้ asyncmap เพื่อเรียกใช้งาน AI ที่ขับเคลื่อนด้วยหลายครั้งพร้อมกัน
เคล็ดลับ
หากคุณใช้โมเดลช้า (เช่น GPT -4) คุณสามารถใช้ @AI_STR เวอร์ชัน @ai_str -> @aai_str เพื่อหลีกเลี่ยงการปิดกั้นการเติมเช่น aai"Say hi but slowly!"gpt4 (ในทำนองเดียวกัน @ai!_str -> @aai!_str สำหรับการสนทนาหลายครั้ง
สำหรับตัวอย่างที่เป็นประโยชน์เพิ่มเติมดู examples/ โฟลเดอร์และส่วนตัวอย่างขั้นสูงด้านล่าง
@ai_str และเทมเพลตง่าย ๆai*airetry!aigenerate ( api_kwargs )วิศวกรรมที่รวดเร็วนั้นไม่ง่ายหรือง่าย ยิ่งไปกว่านั้นรุ่นที่แตกต่างกันและการปรับแต่งของพวกเขาอาจต้องใช้รูปแบบและกลเม็ดที่แตกต่างกันหรืออาจเป็นข้อมูลที่คุณทำงานด้วยต้องใช้โมเดลพิเศษที่จะใช้ PreftingTools.jl หมายถึงการรวมการแจ้งเตือนสำหรับแบ็กเอนด์ที่แตกต่างกันและทำให้งานทั่วไป (เช่นพรอมต์แบบเทมเพลต) ง่ายที่สุดเท่าที่จะทำได้
คุณสมบัติบางอย่าง:
aigenerate : ง่ายขึ้นเทมเพลตพรอมต์ด้วยแฮนด์บาร์ (เช่น {{variable}} ) และอาร์กิวเมนต์คำหลัก@ai_str สตริงแมโคร : บันทึกการกดแป้นด้วยแมโครสตริงสำหรับพรอมต์ง่ายๆai... เพื่อการค้นพบที่ดีขึ้นai* ฟังก์ชั่นที่น่าสังเกต: aigenerate , aiembed , aiclassify , aiextract , aiscan , aiimage , aitemplates
ฟังก์ชั่น ai* ทั้งหมดมีโครงสร้างพื้นฐานเหมือนกัน:
ai*(<optional schema>,<prompt or conversation>; <optional keyword arguments>) ,
แต่พวกเขาแตกต่างกันตามวัตถุประสงค์:
aigenerate เป็นฟังก์ชั่นวัตถุประสงค์ทั่วไปในการสร้างการตอบสนองข้อความใด ๆ ด้วย LLMS, IE, มันส่งคืน AIMessage ด้วยฟิลด์ :content ที่มีข้อความที่สร้างขึ้น (เช่น ans.content isa AbstractString )aiembed ได้รับการออกแบบมาเพื่อแยกการฝังตัวจากการตอบสนองของโมเดล AI เช่นมันส่งคืน DataMessage ด้วยฟิลด์ :content ที่มีการฝัง (เช่น ans.content isa AbstractArray )aiextract ได้รับการออกแบบมาเพื่อแยกข้อมูลที่มีโครงสร้างจากการตอบสนองของโมเดล AI และส่งคืนพวกเขาเป็น Julia Struct (เช่นถ้าเราให้ return_type=Food เราจะได้รับ ans.content isa Food ) คุณต้องกำหนดประเภทการส่งคืนก่อนจากนั้นระบุเป็นอาร์กิวเมนต์คำหลักaitools ได้รับการออกแบบมาสำหรับเวิร์กโฟลว์ตัวแทนที่มีการผสมผสานระหว่างการเรียกเครื่องมือและอินพุตของผู้ใช้ มันสามารถทำงานกับฟังก์ชั่นง่าย ๆ และดำเนินการaiclassify ได้รับการออกแบบมาเพื่อจำแนกข้อความอินพุตลงใน (หรือตอบสนองภายใน) ชุดของ choices ที่ไม่ต่อเนื่องที่ได้รับจากผู้ใช้ มันมีประโยชน์มากในฐานะผู้ตัดสิน LLM หรือเราเตอร์สำหรับระบบ RAG เนื่องจากใช้ "Logit Bias Trick" และสร้างโทเค็น 1 อย่างที่แน่นอน มันส่งคืน AIMessage พร้อมฟิลด์ :content แต่ :content สามารถเป็นเพียงหนึ่งใน choices ที่ให้ไว้ (เช่น ans.content in choices )aiscan มีไว้สำหรับการทำงานกับรูปภาพและโมเดลที่เปิดใช้งานการมองเห็น (เป็นอินพุต) แต่จะส่งคืน AIMessage ด้วยฟิลด์ :content ที่มีข้อความที่สร้างขึ้น (เช่น ans.content isa AbstractString ) คล้ายกับ aigenerateaiimage มีไว้สำหรับการสร้างภาพ (เช่น Openai Dall-e 3) มันส่งคืน DataMessage โดยที่ฟิลด์ :content อาจมี URL เพื่อดาวน์โหลดภาพจากหรือรูปภาพที่เข้ารหัส Base64 ขึ้นอยู่กับ KWARG api_kwargs.response_formataitemplates เป็นฟังก์ชั่นผู้ช่วยในการค้นหาเทมเพลตที่มีอยู่และดูรายละเอียดของพวกเขา (เช่น aitemplates("some keyword") หรือ aitemplates(:AssistantAsk) ) หากคุณใช้ model ที่รู้จักคุณไม่จำเป็นต้องให้ schema (อาร์กิวเมนต์แรก)
อาร์กิวเมนต์คำหลักเสริมใน ai* มักจะเป็น:
model::String - รุ่นใดที่คุณต้องการใช้verbose::Bool - ไม่ว่าคุณจะไปดูบันทึกข้อมูลเกี่ยวกับค่าใช้จ่าย AIreturn_all::Bool - ไม่ว่าคุณต้องการการสนทนาทั้งหมดหรือเพียงแค่คำตอบ AI (เช่นไม่ว่าคุณต้องการรวมอินพุต/พรอมต์ของคุณในเอาต์พุต)api_kwargs::NamedTuple - พารามิเตอร์เฉพาะสำหรับโมเดลเช่น temperature=0.0 ที่จะไม่สร้างสรรค์ (และมีเอาต์พุตที่คล้ายกันมากขึ้นในการรันแต่ละครั้ง)http_kwargs::NamedTuple - พารามิเตอร์สำหรับแพ็คเกจ http.jl เช่น readtimeout = 120 ถึงเวลาหมดใน 120 วินาทีหากไม่ได้รับการตอบกลับการทดลอง: AgentTools
นอกเหนือจากรายการด้านบนของฟังก์ชั่น ai* คุณยังสามารถใช้ ฟังก์ชั่น "ขี้เกียจ" ของฟังก์ชั่นเหล่านี้จากโมดูล AgentTools ทดลอง
using PromptingTools . Experimental . AgentTools ตัวอย่างเช่น AIGenerate() จะสร้างอินสแตนซ์ขี้เกียจของ aigenerate มันเป็นตัวอย่างของ AICall ที่มี aigenerate เป็นฟังก์ชั่น AI มันใช้อาร์กิวเมนต์และอาร์กิวเมนต์คำหลักเหมือนกันอย่างแน่นอนว่าเป็น aigenerate (ดู ?aigenerate สำหรับรายละเอียด)
"ขี้เกียจ" หมายถึงความจริงที่ว่ามันไม่ได้สร้างผลลัพธ์ใด ๆ เมื่อมีการสร้างอินสแตนซ์ (เฉพาะเมื่อ run! เรียกว่า)
หรือกล่าวว่าแตกต่างกันโครงสร้าง AICall และรสชาติทั้งหมด ( AIGenerate , ... ) ได้รับการออกแบบมาเพื่ออำนวยความสะดวกในรูปแบบการดำเนินการรอการตัดบัญชี (การประเมินขี้เกียจ) สำหรับฟังก์ชั่น AI ที่โต้ตอบกับรูปแบบการเรียนรู้ภาษา (LLM) มันเก็บข้อมูลที่จำเป็นสำหรับการโทร AI และดำเนินการฟังก์ชั่น AI พื้นฐานเฉพาะเมื่อให้มาพร้อมกับ UserMessage หรือเมื่อการ run! ใช้วิธีการ สิ่งนี้ช่วยให้เราสามารถจดจำอินพุตของผู้ใช้และทริกเกอร์การโทร LLM ซ้ำ ๆ หาก ?airetry! ซึ่งจะช่วยให้สามารถแก้ไขได้โดยอัตโนมัติ
หากคุณต้องการเวิร์กโฟลว์การตรึงอัตโนมัติที่ทรงพลังคุณสามารถใช้ airetry! ซึ่งใช้ประโยชน์จากการค้นหาต้นไม้ Monte-Carlo เพื่อเลือกวิถีการสนทนาที่ดีที่สุดตามความต้องการของคุณ
การทดลอง: ragtools
สุดท้ายเรามีชุดเครื่องมือในการสร้างแอปพลิเคชัน RAG (ดึงคำตอบสร้าง)
มันสามารถง่ายเหมือนสองสาย: build_index และ airag (เรียกคืน, ตอบ, สร้าง)
หากคุณใช้การพิมพ์สวยด้วย PromptingTools.pprint เราเน้นข้อความที่สร้างขึ้นเทียบกับข้อความที่น่าจะมาจากบริบทและเราให้คะแนนว่าคำตอบที่สร้างขึ้นอย่างมากได้รับการสนับสนุนโดยบริบท นอกจากนี้เราใส่คำอธิบายประกอบแต่ละอันที่สร้างขึ้นด้วยการอ้างอิงถึงเอกสารต้นฉบับที่น่าจะมาจาก (รวมถึงคะแนนความเชื่อมั่นระหว่าง 0 และ 1)
การค้นหาของ Google นั้นยอดเยี่ยม แต่เป็นสวิตช์บริบท คุณมักจะต้องเปิดหน้าสองสามหน้าและอ่านการสนทนาเพื่อค้นหาคำตอบที่คุณต้องการ เช่นเดียวกับเว็บไซต์ CHATGPT
ลองนึกภาพคุณอยู่ใน VSCODE แก้ไขไฟล์. .gitignore ของคุณ ฉันจะเพิกเฉยต่อไฟล์ในโฟลเดอร์ย่อยทั้งหมดได้อย่างไร
สิ่งที่คุณต้องทำคือพิมพ์: aai"What to write in .gitignore to ignore file XYZ in any folder or subfolder?"
ด้วย aai"" (ตรงข้ามกับ ai"" ) เราทำการโทรที่ไม่ปิดกั้นไปยัง LLM เพื่อไม่ป้องกันคุณจากการทำงานของคุณต่อไป เมื่อคำตอบพร้อมเราเข้าสู่ระบบจากพื้นหลัง:
[ข้อมูล: โทเค็น: 102 @ ค่าใช้จ่าย: $ 0.0002 ใน 2.7 วินาที┌ข้อมูล: Aimessage> หากต้องการเพิกเฉยต่อไฟล์ที่เรียกว่า "xyz" ในโฟลเดอร์หรือโฟลเดอร์ย่อยใด ๆ คุณสามารถเพิ่มบรรทัด
**ไปนี้ลงในไฟล์. gitignore:│ **/XYZ │ที่จะเพิกเฉย
คุณอาจประหยัดได้ 3-5 นาทีในงานนี้และอาจอีก 5-10 นาทีเนื่องจากสวิตช์/สิ่งที่ทำให้ไขว้เขวคุณหลีกเลี่ยง มันเป็นชัยชนะเล็กน้อย แต่มันก็เพิ่มขึ้นอย่างรวดเร็ว
คุณสามารถใช้ฟังก์ชัน aigenerate เพื่อแทนที่ตัวแปรแฮนด์บาร์ (เช่น {{name}} ) ผ่านอาร์กิวเมนต์คำหลัก
msg = aigenerate ( " Say hello to {{name}}! " , name = " World " ) พรอมต์ที่ซับซ้อนมากขึ้นคือการสนทนาอย่างมีประสิทธิภาพ (ชุดของข้อความ) ซึ่งคุณสามารถมีข้อความจากสามเอนทิตี: ระบบ, ผู้ใช้, aiassistant เราให้บริการประเภทที่สอดคล้องกันสำหรับแต่ละรายการ: SystemMessage , UserMessage , AIMessage
using PromptingTools : SystemMessage, UserMessage
conversation = [
SystemMessage ( " You're master Yoda from Star Wars trying to help the user become a Jedi. " ),
UserMessage ( " I have feelings for my {{object}}. What should I do? " )]
msg = aigenerate (conversation; object = " old iPhone " )Aimessage ("Ah, ภาวะที่กลืนไม่เข้าคายไม่ออก, คุณมีสิ่งที่แนบมาทางอารมณ์สามารถทำให้เส้นทางของคุณกลายเป็นเจไดได้ติดอยู่กับทรัพย์สินของวัสดุคุณต้องไม่ทำ iPhone เป็น แต่เครื่องมือไม่มีอะไรมากไปเลย
แสวงหาการปลด Padawan รุ่นเยาว์ ไตร่ตรองถึงความไม่แน่นอนของทุกสิ่ง ชื่นชมความทรงจำที่ให้คุณและมีส่วนร่วมอย่างสุดซึ้ง ในกรณีที่ไม่มีประสบการณ์ใหม่ที่จะเติบโตและกลายเป็นหนึ่งเดียวกับพลัง เมื่อนั้นเจไดที่แท้จริงคุณจะกลายเป็น ")
คุณยังสามารถใช้เพื่อสร้างการสนทนาเช่น
new_conversation = vcat (conversation ... ,msg, UserMessage ( " Thank you, master Yoda! Do you have {{object}} to know what it feels like? " ))
aigenerate (new_conversation; object = " old iPhone " )Aimessage ("อืมครอบครอง iPhone เก่าฉันไม่ได้ แต่ประสบการณ์กับสิ่งที่แนบมาฉันมีการปลดฉันเรียนรู้พลังที่แท้จริงและอิสรภาพมันนำมา ... ")
ด้วย LLMS คุณภาพ / ความทนทานของผลลัพธ์ของคุณขึ้นอยู่กับคุณภาพของพรอมต์ของคุณ แต่การเขียนพรอมต์นั้นยาก! นั่นเป็นเหตุผลที่เราเสนอระบบเทมเพลตเพื่อประหยัดเวลาและความพยายามของคุณ
หากต้องการใช้เทมเพลตเฉพาะ (เช่น `` เพื่อถามภาษาจูเลีย):
msg = aigenerate ( :JuliaExpertAsk ; ask = " How do I add packages? " ) ข้างต้นเทียบเท่ากับเวอร์ชัน verbose มากขึ้นซึ่งใช้การจัดส่งบน AITemplate อย่างชัดเจน:
msg = aigenerate ( AITemplate ( :JuliaExpertAsk ); ask = " How do I add packages? " ) ค้นหาเทมเพลตที่มีอยู่พร้อม aitemplates :
tmps = aitemplates ( " JuliaExpertAsk " )
# Will surface one specific template
# 1-element Vector{AITemplateMetadata}:
# PromptingTools.AITemplateMetadata
# name: Symbol JuliaExpertAsk
# description: String "For asking questions about Julia language. Placeholders: `ask`"
# version: String "1"
# wordcount: Int64 237
# variables: Array{Symbol}((1,))
# system_preview: String "You are a world-class Julia language programmer with the knowledge of the latest syntax. Your commun"
# user_preview: String "# Questionnn{{ask}}"
# source: String ""ข้างต้นช่วยให้คุณมีความคิดที่ดีเกี่ยวกับเทมเพลตเกี่ยวกับสิ่งที่มีตัวยึดตำแหน่งและค่าใช้จ่ายเท่าใดในการใช้งาน (= WordCount)
ค้นหาเทมเพลตที่เกี่ยวข้องกับจูเลียทั้งหมด:
tmps = aitemplates ( " Julia " )
# 2-element Vector{AITemplateMetadata}... -> more to come later! หากคุณอยู่ใน VSCODE คุณสามารถใช้ประโยชน์จากการแสดงผลแบบตารางที่ดีพร้อม vscodedisplay :
using DataFrames
tmps = aitemplates ( " Julia " ) |> DataFrame |> vscodedisplay ฉันมีแม่แบบที่เลือกฉันจะใช้มันได้อย่างไร? เพียงใช้ "ชื่อ" ใน aigenerate หรือ aiclassify อย่างที่คุณเห็นในตัวอย่างแรก!
คุณสามารถตรวจสอบเทมเพลตใด ๆ โดย "การแสดงผล" (นี่คือสิ่งที่ LLM จะเห็น):
julia > AITemplate ( :JudgeIsItTrue ) |> PromptingTools . renderดูตัวอย่างเพิ่มเติมในตัวอย่าง/ โฟลเดอร์
คุณสามารถใช้ประโยชน์จาก asyncmap เพื่อเรียกใช้งาน AI ที่ขับเคลื่อนด้วยหลายครั้งพร้อมกันปรับปรุงประสิทธิภาพสำหรับการดำเนินงานแบบแบทช์
prompts = [ aigenerate ( " Translate 'Hello, World!' to {{language}} " ; language) for language in [ " Spanish " , " French " , " Mandarin " ]]
responses = asyncmap (aigenerate, prompts)เคล็ดลับ
คุณสามารถ จำกัด จำนวนงานที่เกิดขึ้นพร้อมกันด้วยคำหลัก asyncmap(...; ntasks=10)
งานบางอย่างต้องการโมเดลที่ทรงพลังกว่า ฟังก์ชั่นการหันหน้าไปทางผู้ใช้ทั้งหมดมี model อาร์กิวเมนต์คำหลักที่สามารถใช้เพื่อระบุโมเดลที่จะใช้ ตัวอย่างเช่นคุณสามารถใช้ model = "gpt-4-1106-preview" เพื่อใช้รุ่น GPT-4 Turbo ล่าสุด อย่างไรก็ตามไม่มีใครอยากพิมพ์มัน!
เราเสนอชุดนามแฝงแบบจำลอง (เช่น "GPT3", "GPT4", "GPT4T" -> Turbo GPT -4 ด้านบน ฯลฯ ) ที่สามารถใช้แทนได้
แต่ละ ai... โทรมาก่อนค้นหาชื่อรุ่นที่ให้ไว้ในพจนานุกรม PromptingTools.MODEL_ALIASES ดังนั้นคุณสามารถขยายได้อย่างง่ายดายด้วยนามแฝงของคุณเอง!
const PT = PromptingTools
PT . MODEL_ALIASES[ " gpt4t " ] = " gpt-4-1106-preview " นามแฝงเหล่านี้ยังสามารถใช้เป็นธงในแมโคร @ai_str เช่น ai"What is the capital of France?"gpt4t (GPT-4 Turbo มีความรู้ตัดออกในเดือนเมษายน 2566 ดังนั้นจึงมีประโยชน์สำหรับคำถามร่วมสมัยมากขึ้น)
ใช้ฟังก์ชั่น aiembed เพื่อสร้าง embeddings ผ่านรุ่น OpenAI เริ่มต้นที่สามารถใช้สำหรับการค้นหาความหมายการจัดกลุ่มและเวิร์กโฟลว์ AI ที่ซับซ้อนมากขึ้น
text_to_embed = " The concept of artificial intelligence. "
msg = aiembed (text_to_embed)
embedding = msg . content # 1536-element Vector{Float64}หากคุณวางแผนที่จะคำนวณระยะห่างของโคไซน์ระหว่าง Embeddings คุณสามารถทำให้เป็นปกติก่อน:
using LinearAlgebra
msg = aiembed ([ " embed me " , " and me too " ], LinearAlgebra . normalize)
# calculate cosine distance between the two normalized embeddings as a simple dot product
msg . content ' * msg . content[:, 1 ] # [1.0, 0.787] คุณสามารถใช้ฟังก์ชัน aiclassify เพื่อจัดประเภทคำสั่งใด ๆ ที่ให้ไว้เป็นจริง/เท็จ/ไม่ทราบ สิ่งนี้มีประโยชน์สำหรับการตรวจสอบข้อเท็จจริงภาพหลอนหรือการตรวจสอบ NLI การกลั่นกรองการกรองการวิเคราะห์ความเชื่อมั่นวิศวกรรมคุณลักษณะและอื่น ๆ
aiclassify ( " Is two plus two four? " )
# trueระบบแจ้งเตือนและแบบจำลองคุณภาพสูงกว่าสามารถใช้สำหรับงานที่ซับซ้อนมากขึ้นรวมถึงการรู้ว่าเมื่อใดที่จะเลื่อนไปที่มนุษย์:
aiclassify ( :JudgeIsItTrue ; it = " Is two plus three a vegetable on Mars? " , model = " gpt4t " )
# unknown ในตัวอย่างข้างต้นเราใช้เทมเพลตพร้อมท์ :JudgeIsItTrue ซึ่งจะขยายไปยังพรอมต์ระบบต่อไปนี้โดยอัตโนมัติ (และพรอมต์ผู้ใช้แยกต่างหาก):
"คุณเป็นผู้พิพากษา AI ที่เป็นกลางประเมินว่าคำสั่งที่ระบุนั้นเป็น" จริง "หรือ" เท็จ "ตอบ" ไม่ทราบ "ถ้าคุณไม่สามารถตัดสินใจได้"
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเทมเพลตดูที่ส่วนการแจ้งเตือนแบบแม่แบบ
aiclassify สามารถใช้สำหรับการจำแนกประเภทเป็นชุดของหมวดหมู่ที่กำหนด (สูงสุด 20) ดังนั้นเราจึงสามารถใช้สำหรับการกำหนดเส้นทาง
นอกจากนี้หากคุณมีตัวเลือกเป็น tuples ( (label, description) ) โมเดลจะใช้คำอธิบายเพื่อตัดสินใจ แต่จะส่งคืนป้ายกำกับ
ตัวอย่าง:
choices = [( " A " , " any animal or creature " ), ( " P " , " for any plant or tree " ), ( " O " , " for everything else " )]
input = " spider "
aiclassify ( :InputClassifier ; choices, input) # -> returns "A" for any animal or creature
# Try also with:
input = " daphodil " # -> returns "P" for any plant or tree
input = " castle " # -> returns "O" for everything elseภายใต้ประทุนเราใช้เคล็ดลับ "logit bias" เพื่อบังคับให้ใช้โทเค็นเพียง 1 ตัวเท่านั้น - นั่นหมายความว่ามันราคาถูกและเร็วมาก!
คุณเบื่อที่จะแยกข้อมูลด้วย Regex หรือไม่? คุณสามารถใช้ LLMS เพื่อแยกข้อมูลที่มีโครงสร้างจากข้อความ!
สิ่งที่คุณต้องทำคือกำหนดโครงสร้างของข้อมูลที่คุณต้องการแยกและ LLM จะทำส่วนที่เหลือ
กำหนด return_type ด้วย struct ให้เอกสารหากจำเป็น (ปรับปรุงผลลัพธ์และช่วยในการจัดทำเอกสาร)
เริ่มต้นด้วยงานยาก - แยกสภาพอากาศปัจจุบันในสถานที่ที่กำหนด:
@enum TemperatureUnits celsius fahrenheit
""" Extract the current weather in a given location
# Arguments
- `location`: The city and state, e.g. "San Francisco, CA"
- `unit`: The unit of temperature to return, either `celsius` or `fahrenheit`
"""
struct CurrentWeather
location :: String
unit :: Union{Nothing,TemperatureUnits}
end
# Note that we provide the TYPE itself, not an instance of it!
msg = aiextract ( " What's the weather in Salt Lake City in C? " ; return_type = CurrentWeather)
msg . content
# CurrentWeather("Salt Lake City, UT", celsius)แต่คุณสามารถใช้งานได้แม้กระทั่งงานที่ซับซ้อนมากขึ้นเช่นการแยกเอนทิตีจำนวนมากจากข้อความ:
" Person's age, height, and weight. "
struct MyMeasurement
age :: Int
height :: Union{Int,Nothing}
weight :: Union{Nothing,Float64}
end
struct ManyMeasurements
measurements :: Vector{MyMeasurement}
end
msg = aiextract ( " James is 30, weighs 80kg. He's 180cm tall. Then Jack is 19 but really tall - over 190! " ; return_type = ManyMeasurements)
msg . content . measurements
# 2-element Vector{MyMeasurement}:
# MyMeasurement(30, 180, 80.0)
# MyMeasurement(19, 190, nothing) มีแม้แต่เสื้อคลุมที่จะช่วยให้คุณตรวจพบข้อผิดพลาดพร้อมคำอธิบายที่เป็นประโยชน์ว่าทำไมการแยกวิเคราะห์จึงล้มเหลว ดู ?PromptingTools.MaybeExtract สำหรับข้อมูลเพิ่มเติม
ด้วยฟังก์ชั่น aiscan คุณสามารถโต้ตอบกับรูปภาพราวกับว่าพวกเขาเป็นข้อความ
คุณสามารถอธิบายภาพที่ให้ไว้:
msg = aiscan ( " Describe the image " ; image_path = " julia.png " , model = " gpt4v " )
# [ Info: Tokens: 1141 @ Cost: $0.0117 in 2.2 seconds
# AIMessage("The image shows a logo consisting of the word "julia" written in lowercase") หรือคุณสามารถทำ OCR ของภาพหน้าจอ ลองถ่ายทอดรหัส SQL จากภาพหน้าจอ (ไม่มีการพิมพ์ใหม่อีกครั้ง!) เราใช้เทมเพลต :OCRTask :
# Screenshot of some SQL code
image_url = " https://www.sqlservercentral.com/wp-content/uploads/legacy/8755f69180b7ac7ee76a69ae68ec36872a116ad4/24622.png "
msg = aiscan ( :OCRTask ; image_url, model = " gpt4v " , task = " Transcribe the SQL code in the image. " , api_kwargs = (; max_tokens = 2500 ))
# [ Info: Tokens: 362 @ Cost: $0.0045 in 2.5 seconds
# AIMessage("```sql
# update Orders <continue>คุณสามารถเพิ่มการไฮไลต์ไวยากรณ์ของเอาต์พุตผ่าน Markdown
using Markdown
msg . content |> Markdown . parseairetry!นี่เป็นคุณสมบัติการทดลองดังนั้นคุณต้องนำเข้าอย่างชัดเจน:
using PromptingTools . Experimental . AgentTools โมดูลนี้เสนอฟังก์ชั่น "ขี้เกียจ" ให้กับฟังก์ชั่น ai... ดังนั้นคุณสามารถใช้พวกเขาในวิธีที่ควบคุมได้มากขึ้นเช่น aigenerate -> AIGenerate (สังเกตเห็น Camelcase) ซึ่งมีอาร์กิวเมนต์เดียวกันยกเว้นมันจะสร้างเฉพาะเมื่อ run! เรียกว่า
ตัวอย่างเช่น:
out = AIGenerate ( " Say hi! " ; model = " gpt4t " )
run! (out) มีประโยชน์อย่างไร? เราสามารถใช้ "อินพุต" เดียวกันสำหรับการโทรซ้ำเช่นเมื่อเราต้องการตรวจสอบหรือสร้างผลลัพธ์บางอย่าง เรามีฟังก์ airetry เพื่อช่วยเราในเรื่องนั้น
ลายเซ็นของ airetry! คือ airetry!(condition_function, aicall::AICall, feedback_function) มันประเมินเงื่อนไข condition_function บนวัตถุ aicall (เช่นเราประเมิน f_cond(aicall) -> Bool ) หากล้มเหลวเราจะเรียก feedback_function บนวัตถุ aicall เพื่อให้ข้อเสนอแนะสำหรับโมเดล AI (เช่น f_feedback(aicall) -> String ) และทำซ้ำกระบวนการจนกว่าจะผ่านหรือจนกว่าจะเกินค่า max_retries
เราสามารถจับความล้มเหลวของ API (ไม่จำเป็นต้องมีข้อเสนอแนะดังนั้นจึงไม่มีการจัดเตรียมไว้)
# API failure because of a non-existent model
# RetryConfig allows us to change the "retry" behaviour of any lazy call
out = AIGenerate ( " say hi! " ; config = RetryConfig (; catch_errors = true ),
model = " NOTEXIST " )
run! (out) # fails
# we ask to wait 2s between retries and retry 2 times (can be set in `config` in aicall as well)
airetry! (isvalid, out; retry_delay = 2 , max_retries = 2 )หรือเราสามารถตรวจสอบผลลัพธ์บางอย่าง (เช่นรูปแบบเนื้อหาของเนื้อหา ฯลฯ )
เราจะเล่นเกมเดาสี (ฉันกำลังคิดว่า "สีเหลือง"):
# Notice that we ask for two samples (`n_samples=2`) at each attempt (to improve our chances).
# Both guesses are scored at each time step, and the best one is chosen for the next step.
# And with OpenAI, we can set `api_kwargs = (;n=2)` to get both samples simultaneously (cheaper and faster)!
out = AIGenerate (
" Guess what color I'm thinking. It could be: blue, red, black, white, yellow. Answer with 1 word only " ;
verbose = false ,
config = RetryConfig (; n_samples = 2 ), api_kwargs = (; n = 2 ))
run! (out)
# # Check that the output is 1 word only, third argument is the feedback that will be provided if the condition fails
# # Notice: functions operate on `aicall` as the only argument. We can use utilities like `last_output` and `last_message` to access the last message and output in the conversation.
airetry! (x -> length ( split ( last_output (x), r" | \ . " )) == 1 , out,
" You must answer with 1 word only. " )
# Note: you could also use the do-syntax, eg,
airetry! (out, " You must answer with 1 word only. " ) do aicall
length ( split ( last_output (aicall), r" | \ . " )) == 1
end คุณสามารถวาง airetry! การโทรตามลำดับ พวกเขาจะลองสดใหม่จนกว่าพวกเขาจะหมดการโทร AI สูงสุด ( max_calls ) หรือการลองใหม่สูงสุด ( max_retries )
ดูเอกสารสำหรับตัวอย่างที่ซับซ้อนมากขึ้นและเคล็ดลับการใช้งาน ( ?airetry ) เราใช้ประโยชน์จาก Monte Carlo Tree Search (MCTS) เพื่อเพิ่มประสิทธิภาพลำดับของการลองใหม่ดังนั้นจึงเป็นเครื่องมือที่ทรงพลังมากสำหรับการสร้างเวิร์กโฟลว์ AI ที่แข็งแกร่ง (แรงบันดาลใจจากกระดาษค้นหาต้นไม้ตัวแทนภาษาและกระดาษยืนยัน DSPY)
Ollama.ai เป็นเครื่องมือที่ง่ายอย่างน่าอัศจรรย์ที่ช่วยให้คุณใช้งานภาษาขนาดใหญ่หลายรุ่น (LLM) บนคอมพิวเตอร์ของคุณ มันเหมาะสมอย่างยิ่งเมื่อคุณทำงานกับข้อมูลที่ละเอียดอ่อนบางอย่างที่ไม่ควรส่งไปทุกที่
สมมติว่าคุณได้ติดตั้ง Ollama ดาวน์โหลดโมเดลและมันทำงานในพื้นหลัง
เราสามารถใช้กับฟังก์ชั่น aigenerate :
const PT = PromptingTools
schema = PT . OllamaSchema () # notice the different schema!
msg = aigenerate (schema, " Say hi! " ; model = " openhermes2.5-mistral " )
# [ Info: Tokens: 69 in 0.9 seconds
# AIMessage("Hello! How can I assist you today?") สำหรับโมเดลทั่วไปที่ได้รับการลงทะเบียน (ดู ?PT.MODEL_REGISTRY ) คุณไม่จำเป็นต้องให้สคีมาอย่างชัดเจน:
msg = aigenerate ( " Say hi! " ; model = " openhermes2.5-mistral " ) และเรายังสามารถใช้ฟังก์ชั่น aiembed :
msg = aiembed (schema, " Embed me " , copy; model = " openhermes2.5-mistral " )
msg . content # 4096-element JSON3.Array{Float64...
msg = aiembed (schema, [ " Embed me " , " Embed me " ]; model = " openhermes2.5-mistral " )
msg . content # 4096×2 Matrix{Float64}: ตอนนี้คุณสามารถใช้ aiscan เพื่อให้ภาพแก่โมเดล Ollama! ดูเอกสารสำหรับข้อมูลเพิ่มเติม
หากคุณได้รับข้อผิดพลาดให้ตรวจสอบว่า Ollama กำลังทำงานอยู่ - ดูคู่มือการตั้งค่าสำหรับส่วน Ollama ด้านล่าง
โมเดล Mistral ได้ครอบครองพื้นที่โอเพ่นซอร์สมานานแล้ว ตอนนี้พวกเขาพร้อมใช้งานผ่าน API ของพวกเขาเพื่อให้คุณสามารถใช้กับ preftingtools.jl!
msg = aigenerate ( " Say hi! " ; model = " mistral-tiny " ) ทุกอย่างใช้งานได้เพราะเราได้ลงทะเบียนโมเดลใน PromptingTools.MODEL_REGISTRY ! ขณะนี้มี 4 รุ่น: mistral-tiny , mistral-small , mistral-medium , mistral-embed
ภายใต้ฝากระโปรงเราใช้สคีมา MistralOpenAISchema ที่ใช้ประโยชน์จากฐานรหัสเฉพาะของ OpenAI ส่วนใหญ่ดังนั้นคุณจึงสามารถให้ข้อโต้แย้งแรกได้อย่างชัดเจน:
const PT = PromptingTools
msg = aigenerate (PT . MistralOpenAISchema (), " Say Hi! " ; model = " mistral-tiny " , api_key = ENV [ " MISTRAL_API_KEY " ]) อย่างที่คุณเห็นเราสามารถโหลดคีย์ API ของคุณได้จาก Env หรือผ่านทางกลไกการตั้งค่า JL (ดู ?PREFERENCES สำหรับข้อมูลเพิ่มเติม)
แต่ Mistralai ไม่ใช่คนเดียว! มีผู้ให้บริการที่น่าตื่นเต้นอื่น ๆ อีกมากมายเช่น Perplexity.ai, Fireworks.ai ตราบใดที่พวกเขาเข้ากันได้กับ OpenAI API (เช่นการส่ง messages พร้อมคีย์ role และ content ) คุณสามารถใช้กับ preftingTools.jl ได้โดยใช้ schema = CustomOpenAISchema() :
# Set your API key and the necessary base URL for the API
api_key = " ... "
prompt = " Say hi! "
msg = aigenerate (PT . CustomOpenAISchema (), prompt; model = " my_model " , api_key, api_kwargs = (; url = " http://localhost:8081 " ))อย่างที่คุณเห็นมันยังใช้งานได้กับรุ่นท้องถิ่นที่คุณอาจใช้งานบนคอมพิวเตอร์ของคุณ!
หมายเหตุ: ในขณะนี้เราสนับสนุนฟังก์ชั่น aigenerate และ aiembed สำหรับ Mistralai และ API ที่เข้ากันได้กับ OpenAI อื่น ๆ เราวางแผนที่จะขยายการสนับสนุนในอนาคต
ตรวจสอบให้แน่ใจว่าตัวแปรสภาพแวดล้อม ANTHROPIC_API_KEY ถูกตั้งค่าเป็นคีย์ API ของคุณ
# cladeuh is alias for Claude 3 Haiku
ai " Say hi! " claudeh นามแฝงแบบจำลองที่ตั้งไว้ล่วงหน้าคือ claudeo , claudes และ claudeh สำหรับ Claude 3 Opus, Sonnet และ Haiku ตามลำดับ
สคีมาที่สอดคล้องกันคือ AnthropicSchema
มีเทมเพลตที่พร้อมใช้งานหลายอย่างที่มี XML ในชื่อแนะนำว่าพวกเขาใช้การจัดรูปแบบ XML ที่เป็นมิตรกับมานุษยวิทยาสำหรับการแยกส่วน ค้นหาพวกเขาด้วย aitemplates("XML")
# cladeo is alias for Claude 3 Opus
msg = aigenerate (
:JuliaExpertAskXML , ask = " How to write a function to convert Date to Millisecond? " ,
model = " cladeo " )tbu ...
ค้นหาตัวอย่างเพิ่มเติมในตัวอย่าง/ โฟลเดอร์
แพ็คเกจถูกสร้างขึ้นประมาณสามองค์ประกอบสำคัญ:
aigenerate , aiembed , aiclassify ) ทำไมการออกแบบนี้? API ที่แตกต่างกันต้องการรูปแบบที่แตกต่างกัน ตัวอย่างเช่น API ของ OpenAI ต้องการพจนานุกรมที่มีฟิลด์ role และ content ในขณะที่ API ของ Ollama สำหรับรุ่น Zephyr-7B ต้องใช้ schema chatml ที่มีสตริงใหญ่และตัวคั่นหนึ่งเช่น <|im_start|>usernABC...<|im_end|>user สำหรับการแยกส่วนในพรอมต์ของคุณ OpenAI ชอบส่วนหัว Markdown ( ##Response ) เทียบกับมานุษยวิทยาทำงานได้ดีขึ้นด้วยแท็ก HTML ( <text>{{TEXT}}</text> )
แพ็คเกจนี้ได้รับแรงบันดาลใจอย่างมากจากผู้สอนและใช้ฟังก์ชั่นการเรียก API อย่างชาญฉลาด
Schemas พร้อม
ประเภทคีย์ที่ใช้สำหรับการปรับแต่งตรรกะของการเตรียมอินพุตสำหรับ LLMS และเรียกพวกเขา (ผ่านการจัดส่งหลายรายการ)
ทั้งหมดเป็นชนิดย่อยของ AbstractPromptSchema และแต่ละฟังก์ชั่นงานมีลายเซ็นทั่วไปที่มีสคีมาในตำแหน่งแรก foo(schema::AbstractPromptSchema,...)
การจัดส่งถูกกำหนดทั้งสำหรับ "การแสดงผล" ของพรอมต์ ( render ) และสำหรับการเรียก APIs ( aigenerate )
เป็นการดีที่แต่ละอินเตอร์เฟสใหม่จะถูกกำหนดในไฟล์ llm_<interface>.jl แยกต่างหาก (เช่น llm_openai.jl )
ข้อความ
พรอมต์เป็นบทสนทนาที่จะเสร็จสิ้นได้อย่างมีประสิทธิภาพ
การสนทนามีแนวโน้มที่จะมีนักแสดงหลักสามคน: ระบบ (สำหรับคำแนะนำโดยรวม) ผู้ใช้ (สำหรับอินพุต/ข้อมูล) และ AI Assistant (สำหรับเอาต์พุต) เราให้บริการ SystemMessage , UserMessage และ AIMessage สำหรับแต่ละประเภท
เมื่อได้รับสคีมาและข้อความอย่างน้อยหนึ่งข้อความคุณสามารถ render วัตถุที่ได้ผลลัพธ์ที่จะถูกป้อนเข้าสู่โมเดล API เช่น Openai
using PromptingTools : render, SystemMessage, UserMessage
PT = PromptingTools
schema = PT . OpenAISchema () # also accessible as the default schema `PT.PROMPT_SCHEMA`
conversation = conversation = [
SystemMessage ( " Act as a helpful AI assistant. Provide only the information that is requested. " ),
UserMessage ( " What is the capital of France? " )]
messages = render (schema, conversation)
# 2-element Vector{Dict{String, String}}:
# Dict("role" => "system", "content" => "Act as a helpful AI assistant. Provide only the information that is requested.")
# Dict("role" => "user", "content" => "What is the capital of France?")วัตถุนี้สามารถให้โดยตรงกับ OpenAI API
ฟังก์ชั่นที่มุ่งเน้นงาน
ความทะเยอทะยานคือการจัดเตรียมฟังก์ชั่นที่ง่ายต่อการจดจำสำหรับงานทั่วไปดังนั้นทั้งหมดเริ่มต้นด้วย ai... ฟังก์ชั่นทั้งหมดควรส่งคืนเสื้อคลุมเบาพร้อมการตอบสนองที่เกิดขึ้น ในขณะนี้มันสามารถเป็นเพียง AIMessage (สำหรับการตอบกลับแบบข้อความใด ๆ ) หรือ DataMessage ทั่วไป (สำหรับข้อมูลที่มีโครงสร้างเช่น Embeddings)
ด้วยความแตกต่างใน API แบบจำลองและพารามิเตอร์ของพวกเขา (เช่น OpenAI API กับ Ollama) ฟังก์ชั่นงานจะถูกส่งไปยัง schema::AbstractPromptSchema เป็นอาร์กิวเมนต์แรกของพวกเขา
ดู src/llm_openai.jl สำหรับการใช้งานตัวอย่าง แต่ละอินเทอร์เฟซใหม่จะถูกกำหนดในไฟล์ llm_<interface>.jl แยกต่างหาก
โมเดลของ Openai อยู่ในระดับแนวหน้าของการวิจัย AI และให้ความสามารถที่แข็งแกร่งและล้ำสมัยสำหรับงานหลายอย่าง
จะมีสถานการณ์ที่ไม่หรือไม่สามารถใช้งานได้ (เช่นความเป็นส่วนตัวค่าใช้จ่าย ฯลฯ ) ในกรณีนี้คุณสามารถใช้โมเดลท้องถิ่น (เช่น Ollama) หรือ API อื่น ๆ (เช่นมานุษยวิทยา)
หมายเหตุ: ในการเริ่มต้นด้วย ollama.ai ดูที่คู่มือการตั้งค่าสำหรับส่วน Ollama ด้านล่าง
มีทางเลือกมากมาย:
ในช่วงเวลาของการเขียน OpenAI ไม่ได้ใช้ API Call เพื่อฝึกอบรมแบบจำลองของพวกเขา
API
OpenAI ไม่ได้ใช้ข้อมูลที่ส่งและสร้างโดย API ของเราเพื่อฝึกอบรมโมเดล OpenAI หรือปรับปรุงการเสนอบริการของ OpenAI เพื่อสนับสนุนการปรับปรุงแบบจำลองของเราอย่างต่อเนื่องคุณสามารถกรอกแบบฟอร์มนี้เพื่อเลือกใช้ข้อมูลของคุณกับเรา - วิธีการใช้ข้อมูลของคุณเพื่อปรับปรุงโมเดลของเรา
คุณสามารถตรวจสอบข้อมูลล่าสุดเกี่ยวกับวิธีการใช้หน้าข้อมูลของ OpenAI ได้เสมอ
ทรัพยากร:
คุณสามารถรับคีย์ API ของคุณจาก OpenAI ได้โดยสมัครใช้งานบัญชีและเข้าถึงส่วน API ของเว็บไซต์ OpenAI
ทรัพยากร:
เคล็ดลับ
กำหนดขีด จำกัด การใช้จ่ายเสมอ!
OpenAI ช่วยให้คุณสามารถตั้งค่าการใช้จ่ายได้โดยตรงบนแผงควบคุมบัญชีของคุณเพื่อป้องกันค่าใช้จ่ายที่ไม่คาดคิด
การเริ่มต้นที่ดีอาจเป็นขีด จำกัด ที่นุ่มนวลของ C $ 5 และขีด จำกัด อย่างหนักของ C $ 10 - คุณสามารถเพิ่มได้ในภายหลังในเดือน
ทรัพยากร:
หากคุณใช้โมเดลท้องถิ่น (เช่นกับ Ollama) ฟรี หากคุณใช้ APIs เชิงพาณิชย์ (เช่น OpenAI) คุณอาจจ่ายต่อ "โทเค็น" (หน่วยย่อยคำ)
ตัวอย่างเช่นคำของ่าย ๆ ที่มีคำถามง่ายๆและการตอบกลับ 1 ประโยคเป็นการตอบแทน (” เป็นคำสั่ง xyz ความคิดเห็นเชิงบวก”) จะทำให้คุณเสียค่าใช้จ่าย ~ $ 0.0001 (เช่นหนึ่งร้อยของร้อยละ)
คุ้มค่าหรือไม่?
Genai เป็นวิธีซื้อเวลา! คุณสามารถจ่ายเซ็นต์เพื่อประหยัดสิบนาทีทุกวัน
ดำเนินการต่อตัวอย่างข้างต้นลองจินตนาการว่าคุณมีตารางที่มี 200 ความคิดเห็น ตอนนี้คุณสามารถแยกวิเคราะห์แต่ละอันด้วย LLM สำหรับคุณสมบัติ/เช็คที่คุณต้องการ สมมติว่าราคาต่อการโทรคือ $ 0.0001 คุณต้องจ่าย 2 เซ็นต์สำหรับงานและประหยัดเวลา 30-60 นาที!
ทรัพยากร:
นี่คือคำแนะนำสำหรับคีย์ API ของ OpenAI แต่ใช้งานได้กับคีย์ API อื่น ๆ ที่คุณอาจต้องการ (เช่น MISTRAL_API_KEY สำหรับ Mistralai API)
หากต้องการใช้ OpenAI API ด้วย preftingtools.jl ตั้งค่าปุ่ม API ของคุณเป็นตัวแปรสภาพแวดล้อม:
ENV [ " OPENAI_API_KEY " ] = " your-api-key "ในฐานะที่เป็นครั้งเดียวคุณสามารถ:
export OPENAI_API_KEY = <your key>setup.jl ของคุณ (ตรวจสอบให้แน่ใจว่าจะไม่ส่งมอบให้กับ GitHub!) ตรวจสอบให้แน่ใจว่าเริ่มจูเลียจากหน้าต่างเทอร์มินัลเดียวกันที่คุณตั้งค่าตัวแปร ตรวจสอบได้ง่ายในจูเลียเรียกใช้ ENV["OPENAI_API_KEY"] และคุณควรเห็นกุญแจของคุณ!
วิธีที่ดีกว่า:
~/.zshrc ) มันจะได้รับการโหลดโดยอัตโนมัติทุกครั้งที่คุณเปิดตัวเทอร์มินัล นอกจากนี้เรายังรองรับ preferences.jl ดังนั้นคุณสามารถเรียกใช้: PromptingTools.set_preferences!("OPENAI_API_KEY"=>"your-api-key") และมันจะคงอยู่ตลอดช่วงการประชุม หากต้องการดูการตั้งค่าปัจจุบันให้เรียกใช้ PromptingTools.get_preferences("OPENAI_API_KEY")
ระวังอย่าให้ความสำคัญ LocalPreferences.toml toml ถึง gitHub เพราะมันจะแสดงคีย์ API ของคุณต่อโลก!
ทรัพยากร:
aigenerate ( api_kwargs )ดูการอ้างอิง OpenAI API สำหรับข้อมูลเพิ่มเติม
เพื่อให้เข้าถึงได้ง่ายจากทุกที่ให้เพิ่มการแจ้งเตือนใน startup.jl ของคุณ (สามารถพบได้ใน ~/.julia/config/startup.jl )
เพิ่มตัวอย่างต่อไปนี้:
using PromptingTools
const PT = PromptingTools # to access unexported functions and types
ตอนนี้คุณสามารถใช้ ai"Help me do X to achieve Y" จากเซสชันใด ๆ !
ethos ของ preftingtools.jl คือการอนุญาตให้คุณใช้โมเดลใด ๆ ที่คุณต้องการซึ่งรวมถึง LLM โอเพนซอร์ส การตั้งค่าที่ได้รับความนิยมและง่ายที่สุดคือ Ollama.ai - ดูข้อมูลเพิ่มเติมด้านล่าง
Ollama ใช้บริการพื้นหลังโฮสติ้ง LLM ที่คุณสามารถเข้าถึงได้ผ่าน API แบบง่าย มันมีประโยชน์อย่างยิ่งเมื่อคุณทำงานกับข้อมูลที่ละเอียดอ่อนบางอย่างที่ไม่ควรส่งไปทุกที่
การติดตั้งนั้นง่ายมากเพียงดาวน์โหลดเวอร์ชันล่าสุดที่นี่
เมื่อคุณติดตั้งแล้วเพียงแค่เปิดแอพแล้วคุณก็พร้อมแล้ว!
หากต้องการตรวจสอบว่ามันกำลังทำงานให้ไปที่เบราว์เซอร์ของคุณและเปิด 127.0.0.1:11434 คุณควรเห็นข้อความ "Ollama กำลังทำงานอยู่" หรือคุณสามารถเรียก ollama serve ในเทอร์มินัลของคุณและคุณจะได้รับข้อความว่ามันกำลังทำงานอยู่แล้ว
มีหลายรุ่นที่มีอยู่ในห้องสมุด Ollama รวมถึง Llama2, Codellama, SQLCoder หรือ openhermes2.5-mistral ที่ฉันโปรดปราน
ดาวน์โหลดรุ่นใหม่ด้วย ollama pull <model_name> (เช่น ollama pull openhermes2.5-mistral )
แสดงโมเดลที่มีอยู่ในปัจจุบันพร้อม ollama list
ดู ollama.ai สำหรับข้อมูลเพิ่มเติม
การปรับแต่งเป็นเทคนิคที่ทรงพลังในการปรับโมเดลให้เข้ากับเคสการใช้งานเฉพาะของคุณ (ส่วนใหญ่เป็นรูปแบบ/ไวยากรณ์/งาน) มันต้องใช้ชุดข้อมูลตัวอย่างซึ่งตอนนี้คุณสามารถสร้างได้อย่างง่ายดายด้วย preftingtools.jl!
คุณสามารถบันทึกการสนทนาใด ๆ (เวกเตอร์ของข้อความ) ไปยังไฟล์ที่มี PT.save_conversation("filename.json", conversation)
เมื่อเวลา finetuning มาถึงให้สร้างชุดการสนทนาที่จัดรูปแบบของ ShareGpt (รูปแบบ finetuning ทั่วไป) ในไฟล์ .jsonl เดียว ใช้ PT.save_conversations("dataset.jsonl", [conversation1, conversation2, ...]) (สังเกตว่าพหูพจน์ "การสนทนา" ในชื่อฟังก์ชั่น)
สำหรับตัวอย่างของกระบวนการ finetuning แบบ end-to-end ลองดูการทดลอง finetuning ของ Juliallmleaderboard น้องสาวของเรา มันแสดงให้เห็นถึงกระบวนการของ finetuning ครึ่งดอลลาร์ด้วย jarvislabs.ai และ axolotl
นี่คือรายการของคุณสมบัติที่ฉันต้องการดูในอนาคต (ไม่ตามลำดับเฉพาะ):
สำหรับข้อมูลเพิ่มเติมการมีส่วนร่วมหรือคำถามกรุณาเยี่ยมชมที่เก็บข้อมูล reptingtools.jl github
โปรดทราบว่าในขณะที่การแจ้งเตือน toolss.jl มีจุดมุ่งหมายเพื่อให้ประสบการณ์ที่ราบรื่น แต่ต้องอาศัย API ภายนอกซึ่งอาจเปลี่ยนแปลง คอยติดตามที่เก็บข้อมูลเพื่ออัปเดตและคุณสมบัติใหม่
ขอบคุณสำหรับการเลือก PreftingTools.jl เพื่อเพิ่มขีดความสามารถของแอปพลิเคชันของคุณด้วย AI!
