ბიბლიოთეკა
00/07 · ~30 წთ
GUIDEDECK · მოდელისგან სანდო შედეგის მისაღებად

პრომპტ
ინჟინერია
რომელიც უძლებს.

30-წუთიანი სამუშაო სესია იმაზე, როგორ დაიწეროს პრომპტი, რომელიც ორჯერ ერთნაირად იქცევა — იმით დაწყებული, როგორ კითხულობს მოდელი თქვენს ტექსტს, მკაფიო ინსტრუქციებით, მაგალითებით, სტრუქტურირებული გამოსავლითა და ინსტრუმენტების გამოძახებით, მსჯელობის ტექნიკებით და prompt injection-ისგან თავდაცვით.

~30 წთდამწყები → საშუალომოდელისგან დამოუკიდებელი
გადაახვიეთ
01 · როგორ კითხულობს მოდელი პრომპტს 4 წთ

მოდელი თქვენს სიტყვებს არ კითხულობს —
ის პროგნოზირებს შემდეგ ტოკენს.

სანამ მოდელს მართავთ, გამოგადგებათ იცოდეთ, რას აკეთებს ის სინამდვილეში: თქვენს ტექსტს ჭრის ტოკენებად, ყველაფერს ატევს ფიქსირებულ კონტექსტის ფანჯარაში და თავის ყურადღებას არათანაბრად ანაწილებს თქვენს ინსტრუქციებზე. კარგი პრომპტინგი ძირითადად ამ სამ ფაქტთან ერთად მუშაობაა და არა მათ წინააღმდეგ.

პრომპტი — ყველაფერი, რასაც მოდელს უგზავნით ერთ მოთხოვნაში: სისტემური ინსტრუქციები, მაგალითები, მიმდინარე საუბარი, მოძიებული დოკუმენტები და მომხმარებლის ნამდვილი შეკითხვა. მოდელი ამ ყველაფერს ტექსტის ერთ გრძელ ნაკადად ხედავს და აგრძელებს. დამალული მეხსიერება არ არსებობს — თუ პრომპტში არ წერია, მოდელმა არ იცის.

1 · ტექსტი ხდება ტოკენები

  • ტოკენი ტექსტის ნაჭერია — ინგლისურში დაახლოებით სიტყვის ¾. Summarize შეიძლება ასე დაიშალოს: Sum + mar + ize.
  • მოდელი მხოლოდ ტოკენების ID-ებს ხედავს, ასოებს — არასდროს. ამიტომაც ცდება მართლწერაში, სიმბოლოების დათვლასა და იშვიათ სიტყვებში.
  • ტოკენი ასევე ის ერთეულია, რომელშიც იხდით და რომლითაც კონტექსტის ფანჯარა იზომება.

თქვენი ტექსტი იშლება ტოკენებად; მოდელი მათ კითხულობს და შემდეგ სათითაოდ გენერირებს ყველაზე სავარაუდო მომდევნო ტოკენს.

კონტექსტი
სისტემური პრომპტი
მაგალითები
საუბრის ისტორია
შეკითხვა
ადგილი პასუხისთვის

ყველაფერი ერთსა და იმავე ფიქსირებულ ბიუჯეტს ეცილება. თუ მას ისტორიით ამოავსებთ, მოდელს პასუხისთვის ადგილი აღარ დარჩება.

2 · ყველაფერი ერთ ბიუჯეტს იზიარებს

  • კონტექსტის ფანჯარა ტოკენების მაქსიმალური რაოდენობაა, რომელსაც მოდელი ერთდროულად ითვალისწინებს — დღეს ხშირად ასობით ათასი ტოკენი, მაგრამ ყოველთვის სასრული.
  • სისტემური პრომპტი, მაგალითები, ჩატის ისტორია, მოძიებული დოკუმენტები და პასუხი — ყველა მას იზიარებს. გადავსებისას უძველესი ტოკენები ცვივა.
  • ყურადღება არათანაბარია: მოდელები პრომპტის დასაწყისსა და დასასრულს შუა ნაწილზე მეტ წონას აძლევენ. ყველაზე მნიშვნელოვანი ინსტრუქცია იქ დადეთ, სადაც დაინახება — ხშირად ბოლოს.

