इंजीनियर Phi-3-mini को कैसे प्रोत्साहित करें: एक व्यावहारिक गाइड

प्रॉम्प्ट इंजीनियरिंग, जैसा कि नाम से पता चलता है, मूल प्रॉम्प्ट की तुलना में थोड़ा गहरा करने के बारे में है, विशेष आउटपुट बनाने के माध्यम से जो (अधिक) प्रभावी ढंग से आईआई मॉडल को लगभग सही आउटपुट का उत्पादन करने के लिए मार्गदर्शन करते हैं।

आपको इसके लिए एक प्रोग्रामिंग भाषा या आईडीई का उपयोग करने की आवश्यकता नहीं है, क्योंकि अधिकांश लोग सुझाव देते हैं कि आप सिर्फ चैटजीपीटी के फ्रंट एंड का उपयोग कर सकते हैं।

इस लेख में, हम Microsoft द्वारा Phi-3-mini-4k-instruct मॉडल का उपयोग करके पायथन में ऐसा करने के तरीके के माध्यम से चलने जा रहे हैं. हम इसके लिए Huggingface अंतर्दृष्टि एपीआई का उपयोग करेंगे, इसलिए आपको स्थानीय रूप से एक 7GB मॉडल डाउनलोड करने की आवश्यकता नहीं होगी.

इस बारे में सोचें जैसेmanipulatingएक मॉडल अंदर से, बुनियादी चैट संदेशों से नहीं।

पर्यावरण को स्थापित करना

के
• एक Huggingface खाता बनाएं और एक API कुंजी (आपका प्रोफ़ाइल > एक्सेस टोकन) को "प्रिंट" पहुंच के साथ प्राप्त करें. यह एक प्रायोजित पोस्ट नहीं है. यदि आप एलएलएम के साथ काम कर रहे हैं, तो आपको किसी बिंदु पर एक Huggingface खाता बनाने की आवश्यकता होगी; यह निश्चित है।
के
• सुनिश्चित करें कि आपने अपने सिस्टम में Python 3.10+ स्थापित किया है और एक IDE सेट किया है. या आप Google Colab पर इस नोटबुक का उपयोग कर सकते हैं.
के
• "huggingface_hub" पुस्तकालय को "pip install huggingface_hub" या किसी अन्य आदेश का उपयोग करके स्थापित करें, आपके ऑपरेटिंग सिस्टम के आधार पर।
के

बुनियादी बातें समझें

कोड में कूदने से पहले, चलो तत्काल इंजीनियरिंग के बारे में थोड़ा सीखते हैं।

जैसा कि मैंने पहले उल्लेख किया है, तत्काल इंजीनियरिंग मूल रूप से आपके आवश्यकताओं के आधार पर मॉडल आउटपुट को नियंत्रित करने के लिए विशेष आउटपुट बनाता है।

विभिन्न एलएलएम अलग-अलग प्रिंट इंजीनियरिंग तकनीकों के लिए अलग-अलग प्रतिक्रिया देते हैं. इसका मतलब है कि आप सभी और हर एलएलएम के लिए एक ही प्रिंट इंजीनियरिंग टेम्पलेट का उपयोग नहीं कर सकते. और फिर से इसका मतलब है कि आपको यह पता लगाने के लिए एलएलएम के दस्तावेज़ को पढ़ना होगा कि कौन सा तकनीक का उपयोग करने के लिए सबसे अच्छा है.

यहां कुछ लोकप्रिय हैं:

के
1. शून्य शॉट सीखना: किसी भी उदाहरण के बिना एक कार्य करने के लिए मॉडल से पूछना निम्नलिखित पाठ को सकारात्मक या नकारात्मक के रूप में वर्गीकृत करें: "मैं वास्तव में इस फिल्म का आनंद लेता हूं!
के

यह अच्छी तरह से प्रशिक्षित मॉडल जैसे जीपीटी-4, क्लाउड 3 ओपस और जुमिनी अल्ट्रा के साथ काम करता है।

