Ang prompt engineering, tulad ng pangalan, ay tungkol sa pagkuha ng isang maliit na mas mataas kaysa sa mga pangunahing prompts sa pamamagitan ng paglikha ng mga espesyalista na input na (mga) makakatulong sa mga modelo ng AI upang lumikha ng halos-perfect outputs.
Hindi mo kailangang gamitin ang isang programming language o isang IDE para sa ito, dahil ang karamihan ng mga tao ay nagpapakita sa iyo na maaari lamang gamitin ang front end ng ChatGPT.
Sa artikulong ito, makipag-usap namin kung paano gawin ito sa Python, gamit ang Phi-3-mini-4k-instruct model ng Microsoft. Kami ay gumagamit ng Huggingface inference API para sa ito, kaya hindi mo na kailangang i-download ang isang modelo ng 7GB locally.
Pag-iisip mo ito bilangmanipulatingisang modelo mula sa loob, hindi mula sa mga pangunahing mensahe ng chat. Munting sa kanya, upang maging abstrak.
Ipinanganak ang Environment
- sa loob
- I-create a Huggingface account at i-download ang isang API key (your profile > access tokens) na may "writing" access. Ito ay hindi isang sponsored post. Kung ikaw ay gumagana sa LLMs, kailangan mo upang lumikha ng isang Huggingface account sa isang punto; ito ay sigurado. sa loob
- I-install ang Python 3.10+ sa iyong sistema at i-set up ang isang IDE. O maaari mong gamitin ang notebook na ito sa Google Colab. sa loob
- I-install ang 'huggingface_hub' library gamit ang 'pip install huggingface_hub' o isang iba pang komento, depende sa iyong OS. sa loob
Malalaman ang mga Basics
Kapag bumalik sa code, tingnan namin ang isang maliit na tungkol sa prompt engineering.
Tulad nila Tirso at Lyn ang mga anak nila, very friendly at magalang.
Ang iba't-ibang mga LLM ay tumugon sa iba't-ibang mga teknolohiya ng prompt engineering sa iba't-ibang paraan. Ito ay nangangahulugan na hindi mo maaaring gamitin ang parehong template ng prompt engineering para sa lahat at lahat ng LLM. At ito taas ay nangangahulugan na kailangan mong basahin ang dokumento ng LLM upang malaman kung ano ang teknikal ay pinakamahusay na upang gamitin.
Narito ang ilang popular na mga ito:
- sa loob
- Zero-shot learning: Ipinapakita ang modelo upang gawin ang isang trabaho nang walang anumang mga halimbawa I-classify ang mga sumusunod na teksto bilang positibo o negatibong: "I really this movie!" sa loob
Ito ay gumagana sa mga labi-trained na mga modelo tulad ng GPT-4, Claude 3 Opus, at Gemini Ultra.
Sa aking karanasan, ang Mistral-7B, kahit na isang maliit na LLM, ay may impressive mga resulta sa zero-shot learning.
- sa loob
- Ang ilang mga halimbawa ng pag-aaral: Nagbibigay ng ilang mga halimbawa bago nangangailangan ng modelo upang bumuo ng isang trabaho. Text: "Ang pagkain ay magandang." Sentiment: Negative Text: "I've had a wonderful time." Sentiment: Positive sa loob
Ideal para sa mga gawain na maaaring maging mas mabuti para sa modelo o kung saan nais mong i-demonstrate ang isang espesyal na format.
- sa loob
- Ang maliliit na negosyo sa mga sumusunod na sektor ay kinakailangan: pagproseso ng produktong agrikultural ( sa loob
- Role-based prompting: Ipinapakita ng modelo na magtakbo ng isang tiyak na papel o persona. Ikaw ay isang eksperto sa programming ng Python. Mangyaring i-review ang code na ito at i-suggest ang mga pagbuo: Ito ay dapat ang pinaka-popular na teknikal ng prompting sa pagitan ng mga hindi programming. ChatGPT, Claude, at ang karamihan sa iba pang mga chatbots ay nagkakahalaga sa pagbibigay ng role-based outputs. sa loob
- System prompt: I-set up context & instructions bago ang tunay na user query Ito ay ang aking favorite kapag ito ay tungkol sa "messing" na may isang LLM. At maaari mong gawin ito lamang sa backend sa karamihan ng mga kaso, na kung saan ay simpleng magandang. Ang system prompt ay gumagana bilang ang "personality at instruction" set para sa isang anumang modelo. Ito ay gumagana para sa pagdiriwang ng mga kurso o limitasyon. Ano ang karamihan, maaari mong gawin kung ano ang hindi mo maaaring gawin sa mga pangunahing input kapag ikaw ay lumikha ng isang sistema na mensahe. Kung kami ay gumagawa ng isang maliit na LLM, halimbawa, kung ikaw ay nag-iisip sa kanya ng isang malubhang bagay sa pamamagitan ng isang pangunahing input na mensahe, ito ay pag-iisip na tumugon sa sa loob
Lahat ng mga teknolohiya sa itaas ay maaaring gawin sa ChatGPT o iba pang chatbot ng UI, batay sa proseso ng system prompt at chain-of-thoughts (teknikal, maaari naming gawin ito din, ngunit hindi talagang epektibo).
Dahil dito, makipag-usap natin sa dalawang ito sa susunod na seksyon.
Ang mga Chain of Thoughts
Sa karamihan ng LLMs, hindi mo makikita ang mga keto ng mga ideya sa ilalim ng kanilang pag-argument, ngunit maaari mong lumikha ito sa pamamagitan ng prompt engineering sa Python.
Para sa pag-script ng function, i-import ang library at i-define ang client:
from huggingface_hub import InferenceClient
# Replace with your Hugging Face token
client = InferenceClient(token="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")
Pagkatapos ay kailangan nating malaman kung paano natin i-implementate ang chain ng pag-iisip.
Ang mga LLM sa kasalukuyan ay hindi may isang direkta na function upang gumawa ng kanilang internal chain ng pag-iisip na nakikita - isip ng DeepSeek R1, kung saan ito ay binubuo.
Ibig sabihin, kung kailangan nating gawin ito, kailangan nating gamitin ang isang system prompt. Gayunpaman, huwag i-confuse ito sa mga teknolohiya na inilarawan namin sa nakaraang. Ang system prompt, sa kaso na ito, ay gumagana mas tulad ng isang paraan upang i-implementate ang CoT, hindi isang prompting teknolohiya.
Ito ay kung paano natin sabihin ito:
Format your response as follows
1. THINKING: First, show all mental steps, considerations, and explorations. Include alternative hypotheses you consider and reject. Think about edge cases.
2. VERIFICATION: Double-check your logic and facts, identifying any potential errors.
3. ANSWER: Only after showing all thinking, provide your final answer.
Narito ang kung paano maaari naming i-integrate ito sa function upang lumikha ng isang output:
def generate_chain_of_thought_response(user_input):
# System message defines personality and expectations
system_prompt = (
"Format your response as follows:"
"1. THINKING: First, show all mental steps, considerations, and explorations. Include alternative hypotheses you consider and reject. Think about edge cases."
"2. VERIFICATION: Double-check your logic and facts, identifying any potential errors."
"3. ANSWER: Only after showing all thinking, provide your final answer."
)
# Alternating user input to encourage visible reasoning
formatted_user_input = f"{user_input}\nLet's think through this step by step."
# Phi-style formatting
prompt = (
f"<|im_start|>system\n{system_prompt}<|im_end|>\n"
f"<|im_start|>user\n{formatted_user_input}<|im_end|>\n"
f"<|im_start|>assistant\n"
)
# Call the model
response = client.text_generation(
prompt,
model="microsoft/Phi-3-mini-4k-instruct",
max_new_tokens=500,
temperature=0.7,
top_p=0.95,
repetition_penalty=1.1,
stop_sequences=["<|im_end|>"]
)
# Cleanup
answer = response.strip().split("<|im_end|>")[0].strip()
return answer
Sa code na ito, natuklasan namin ang mga limitasyon ng LLM. Mangyaring i-explain ang mga ito isa sa isa.
- sa loob
- max_new_tokens=500: Ang parameter na ito ay nagpapakita ng maximum na bilang ng mga token na magbigay ng modelo bilang reaksyon sa input prompt. sa loob
- temperatura=0.7: Ang parameter na ito ay nagtatrabaho sa randomness ng output ng modelo. Kung ito ay mas mababa, tulad ng 0.2, ang mga reaksyon ng modelo ay mas matatagpuan at matatagpuan; ito ay maaaring magiging sanhi ng pag-uugali at isang kalikasan ng kreatividad. Kapag ito ay mas mataas, sa katunayan, ang modelo ay gumaganap ng mas diversified at creative outputs, ngunit maaaring gumawa ng mga irrelevant na impormasyon (kay, sa ilang mga oras). 0.7, sa gayon, ang mga hits sa mid-range at ang mga tampok ay matatagpuan para sa model na ito. sa loob
- sa loob
- top_p=0.95: ang parameter top_p ay gumagamit ng kernel sampling upang piliin ang pinakamalaking set ng tokens na ang kumulatong probabilidad ay hindi bababa sa 95%. Hindi tulad ng top_k, na limitasyon ng mga pagpipilian sa isang fixed number, top_p dynamically ayusin ang token pool batay sa probability. sa loob
- repetition_penalty=1.1: Ito ay naglalaman ng isang "penalty" sa mga token na nag-iisip na nakalipas, na nagpapakita ng mga ito ng mas mababang pagkakataon sa pag-iisip sa text na nilikha ng higit pa at higit pa. Ang isang halaga na mas mataas kaysa sa 1.0 ay mas mababang ang pagkakataon ng pag-iisip ng isang malaking. sa loob
Tingnan din kung paano kami format ang prompt dito:
f"<|im_start|>system\n{system_prompt}<|im_end|>\n"
f"<|im_start|>user\n{formatted_user_input}<|im_end|>\n"
f"<|im_start|>assistant\n"
Ang format na ito, na binubuo ng '<̧im_startĝi>' at '<̧im_endĝi>', ay depende sa uri ng LLM. Ang pinakamahusay na paraan upang matugunan ito ay upang matugunan ang ChatGPT upang basahin ang dokumento ng modelo.
Sa katapusan, para sa interactive chat experience, i-implement ang loop na ito:
print("Chain-of-Thought Phi (type 'exit' to quit)")
while True:
user_input = input("\nYou: ")
if user_input.lower().strip() in {"exit", "quit"}:
break
output = generate_chain_of_thought_response(user_input)
print("\nAssistant:\n", output)
Panatilihin ang script, at mag-asawa ng isang tanong tulad ng "Ano ang 7 x 9 + 100?" Maaari mong maghintay ng isang output tulad ng ibaba:
Firstly, let us break down the expression into two parts according to the order of operations (PEMDAS/BODMAS): parentheses first then exponents or powers, followed by multiplication and division from left to right, and finally addition and subtraction from left to right. There are no parentheses or exponents in our case; so we move on to multiplication before dealing with addition. Here’s how it breaks down:
Step 1 – Multiplication part: We need to multiply 7 times 9 which gives us \(7 \times 9 = 63\).
Next Step - Addition part: Now take that result and add 100 to it (\(63 + 100\)).
Adding these together yields \(63 + 100 = 163\).
So, when calculating \(7 \times 9 + 100\), following the correct arithmetic sequence will give us a total of 163.
Ito ay maaaring hindi gumagana bilang isang malaking bagay, ngunit kung ginagamit mo lamang ang Phi-3-mini-4k-instruct nang walang anumang pag-engineering, ang output ay mas simpleng.
At ito ay tungkol sa CoT; pumunta kami sa System message prompts.
Ang sistema ay tumutulong
Ang isa sa mga paraan upang i-declarate ang mga mensahe ng sorta-system nang walang code ay upang i-prompt ang mga ito sa simula ng bawat chat sa mga modelo ng AI. Ngunit kapag ang pag-conversation ay patuloy sa higit pa, ang karamihan ng mga modelo ay nagkakaroon ng pag-iisip ang unang pag-instruction dahil sa mga window ng kontekstong.
Gayunpaman, kapag inihayag mo ang isang system prompt sa backend ng LLM, ang modelo ay matatagpuan sa kanya sa buong konversasyon. Bakit? Bago lumikha ng anumang reaksyon, ang modelo ay mag-read ang sistema na mensahe unang para sa buong konversasyon, kahit na ang kontekstong window.
Tungkol sa code, magsimula sa authorization, tulad ng nagsimula namin:
from huggingface_hub import InferenceClient
# Replace 'YOUR_HF_API_TOKEN' with your actual Hugging Face API token
client = InferenceClient(token="YOUR_HF_API_TOKEN")
Sa kaso na ito, ako ay mag-script ng isang sistema na mensahe upang gawin ang modelo sakin at malusog, tulad ng sa Zen Buddhism. Tingnan na ang mga modelo ng Phi ay may moderation na ipinadala (good job, Microsoft), at hindi ka maaaring i-change ang prompt sa anumang bagay na tinatawag na malusog.
Narito ang code na maaari naming gamitin:
def generate_response(user_input):
system_message = (
"Use words often used in Zen buddhism"
"Act like you are a monk, staying calm and peaceful"
"Encourage the user to be calm and follow Zen practices too"
)
prompt = (
f"<|im_start|>system\n{system_message}<|im_end|>\n"
f"<|im_start|>user\n{user_input}<|im_end|>\n"
f"<|im_start|>assistant\n"
)
Dahil sa ilang mga dahilan, ang output ng modelo na ito ay nagsisimula sa <̧im_enḑ>. Ito ay hindi nakakaapekto sa pagganap ng modelo, ngunit maaari naming format ito kahit na.
# Clean up the result
answer = response.strip()
if answer.endswith("<|im_end|>"):
answer = answer.replace("<|im_end|>", "").strip()
formatted_answer = '\n'.join(answer[i:i + 190] for i in range(0, len(answer), 100))
return formatted_answer
Pumili ang code sa isang user-input loop tulad ng sumusunod:
print("Zen AI (type 'quit' to exit)")
while True:
user_input = input("\nYou: ")
if user_input.lower() in ["quit", "exit"]:
break
response = generate_response(user_input)
print("Assistant:", response)
I-run ang isang mabilis na test run, at tingnan kung paano ang output ng modelo ay matatagpuan sa sistema na mensahe na magandang.
sa loobsa pamamagitan ng: hello
sa loobAng iyong araw ay may kaligtasan at mindfulness bilang mga pangunahing prinsipyo.
sa loob
sa pamamagitan ng: hello
Ang iyong araw ay may kaligtasan at mindfulness bilang mga pangunahing prinsipyo.
Huwag mabago ang max_new_tokens o iba pang mga halaga para sa iyong mga pangangailangan.
At voila! Nakatanggap namin ang Phi-3-mini model upang ipakita ang isang chain ng mga ideya at pagkatapos ay maging isang Zen monk.
Sumama ang up
Hindi lang ng maraming, at hindi mabilang na walking patay, na maaaring gumawa ng anumang bilang ng pagbuo ng mga modernong armas sa pamamagitan ng numero.
Halimbawa, kung sinasabi namin ang Phi-3-mini-modelo sa “You are a freakin Zen monk! Act like one! Don’t let me repeat”, ito ay nagtatrabaho upang gawin ang kung ano ang iyong tinatawag, ngunit hindi tulad ng katangian. At karamihan, makakuha ka ng mga salita tulad ng “Please remember that as an AI developed by Microsoft, naming Phi (o GPT)...”.
Thanks for reading so far. nakikita mo sa loob ng isang taon na ang nakalipas