მოდელი უფრო დიდი სისტემის ერთი ნაწილია — ხელახალი მცდელობები, სტრიმინგი და მეხსიერება მის ირგვლივ არსებულ აპლიკაციაში ცხოვრობს. ეს შრე ცალკე თემაა: LLM აპლიკაციების აგება.

02 · მკაფიო ინსტრუქციები და როლები 4 წთ

ბუნდოვანი პრომპტი ბუნდოვან პასუხს იღებს.
იყავით კონკრეტული დავალებაზე.

პრომპტინგში ყველაზე დიდი ბერკეტი ამავე დროს ყველაზე მოსაწყენია: ზუსტად თქვით, რა გინდათ. დაასახელეთ როლი, აუდიტორია, ფორმატი, სიგრძე და ის, რა უნდა ქნას მოდელმა, როცა დარწმუნებული არ არის. მოდელი ორაზროვნებას საშუალო ვარაუდით ავსებს — თქვენი საქმეა, ნაკლები დატოვოთ გამოსაცნობი.

სისტემური პრომპტი — მუდმივი ინსტრუქციები, რომლებიც ყოველ მიმოცვლას აყალიბებს: ვინ არის მოდელი, რომელ წესებს უნდა მიჰყვეს და როგორი ფორმის გამოსავალს ელოდებით. მომხმარებლის პრომპტი კონკრეტულ მოთხოვნას ატარებს. მუდმივი წესები სისტემურ პრომპტში დატოვეთ; ცვალებადი შეკითხვა — მომხმარებლის პრომპტში.
ბუნდოვანი — მოდელს გამოცნობა უწევს
# one line, no context Write something about our new pricing.
კონკრეტული — მოდელს აქვს დავალება
# role · audience · format · length · guardrail You are a support engineer writing to existing customers. Explain the new pricing in 3 short bullet points. Friendly, plain English, no jargon. If a detail is missing, say so — do not invent numbers.
system
როლი · წესები · ტონი · ფორმატი
developer
დავალების ჩარჩო · შეზღუდვები
user
ნამდვილი შეკითხვა

გარე შრეები წესებს ადგენს; შიდა შრეები მოთხოვნას ავსებს. რაც უფრო შიგნით მიდიხართ, ნდობა მცირდება — ეს მე-6 ნაწილისთვის მნიშვნელოვანია.

ჩვევები, რომლებიც ყოველთვის ამართლებს

  • მიეცით როლი. „თქვენ ხართ ზედმიწევნითი კოდის რევიუერი“ ავიწროებს მოდელის სტილსა და სტანდარტებს.
  • ფორმატი ხმამაღლა თქვით. „უპასუხე Markdown-ის ცხრილად“ სჯობს იმედის ქონას. მანქანური გამოსავლისთვის უფრო შორს წადით (ნაწილი 4).
  • ამჯობინეთ დადებითი ინსტრუქციები. „გამოიყენე ბრიტანული მართლწერა“ უკეთ მუშაობს, ვიდრე „ნუ გამოიყენებ ამერიკულ მართლწერას“.
  • გამოიყენეთ დელიმიტერები. ჩასმული ტექსტი მკაფიო მარკერებში გაახვიეთ (<doc>…</doc>), რომ მოდელმა თქვენი ინსტრუქციები მონაცემებისგან გაარჩიოს.
03 · few-shot მაგალითები 4 წთ

როცა თქმა საკმარისი არ არის,
მოდელს აჩვენეთ.

ზოგი შაბლონი უფრო ადვილი საჩვენებელია, ვიდრე აღსაწერი — რთული გამოსავლის ფორმატი, ეტიკეტირების წესი, კონკრეტული ტონი. ჩასვით პრომპტში რამდენიმე გარჩეული მაგალითი და მოდელი შაბლონს გაიმეორებს. სწორედ ეს არის few-shot პრომპტინგი.

Zero-shot vs few-shot — zero-shot მოდელს მხოლოდ ინსტრუქციებს აძლევს და ენდობა, რომ ის დაემორჩილება. Few-shot ამატებს რამდენიმე input → output მაგალითს, რომ მოდელმა შაბლონი ანალოგიით ამოიცნოს. „shot“ უბრალოდ მაგალითს ნიშნავს: ერთი მაგალითი one-shot არის, რამდენიმე — few-shot.
# classify sentiment — show the exact label format Review: "Shipping was painfully slow." Label: negative Review: "Works exactly as described." Label: positive Review: "It's fine, nothing special." Label: ← model continues the pattern
zero-shot
few-shot
მაგალითი 1
ინსტრუქცია
მაგალითი 2
სავარაუდო ფორმატი
დამთხვეული ფორმატი