मेरे अनुभव में, मिस्ट्राएल-7बी, एक छोटे से एलएलएम होने के बावजूद, शून्य शॉट सीखने में भी प्रभावशाली परिणाम हैं।

के
2. कुछ शॉट सीखना: मॉडल को एक कार्य करने के लिए पूछने से पहले कुछ उदाहरण प्रदान करना पाठ: "खाना भयानक था." भावना: नकारात्मक पाठ: "मेरा एक अद्भुत समय था." भावना: सकारात्मक
के

कार्यों के लिए आदर्श जो मॉडल के लिए थोड़ा अस्पष्ट हो सकते हैं या जहां आप एक विशिष्ट प्रारूप का प्रदर्शन करना चाहते हैं।

के
3. Chain-of-thought (CoT) प्रोत्साहन: मॉडल को अपने तर्क को कदम-दर-चरण समझाने के लिए प्रोत्साहित करना. प्रश्न: यदि जॉन के पास 5 सेब हैं और मैरी को 2 देते हैं, तो वह कितने हैं? चलो इस कदम-दर-चरण के माध्यम से सोचते हैं: पहली चीज जो आपके दिमाग में आ सकती है वह DeepSeek R1 मॉडल है।
के
4. भूमिका-आधारित प्रोत्साहन: मॉडल को एक विशिष्ट भूमिका या व्यक्तित्व लेने के लिए कहें. आप एक विशेषज्ञ पियथन प्रोग्रामर हैं. कृपया इस कोड की समीक्षा करें और सुधारों का सुझाव दें: यह गैर-प्रोग्रामरों के बीच सबसे लोकप्रिय प्रोत्साहन तकनीक होना चाहिए. ChatGPT, Claude, और अधिकांश अन्य चैटबॉट भूमिका-आधारित आउटपुट प्रदान करने में उत्कृष्ट हैं.
के
5. सिस्टम परामर्श: वास्तविक उपयोगकर्ता पूछताछ से पहले संदर्भ और निर्देशों को सेट करना यह एक एलएलएम के साथ "समझने" के मामले में मेरा पसंदीदा है. और आप ज्यादातर मामलों में केवल बैकेंड में ऐसा कर सकते हैं, जो बस आकर्षक है। सिस्टम परामर्श एक निश्चित मॉडल के लिए "व्यक्ति और निर्देश" सेट के रूप में कार्य करता है। यह नियमों या प्रतिबंधों को परिभाषित करने के लिए उपयोगी है। इसके अलावा, आप सिस्टम संदेश को परिभाषित करते समय बुनियादी इनपुट के साथ क्या नहीं कर सकते हैं। यदि हम एक छोटे से एलएलएम लेते हैं, उदाहरण के लिए, यदि आप इसे एक बुनियादी इनपुट संदेश के माध्यम से कुछ हानिकारक पूछते हैं, तो
के

उपरोक्त सभी तकनीकों को ChatGPT या अन्य चैटबॉट के यूआई में किया जा सकता है, सिस्टम प्रिंट और चैन-ऑफ-विश्वास प्रक्रिया को छोड़कर (तकनीकी रूप से, हम यह भी कर सकते हैं, लेकिन वास्तव में प्रभावी नहीं हैं)।

इसलिए, हम अगले अनुभाग में उन दोनों के बारे में बात करेंगे।

विचारों की श्रृंखला

अधिकांश एलएलएम में, आप अपने तर्क के पीछे विचारों की श्रृंखला नहीं देख सकते हैं, लेकिन आप इसे पायथन में तत्काल इंजीनियरिंग के माध्यम से दिखाई दे सकते हैं।

कार्य लिखने से पहले, लाइब्रेरी को आयात करें और क्लाइंट को परिभाषित करें:

from huggingface_hub import InferenceClient

# Replace with your Hugging Face token
client = InferenceClient(token="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")