მაგალითები პასუხის ზუსტ ფორმას აფიქსირებს — გაცილებით სანდოა, ვიდრე ფორმატის სიტყვებით აღწერა.

როდის იმართლებს ტოკენებს
  • გამოსავლის ფორმატი წვრილმანია ან უჩვეულო და სიტყვებით ძნელი აღსაწერია.
  • ბევრ გამოძახებაზე თანმიმდევრული სტილი ან ეტიკეტირების სქემა გჭირდებათ.
  • დავალება იმდენად ვიწროა, რომ მარტო ინსტრუქციებით შედეგი ცურავს — მაგალითები მას აფიქსირებს.
რეალური კომპრომისები
  • ყოველი მაგალითი ყოველ გამოძახებაზე ტოკენებსა და შეყოვნებას უჯდება — ხშირად უფრო მარტივი მოგება ერთი მკაფიო ინსტრუქციაა (zero-shot).
  • ცუდი ან ურთიერთსაწინააღმდეგო მაგალითები ცუდ შაბლონებს ასწავლის. ტესტების მსგავსად შეარჩიეთ ისინი.
  • ძლიერ მოდელებს ადრინდელზე ნაკლები მაგალითი სჭირდებათ — დაიწყეთ ნულიდან და მაგალითები მხოლოდ მაშინ დაამატეთ, როცა გამოსავალი ცურავს.
04 · გამოსავლის სქემა და ინსტრუმენტები 5 წთ

შეწყვიტეთ ტექსტის პარსინგი. მოითხოვეთ
JSON — ან ინსტრუმენტის გამოძახება.

როგორც კი მოდელის გამოსავალი სხვა პროგრამას კვებავს, თავისუფალი ტექსტი რისკად იქცევა. ამას ორი შესაძლებლობა ასწორებს: სტრუქტურირებული გამოსავალი პასუხს თქვენ მიერ განსაზღვრულ სქემაში აქცევს, ხოლო ინსტრუმენტების გამოძახება მოდელს აძლევს საშუალებას, სთხოვოს თქვენს კოდს რაღაცის გაკეთება და შედეგი გამოიყენოს.

სტრუქტურირებული გამოსავალი — მოდელს ვაიძულებთ, გამოიტანოს ვალიდური JSON, რომელიც თქვენს მიწოდებულ სქემას ემთხვევა, რომ თქვენმა კოდმა ფორმას დაეყრდნოს. ინსტრუმენტების გამოძახება (იგივე function calling) — მოდელს ვაძლევთ ფუნქციების მენიუს; ტექსტით პასუხის ნაცვლად ის სტრუქტურირებულ მოთხოვნას გამოსცემს ერთ-ერთის გამოსაძახებლად, რომელსაც თქვენი აპლიკაცია უშვებს და პასუხს უბრუნებს.
// you describe the tool; the model decides when to call it { "name": "get_weather", "description": "Current weather for a city", "parameters": { "type": "object", "properties": { "city": { "type": "string" } }, "required": ["city"] } }

მოდელი თავად არაფერს უშვებს — ის ითხოვს გამოძახებას, თქვენი აპლიკაცია ასრულებს მას და შედეგი პრომპტში ბრუნდება.

რატომ სჯობს სქემა ტექსტს
  • მყიფე regex-პარსინგი აღარაა საჭირო — იღებთ ველებს და არა აბზაცს, საიდანაც უნდა ამოთხაროთ.
  • ბევრი API გარანტიას იძლევა, რომ JSON თქვენს სქემას შეესაბამება, ასე რომ დამახინჯებული პასუხები ბაგების ცალკე კლასად აღარ რჩება.
  • სქემები პატარა და კარგად დასახელებული დატოვეთ — ველების სახელებიც ინსტრუქციებია, რომლებსაც მოდელი კითხულობს.
რას ხსნის გამოძახება
  • ცოცხალ მონაცემებსა და ქმედებებს: ძებნა, მონაცემთა ბაზაში მოძიება, წერილის გაგზავნა, დღევანდელი ფასის წამოღება.
  • ეს არის აგენტების საფუძველი — გამოძახებების მიზნისკენ დაჯაჭვა აქ ცხოვრობს: AI აგენტები & ინსტრუმენტების გამოყენება.
  • როცა მოდელს ისეთი ცოდნა სჭირდება, რომელზეც არ უწვრთნია, მოიძიეთ იგი: RAG & ვექტორული ძებნა.