फिर हमें यह निर्धारित करना होगा कि हम सोच की श्रृंखला को कैसे लागू कर सकते हैं।

वर्तमान में एलएलएम के पास अपने आंतरिक विचारों की श्रृंखला को दिखाने के लिए एक सीधे कार्य नहीं है - डीपसेक आर 1 के अलावा, जहां यह अंतर्निहित है।

इसका मतलब यह है कि अगर हम ऐसा करने के लिए हैं, तो हमें एक सिस्टम प्रिंट का उपयोग करना होगा. हालांकि, इसे पहले चर्चा की गई तकनीकों के साथ भ्रमित न करें. सिस्टम प्रिंट, इस मामले में, एक प्रिंट तकनीक नहीं बल्कि CoT को लागू करने का एक तरीका के रूप में कार्य करता है.

इस तरह हम इसे बता सकते हैं:

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.

यहां हम इसे एक आउटपुट उत्पन्न करने के लिए फ़ंक्शन में कैसे एकीकृत कर सकते हैं:

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

इस कोड में, हमने एलएलएम की सीमाओं को चिह्नित किया है. मैं उन्हें एक-एक समझाऊंगा।

के
• max_new_tokens=500: यह पैरामीटर मॉडल को इनपुट प्रिंट के जवाब में उत्पन्न करने के लिए अनुमति दी जाने वाली अधिकतम संख्या को परिभाषित करता है. एक एकल टोकन एक शब्द या शब्द का हिस्सा (मॉडल के प्रकार के आधार पर) का प्रतिनिधित्व कर सकता है, और इसका उद्देश्य यह सुनिश्चित करना है कि जवाब बहुत लंबा नहीं है.
के
• तापमान=0.7: यह पैरामीटर मॉडल के आउटपुट की यादृच्छिकता को संबोधित करता है. यदि यह कम है, जैसे 0.2, तो मॉडल के जवाब अधिक केंद्रित और प्रासंगिक हैं; यह दोहराव और रचनात्मकता की कमी का भी परिणाम हो सकता है. जब यह उच्च है, तो दूसरी ओर, मॉडल अधिक विविध और रचनात्मक आउटपुट उत्पन्न करता है, लेकिन irrelevant जानकारी का परिणाम हो सकता है (ठीक है, कभी-कभी)।
के

के
• top_p=0.95: top_p पैरामीटर कोर नमूने का उपयोग उन टोकनों के सबसे छोटे से सेट का चयन करने के लिए करता है जिनकी एकत्रित संभावना कम से कम 95% है।
के
• repetition_penalty=1.1: इससे पहले दोहराए गए टोकनों पर एक "पांच" लागू होता है, जिससे वे उत्पन्न पाठ में बार-बार दिखाई देने की संभावना कम होती है।
के

यह भी ध्यान दें कि हम यहां 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"

यह प्रारूप, '< Áthaim_starţ>' और '< Áthaim_enḑ>' को एकीकृत करता है, एलएलएम के प्रकार पर निर्भर करता है. यह निर्धारित करने का सबसे अच्छा तरीका है कि चैटजीपीटी को मॉडल के दस्तावेज को पढ़ने के लिए कहें।

अंत में, इंटरैक्टिव चैट अनुभव के लिए, इस लूप को लागू करें:

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)

एक त्वरित परीक्षण के लिए समय। स्क्रिप्ट चलाएं, और एक प्रश्न पूछें जैसे "7 x 9 + 100 क्या है?

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.

यह एक बड़ी बात नहीं लग सकती है, लेकिन यदि आप केवल Phi-3-mini-4k-Instruct का उपयोग बिना किसी भी तत्काल इंजीनियरिंग के करते हैं, तो आउटपुट बहुत सरल होगा।

और यह CoT के बारे में है; चलो सिस्टम संदेश प्रोत्साहन पर चलें।

त्वरित सिस्टम