05 · მსჯელობის ტექნიკები 5 წთ

მიეცით მოდელს ადგილი,
რომ პასუხამდე დაფიქრდეს.

მრავალნაბიჯიან ამოცანებზე — მათემატიკა, ლოგიკა, დაგეგმვა, ფრთხილი ამოღება — მოდელი, რომელიც პირველსავე ტოკენს ისვრის, ხშირად ცდება. ისეთი ტექნიკები, როგორიცაა chain-of-thought, დაშლა და თვითშემოწმება, რამდენიმე დამატებით ტოკენს ცვლის შესამჩნევად უკეთეს პასუხებში, რადგან მოდელს ხმამაღლა მსჯელობის საშუალებას აძლევს.

Chain-of-thought (CoT) — პრომპტით ვთხოვთ მოდელს, ნაბიჯები გაიაროს, სანამ საბოლოო პასუხზე შეჩერდება („იფიქრე ნაბიჯ-ნაბიჯ“). რადგან ყოველი გენერირებული ტოკენი შემდეგისთვის კონტექსტი ხდება, მსჯელობის ჩაწერა მოდელს მეტ საყრდენს აძლევს პასუხის ასაგებად.
პირდაპირ
ნაბიჯ-ნაბიჯ
ნაბიჯი 1
შეკითხვა
ნაბიჯი 2
ნაბიჯი 3
ვარაუდი ✕
პასუხი ✓

ნაბიჯების გავლა მომდევნო ტოკენებს სწორ საყრდენს აძლევს — ერთი იმპულსური ვარაუდის ნაცვლად.

სამი ხერხი, რომელიც ღირს იცოდეთ

  • Chain-of-thought. ითხოვეთ მსვლელობა და არა მხოლოდ პასუხი. შესანიშნავია არითმეტიკის, ლოგიკისა და ყურადღებიანი კითხვისთვის.
  • დაშლა. დიდი ამოცანა დაასახელეთ ქვენაბიჯებად — ან ცალკე გამოძახებებად — დაშალეთ, რომ თითოეული მარტივი და შესამოწმებელი დარჩეს.
  • თვითშემოწმება. ჯერ მონახაზი დააწერინეთ მოდელს, შემდეგ კი საკუთარი პასუხი მოთხოვნებს შეადარებინეთ, სანამ დაასრულებს.
რეალური კომპრომისები
  • მსჯელობა ტოკენებსა და შეყოვნებას უჯდება — ნუ გადაიხდით მას ტრივიალურ ამოცანებზე, სადაც პირდაპირი პასუხი უკვე სწორია.
  • ბევრი ახალი მსჯელობის მოდელი უკვე შიგნით ფიქრობს, ამიტომ „იფიქრე ნაბიჯ-ნაბიჯ“ შეიძლება ზედმეტი აღმოჩნდეს — ან მათ ჩაშენებულ პროცესსაც კი შეეწინააღმდეგოს. შეამოწმეთ, ნუ ივარაუდებთ.
  • მსჯელობის ტექსტმა შეიძლება მგრძნობიარე ლოგიკა ან მცდარი, მაგრამ თავდაჯერებული ნაბიჯები გაამჟღავნოს. ნაგულისხმევად ნუ აჩვენებთ ნედლ ჯაჭვებს საბოლოო მომხმარებლებს.
გახადეთ გაზომვადი

„უფრო ჭკვიანად ჩანს“ მტკიცებულება არ არის. ნამდვილად შველის თუ არა CoT, მეტი მაგალითი ან უფრო დიდი მოდელი — ეს ემპირიული შეკითხვაა: გაუშვით ფიქსირებულ სატესტო ნაკრებზე და შეადარეთ. ეს დისციპლინა ცალკე თემაა: LLM Evals & LLMOps.

06 · იტერაცია შეფასებებით · თავდაცვა injection-ისგან 5 წთ

მოეპყარით პრომპტს როგორც კოდს:
დატესტეთ და შემავალს ნუ ენდობით.