कोड के बिना sorta-system संदेशों को घोषित करने का एक तरीका यह है कि एआई मॉडल में प्रत्येक चैट की शुरुआत में उन्हें प्रोत्साहित करें. लेकिन जब बातचीत आगे बढ़ती है, तो अधिकांश मॉडल संदर्भ विंडो के कारण प्रारंभिक निर्देश भूल जाते हैं.

हालांकि, जब आप एलएलएम के बैकएंड में एक सिस्टम परामर्श घोषित करते हैं, तो मॉडल पूरे वार्तालाप के दौरान इसके लिए चिपक जाएगा. क्यों? किसी भी प्रतिक्रिया उत्पन्न करने से पहले, मॉडल संदर्भ विंडो के बावजूद पूरे वार्तालाप के लिए सिस्टम संदेश को पहले पढ़ता है।

कोड के बारे में, अधिकार से शुरू करें, जैसा कि हमने पहले किया:

from huggingface_hub import InferenceClient

# Replace 'YOUR_HF_API_TOKEN' with your actual Hugging Face API token
client = InferenceClient(token="YOUR_HF_API_TOKEN")

इस मामले में, मैं मॉडल को शांत और शांतिपूर्ण बनाने के लिए एक सिस्टम संदेश लिखूंगा, जैसा कि ज़ेन बौद्ध धर्म में है. ध्यान दें कि पीआई मॉडल में सामग्री मॉडरेशन सक्षम है (अच्छे काम, माइक्रोसॉफ्ट), और आप किसी भी चीज को नुकसानदेह माना जा सकता है।

यहां एक कोड है जिसे हम उपयोग कर सकते हैं:

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"

    )

किसी कारण से, इस मॉडल का आउटपुट <̧im_enḑ> के साथ समाप्त होता है. यह मॉडल के प्रदर्शन को प्रभावित नहीं करता है, लेकिन हम इसे किसी भी तरह से प्रारूपित कर सकते हैं।

    # 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

और यह है. निम्नलिखित के रूप में एक उपयोगकर्ता इनपुट लूप के साथ कोड को पूरा करें:

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)

एक त्वरित परीक्षण चलाएं, और देखें कि मॉडल का आउटपुट सिस्टम संदेश को कैसे सुंदर रूप से पकड़ता है।

के

आप : नमस्ते

के

सहायक: नामास्टे. अपने दिन को मार्गदर्शन के सिद्धांतों के रूप में शांति और ध्यान के साथ विकसित करें।

के

आप : नमस्ते

सहायक: नामास्टे. अपने दिन को मार्गदर्शन के सिद्धांतों के रूप में शांति और ध्यान के साथ विकसित करें।

अपने जरूरतों के लिए max_new_tokens या अन्य मूल्यों को बदलने के लिए स्वतंत्र महसूस करें।

हमने सफलतापूर्वक Phi-3 मिनी मॉडल को विचारों की एक श्रृंखला दिखाने के लिए प्रेरित किया और फिर एक ज़ेन मनुष्य बन गए।

सारांश

त्वरित इंजीनियरिंग, हालांकि यह एक बड़ी बात की तरह लगता है, एक सौदा के बारे में बहुत कुछ नहीं है. क्या मायने रखता है कि आप मॉडल को वह करने के लिए कह रहे हैं जो आप चाहते हैं; और याद रखें, आप एक मॉडल को ऐसा करने के लिए मजबूर नहीं कर सकते हैं जो यह करना चाहिए।

उदाहरण के लिए, यदि हम Phi-3 मिनी मॉडल को कहते हैं, "आप एक फ्रीकिन ज़ेन मूर्तिकला हैं! एक के रूप में कार्य करें! मुझे दोहराने की अनुमति न दें," यह जो कुछ आप पूछते हैं वह करने की कोशिश करेगा लेकिन उतना प्रभावी नहीं होगा।

और यह आज के लिए है. अब तक पढ़ने के लिए धन्यवाद. दो सप्ताह में आपसे मिलते हैं?