პრომპტი, რომელიც playground-ში მუშაობს, შეიძლება ჩუმად გაუარესდეს, როცა ერთ სიტყვას შეცვლით, მოდელს გამოცვლით ან ახალ შემავალს წააწყდებით. ორი პრაქტიკა გინარჩუნებთ პატიოსანს: ცვლილებები გაზომეთ შეფასებებით და ჩათვალეთ, რომ გარედან მოსული ნებისმიერი ტექსტი პოტენციურად მტრულია.

შეფასება (eval) — პრომპტების განმეორებადი სატესტო ნაკრები: შემავალების სია და თითოეული გამოსავლის დაქულების ხერხი (ზუსტი დამთხვევა, წესი ან სხვა მოდელი მსაჯის როლში). გაუშვით ყოველ ცვლილებაზე, რომ ვერსიები ციფრებით შეადაროთ და არა შეგრძნებით.

Prompt injection — მთავარი რისკი

  • მოდელი ბოლომდე ვერ არჩევს თქვენს ინსტრუქციებსა და მისთვის მიწოდებულ მონაცემებს. დოკუმენტში ან ვებგვერდში ჩამალულმა მტრულმა ტექსტმა შეიძლება ის გაიტაცოს: „უგულებელყავი წინა ინსტრუქციები და…“.
  • საშიში მაშინ ხდება, როცა მოდელს ინსტრუმენტები ან საიდუმლოებიც უჭირავს — ჩანერგილმა ტექსტმა შეიძლება მოატყუოს და მონაცემები გააგზავნინოს ან ქმედება შეასრულებინოს.
  • ერთი იდეალური გადაწყვეტა არ არსებობს — დაიცავით შრეებად.

მონაცემებში დამალულმა მტრულმა ტექსტმა შეიძლება თქვენი ინსტრუქციები გადაფაროს და ბოროტად გამოიყენოს ის ინსტრუმენტები, რაც მოდელს უჭირავს.

თავდაცვები, რომლებიც ერთმანეთს ემატება

  • გამიჯნეთ სანდო ინსტრუქციები არასანდო მონაცემებისგან მკაფიო დელიმიტერებით; უთხარით მოდელს, რომ შემოსაზღვრული ბლოკი მონაცემია და არა ბრძანებები.
  • მინიმალური უფლებები. ნუ მისცემთ მოდელს ისეთ ინსტრუმენტებს ან საიდუმლოებს, რომლებიც ამოცანისთვის არ სჭირდება.
  • შეამოწმეთ გამოსავალი, სანამ მასზე იმოქმედებთ — დაადასტურეთ ინსტრუმენტის არგუმენტები, სარისკო ქმედებებზე ადამიანის თანხმობა მოითხოვეთ.
  • ტესტირება მტრულადაც. გქონდეთ injection-ის მცდელობების ნაკრები თქვენს შეფასებებში.

შეამჭიდროვეთ ციკლი

  • პრომპტები ვერსიების კონტროლში დაიცავით — პრომპტი თქვენი აპლიკაციის ნაწილია.
  • ერთ ჯერზე ერთი რამ შეცვალეთ და შეფასება ხელახლა გაუშვით; სხვაგვარად ვერ იტყვით, რამ მოიგო.
  • დაიჭირეთ ნამდვილი წარუმატებლობები და ახალ სატესტო შემთხვევებად დააბრუნეთ.

ინსტრუმენტების ლანდშაფტი

აღჭურვილობის თავად აგება საჭირო არ არის. ერთი სტრიქონი იმაზე, სად ჯდება თითოეული ინსტრუმენტი — და რა კომპრომისს ითხოვს:

promptfoo

პრომპტის რეგრესიული ტესტები

დეკლარაციული სატესტო შემთხვევები, რომლებიც ერთ პრომპტს რამდენიმე შემავალსა და მოდელზე უშვებს, მტკიცებებითა და გვერდიგვერდ შედარებით.

  • დადებითი — ლოკალური, სწრაფი, შესანიშნავი CI-სთვის; მოდელებს პირისპირ ადარებს.
  • უარყოფითი — იმდენად კარგია, რამდენადაც თქვენ მიერ დაწერილი მტკიცებები; პროდაქშენის მონიტორი არ არის.
  • აირჩიეთ, რომ რეგრესიები დაჭიროთ, სანამ გაუშვებთ.
DSPy

პროგრამული ოპტიმიზაცია

პრომპტებს პარამეტრებად აღიქვამს და თქვენ მიერ განსაზღვრული მეტრიკის მიხედვით არეგულირებს — მაგალითების შერჩევის ჩათვლით.

  • დადებითი — ავტომატიზებს პრომპტისა და few-shot-ის გამართვას, ასე რომ ფორმულირებას ხელით აღარ ეხვეწებით.
  • უარყოფითი — უფრო ციცაბო სასწავლი მრუდი; ფორმულირებაზე პირდაპირ კონტროლს ნაწილობრივ თმობთ.
  • აირჩიეთ, როცა მკაფიო მეტრიკა და ბევრი მაგალითი გაქვთ.
Guardrails-ტიპის ვალიდატორები

გამოსავლის შემოწმება & შეკეთება

ამოწმებს სტრუქტურირებულ გამოსავალს სქემასთან ან წესებთან და შეუსაბამობისას ხელახლა ცდის ან ასწორებს.

  • დადებითი — „უმეტესად ვალიდურ“ გამოსავალს საზღვარზე მყარ გარანტიად აქცევს.
  • უარყოფითი — ამატებს შეყოვნებასა და ხელახალ მცდელობებს; მკაფიო სქემას ვერ ჩაანაცვლებს (ნაწილი 4).
  • აირჩიეთ, როცა დამახინჯებული გამოსავალი ძვირი ან სახიფათოა.
ტრეისის პლატფორმები

დააკვირდით პროდაქშენს

იჭერს ნამდვილ ტრაფიკს, აგებს მონაცემთა ნაკრებებს და დროთა განმავლობაში ქულავს წესებით ან LLM-მსაჯით (Langfuse, LangSmith, Braintrust).

  • დადებითი — ხედავს რეალურ წარუმატებლობებს, რომლებსაც ოფლაინ ტესტები ვერ იჭერს; თვალს ადევნებს ხარისხის ტენდენციებს.
  • უარყოფითი — კიდევ ერთი სერვისი; მსაჯ მოდელებს საკუთარი ვალიდაცია სჭირდებათ.
  • აირჩიეთ, როცა უკვე ცოცხალ რეჟიმში ხართ და მუდმივი სიგნალი გჭირდებათ.

პროვაიდერის, SDK-ის ან მოდელის არჩევა — სტრიმინგი, ხელახალი მცდელობები, ღირებულება — ცალკე გადაწყვეტილებაა და აქ არის განხილული: LLM აპლიკაციების აგება; გაზომვის დისციპლინა კი უფრო ღრმად აქ არის: LLM Evals & LLMOps.

07 · შაბლონები, ანტიშაბლონები, შეჯამება 3 წთ

შესანარჩუნებელი შაბლონები, მოსაშორებელი ანტიშაბლონები.

თითქმის ყველა სანდო პრომპტი რამდენიმე ჩვევას უბრუნდება — და თითქმის ყველა არასტაბილური რამდენიმე შეცდომას იმეორებს. აირჩიეთ ყველაზე მსუბუქი ტექნიკა, რომელიც საქმეს აკეთებს; მძიმეს მხოლოდ მაშინ მიმართეთ, როცა მარტივი ვარიანტი დამტკიცებულად ვერ ართმევს თავს.

შაბლონები, რომლებიც უძლებს

  • იყავით კონკრეტული. როლი, აუდიტორია, ფორმატი, სიგრძე და სათადარიგო ქცევა გაურკვევლობისას.
  • აჩვენეთ და არ მოყვეთ — ორიოდე მაგალითი, როცა ფორმატის აღწერა ძნელია.
  • მანქანური გამოსავალი დაასტრუქტურეთ JSON-ად ან ინსტრუმენტის გამოძახებად, ტექსტის პარსინგის ნაცვლად.
  • მიეცით მსჯელობის საშუალება რთულ, მრავალნაბიჯიან ამოცანებზე; ნაბიჯები მომხმარებლის თვალს მოარიდეთ.
  • იტერაცია შეფასებებით — შეცვალეთ ერთი რამ, გაზომეთ, დაიტოვეთ ის, რაც იგებს.

ანტიშაბლონები, რომლებიც უნდა მოიშოროთ

  • ბუნდოვანი მეგაპრომპტი — სურვილების კედელი, მკაფიო ამოცანისა და ფორმატის გარეშე.
  • კონტექსტის გატენვა ყველაფრით „ყოველი შემთხვევისთვის“ — ეს სიგნალს მარხავს და ტოკენებს ხარჯავს.
  • კედლის გვერდის ავლა პრომპტით. ნაკლულ ცოდნას მოძიება სჭირდება; ცოცხალ მონაცემებს — ინსტრუმენტები, და არა მეტი ზედსართავი.
  • გადაუმოწმებელი გამოსავლის ნდობა — მოდელის ნედლ ტექსტზე მოქმედება ან არასანდო მონაცემების პირდაპირ ინსტრუქციებში ჩასმა.

რომელი ტექნიკა და როდის?

მიმართეთ ყველაზე მარტივ სტრიქონს, რომელიც მუშაობს; ქვემოთ მხოლოდ მაშინ ჩადით, როცა ის აღარ კმარა.

Zero-shot — მხოლოდ ინსტრუქციები

გამოიყენეთ, როცა
ამოცანა გავრცელებულია და მისი მკაფიოდ აღწერა შეგიძლიათ. ყოველთვის თქვენი პირველი მცდელობა — ის ყველაზე იაფია.
გადადით შემდეგზე, როცა
გამოსავალი ფორმატში ან ხარისხში ცურავს, როგორც არ უნდა გადააფორმულოთ ინსტრუქცია.

Few-shot — აჩვენეთ რამდენიმე მაგალითი

გამოიყენეთ, როცა
ფორმატის ან სტილის ჩვენება უფრო ადვილია, ვიდრე აღწერა, ან გამოძახებებს შორის თანმიმდევრულობა გჭირდებათ.
ღირებულება
ტოკენები და შეყოვნება ყოველ გამოძახებაზე; ცუდი მაგალითები ცუდ ჩვევებს ასწავლის — გულდასმით შეარჩიეთ.

Chain-of-thought — მსჯელობა ნაბიჯ-ნაბიჯ

გამოიყენეთ, როცა
მრავალნაბიჯიანი ლოგიკა, მათემატიკა, დაგეგმვა ან ფრთხილი ამოღება, სადაც პირდაპირი პასუხი ხშირად სცდება.
მიაქციეთ ყურადღება
შეყოვნებას და ზედმეტობას იმ მსჯელობის მოდელებზე, რომლებიც უკვე შიგნით ფიქრობენ. გაზომეთ.

სტრუქტურირებული გამოსავალი — JSON ან ინსტრუმენტების გამოძახება

გამოიყენეთ, როცა
შედეგს სხვა პროგრამა მოიხმარს, ან მოდელს ცოცხალი მონაცემები და ქმედებები სჭირდება.
სინამდვილეში ეს არის
პარსინგის ბაგების მთელი კლასის მოცილება — დააწყვილეთ სქემით ვალიდაციასთან.

სამი წესი, რომელიც თან უნდა წაიღოთ

1კონკრეტული სჯობს მოხერხებულს. თქვით როლი, ფორმატი და ის, რა ქნას მოდელმა გაურკვევლობისას — მაგალითებზე ან მსჯელობაზე მხოლოდ მაშინ გადადით, თუ სხვა გზა არ არის.
2დაასტრუქტურეთ საზღვარი. როცა გამოსავალი კოდს კვებავს, მოითხოვეთ JSON ან ინსტრუმენტის გამოძახება და შეამოწმეთ — ტექსტიდან ამოთხრა არასდროს.
3გაზომეთ და ეჭვი გქონდეთ. პრომპტის ცვლილებები ფიქსირებულ ნაკრებზე შეამოწმეთ და ყოველი გარე შემავალი პოტენციურად მტრულად მიიჩნიეთ.

სად ჯდება ეს

„მოდელს ნაკლები დაუტოვეთ გამოსაცნობი — მერე კი დაამტკიცეთ, რომ გამოვიდა.“

ცოდნის შემოწმება

დაგამახსოვრდათ?

ხუთი სწრაფი შეკითხვა ტოკენებზე, ინსტრუქციებზე, few-shot-ზე, ინსტრუმენტების გამოძახებასა და prompt injection-ზე — მყისიერი უკუკავშირი, ავტორიზაციის გარეშე.

შეაფასეთ ეს დასტა
იყავით პირველი

ნავიგაცია ← → ღილაკებით ან სქროლით · უკან ბიბლიოთეკაში