ჯანდაცვისა და ხელოვნური ინტელექტის ტრანსფორმაცია

  • დაიწყეთ მოქმედი ხელოვნური ინტელექტით აღჭურვილი აპლიკაციის შექმნა კოდის გარეშე ხელსაწყოს გამოყენებით
  • გაიგეთ, როგორ ინახავს ვებ აპლიკაციები მონაცემებს ბრაუზერის მეხსიერების გამოყენებით
  • გაიგეთ, თუ როგორ შეიძლება ხელოვნური ინტელექტი იყოს მოაზროვნე პარტნიორი და არა აზროვნების შემცვლელი
  • გაიგეთ, როგორ დააკავშიროთ თქვენი პროექტი GitHub-თან, რათა თქვენი კოდი არასდროს დაიკარგოს
  • Github-ის კოდურ სივრცეებში აგებული მოქმედი Founder's Toolkit აპლიკაცია, რომელიც მოიცავს:
    • უკუკავშირის შენახვის მოდული დაინტერესებული მხარეების საწყისი შენიშვნების ორგანიზებისთვის
    • კონტრარის მოდული, რომელიც უზრუნველყოფს „მესამე ხმას“ და კითხვის ნიშნის ქვეშ აყენებს თქვენი პრობლემის განმარტებას
  • GitHub- ის საცავი თქვენი Founder's Toolkit პროექტით, სადაც თქვენი კოდი შეინახება
  • სტუდენტები იგებენ ხელოვნური ინტელექტის ძირითად კონცეფციებს და შეისწავლიან ხელოვნური ინტელექტის ინსტრუმენტებს სამეწარმეო განყოფილებებში (ხელოვნური ინტელექტის შესახებ ცნობიერება და სამეწარმეო აზროვნება).
  • წინასწარი კოდირების ან სწრაფი ინჟინერიის გამოცდილება არ არის საჭირო

ძიებიდან მოქმედებამდე

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

  • ეს პრობლემა მათთანაც ხომ არ არის აქტუალური?
  • რომელი ასპექტები მიაჩნიათ მათ ყველაზე მნიშვნელოვნად?
  • რა კითხვები ან შეშფოთება მოგდის თავში?
  • რა გამოგრჩათ ამ პრობლემაში?

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

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

ხელოვნური ინტელექტი, როგორც თქვენი აზროვნების პარტნიორი

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

პირველ ორ ტექნიკურ ერთეულში თქვენ შეისწავლით ხელოვნური ინტელექტის, როგორც მოაზროვნე პარტნიორის გამოყენებას Vibe კოდირების გამოყენებით . Vibe კოდირება გულისხმობს, რომ თქვენ აღწერთ იმას, რაც გსურთ მარტივი ენით, ხოლო ხელოვნური ინტელექტი თქვენთვის ფუნქციებს ქმნის. ამ გაკვეთილისთვის ჩვენ Vibe კოდს Github Copilot-ის გამოყენებით დავამუშავებთ Founder's Toolkit აპლიკაციის შესაქმნელად, რომელიც პოტენციურად სასარგებლო აპლიკაციაა თქვენივე პროექტის გასაძლიერებლად .

female engineer with code

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

Github-ის გამოყენების დაწყება

 მთელი ამ პროგრამისთვის თქვენ გამოიყენებთ GitHub-ს და ჩვენ გამოვიყენებთ მის მრავალ შესაძლებლობას, მათ შორის შენახვის შესაძლებლობებს.

კოდის მართვის ძირითადი შემთხვევის გარდა, Github ასევე გთავაზობთ AI Agent Github Copilot-ს და ღრუბლოვანი კოდირების პლატფორმა Codespaces-ს . ჩვენ გამოვიყენებთ Codespaces-ს , რომელიც თქვენს ბრაუზერში გაშვებული განვითარების გარემოა. თქვენ შეძლებთ Copilot-ს ბუნებრივ ენაზე მისცეთ ინსტრუქცია, თუ რა გსურთ შექმნათ და ნახოთ Codespaces- ში აგებული კოდი, რათა გაიგოთ, გამოსცადოთ და საბოლოოდ განათავსოთ იგი.

მათი აღწერა აქ შეგვიძლია:

  • GitHub => თქვენი პროექტის კოდის მთავარი გვერდია, მაგალითად Google Drive
  • კოდური სივრცეები => თქვენი სამუშაო სივრცე Google Docs-ის მსგავსია, მაგრამ აპლიკაციების შესაქმნელად
  • Copilot => თქვენი ხელოვნური ინტელექტის კოდირების პარტნიორი, რომელიც თქვენს იდეებს მოქმედ კოდად აქცევს

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

დასაწყებად:

  1. თუ უკვე გაქვთ Github-ის ანგარიში, შეგიძლიათ გამოტოვოთ ეს ნაბიჯები. წინააღმდეგ შემთხვევაში, გადადით github.com- ზე. 
  2. დააჭირეთ ღილაკს „რეგისტრაცია“ და მიჰყევით ნაბიჯებს (ეს უფასოა და დაახლოებით 2 წუთი სჭირდება)
  3. გამოიყენეთ ელექტრონული ფოსტის მისამართი, რომელსაც რეგულარულად ამოწმებთ და გირჩევთ, აირჩიოთ პროფესიონალური მომხმარებლის სახელი, რადგან ეს მომხმარებლის სახელი იქნება ის, თუ როგორ გამოიყურებით სხვა დეველოპერებთან თანამშრომლობის დროს.

თუ თქვენ ხართ რეგისტრირებული სტუდენტი სკოლაში ან უნივერსიტეტში, დარეგისტრირდით Github Education-ის სტუდენტურ ანგარიშზე. Student Developer Pack-ით თქვენ მიიღებთ უფასო Github Pro ანგარიშს, შეუზღუდავ საცავებს და მეტ Copilot კრედიტს. ასევე არსებობს მესამე მხარის უფასო დეველოპერის ხელსაწყოები, რომლებზეც წვდომა გექნებათ. 

თქვენი გამოხმაურების შენახვა

მზად გქონდეთ მე-2 ერთეულის: მეწარმეობის აზროვნების სამუშაო ფურცელი და ინტერვიუს ჩანაწერები.

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

აქტივობა 1

დაიწყეთ თქვენი განვითარების გარემო

სავარაუდო დრო: 15 წუთი

საცავი (ან „საცავი“) GitHub-ზე თქვენი პროექტის ცენტრალური ადგილია.

  1. მოდით შევქმნათ ის „საცავის შექმნა“ ან „ახალი“ ღილაკზე დაწკაპუნებით. 
  2. დაამატეთ რეპოს სახელი და აღწერა.
    1. სახელის ნაცვლად შეგიძლიათ მიანიჭოთ მას რაღაც, მაგალითად, AIVA Founders Toolkit, მაგრამ ის უნიკალური უნდა იყოს, ამიტომ დაამატეთ თქვენთვის იდენტიფიკატორი.
    2. აღწერილობისთვის საკმარისი იქნება AIVA-ს დამფუძნებლის ინსტრუმენტარიუმის აპლიკაცია .
  3. კონფიგურაციაში აირჩიეთ შემდეგი:
    1. ხილვადობა = პირადი, რათა უზრუნველყოთ, რომ რეპოზიტორის ნახვა მხოლოდ თქვენ შეგიძლიათ
    2. Readme = True, რათა Github-მა ავტომატურად შექმნას ნაგულისხმევი ფაილი, რომელიც გამოყენებული იქნება დოკუმენტაციისთვის.
    3. დაამატეთ .gitignore ფაილი = Node
    4. ლიცენზიის დამატება = MIT ლიცენზია

ამ დეტალების მნიშვნელობას შემდგომ თავებში განვიხილავთ. თუ რომელიმე მათგანი გამოგრჩათ, არ ინერვიულოთ, რადგან მოგვიანებით მათი ხელით დამატება შეგვიძლია.

create repo screenshot for github
  1. ხელმისაწვდომი ფილიალების სიის საჩვენებლად დააწკაპუნეთ თქვენი რეპოს ზედა მარცხენა კუთხეში არსებულ „ძირითად“ ფილიალზე.
  2. აირჩიეთ „ფილიალებების ნახვა“ და შემდეგ შექმენით ახალი ფილიალი .
  3. ახალ ფილიალს სახელი დაარქვით. ეს მხოლოდ თქვენი გამოყენებისთვისაა, ასე რომ, შეგიძლიათ ნებისმიერი სახელი დაარქვათ, მაგრამ სასარგებლოა მისთვის იდენტიფიცირებადი სახელის მინიჭება, მაგალითად, tech-unit-1 .

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

create branch screenshot
screenshot naming a branch

ჩვენ შევქმენით განშტოება, სადაც კოდის ვერსია შეინახება და შეინახება. ახლა გვინდა კოდირების დაწყება განვითარების გარემოში Codespaces-ის გამოყენებით.

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

დაინახავთ, რომ თქვენი ბრაუზერი გახსნის ფანჯარას, რომელიც წარმოადგენს კოდირების შემუშავების ინსტრუმენტს, რომელიც გამოიყურება და მოქმედებს როგორც Visual Studio Code . ეს არის თქვენი შემუშავების სამუშაო სივრცე, სადაც ჩვენ დავიწყებთ კოდირებას. 

როგორც კი Codespaces ჩაიტვირთება, შეამჩნევთ, რომ მას მრავალი პანელი აქვს:

  1. ფაილების მკვლევარი: თქვენი პროექტის ფაილები
  2. რედაქტორი: სადაც შეგიძლიათ ფაილების წინასწარი გადახედვა და რედაქტირება
  3. ტერმინალი: სადაც ბრძანებებს ასრულებთ
  4. Github Copilot: სადაც თქვენ ხელოვნურ ინტელექტს ასწავლით, რათა დაგეხმაროთ მშენებლობაში
  5. ზედა პანელი: მენიუს ზოლით და ძიებით

აღსანიშნავია:

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

ახლა, როდესაც Codespaces-ში თქვენი განვითარების გარემო დაყენებულია, მზად ხართ, 10 წუთზე ნაკლებ დროში დაიწყოთ მოქმედი აპლიკაციის შექმნა.

სწრაფი ინჟინერიის საფუძვლები

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

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

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

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

მაგრამ არსებითად, ტექნიკის უმეტესობა მოიცავს:

კონტექსტის პარამეტრი

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

მაგალითად

კონტექსტის გარეშე:
„მომეცით ჩემი იდეის შესახებ გამოხმაურება.“

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

გამომავალი სტრუქტურა

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

მაგალითად

კონტექსტის გარეშე:
„ჩამოთვალეთ რამდენიმე გამოწვევა.“

კონტექსტით:
„ჩამოთვალეთ ზუსტად 3 გამოწვევა, თითოეული ერთი წინადადების სახით, 20 სიტყვაზე ნაკლები.“

ტონის კონტროლი

უხელმძღვანელეთ ხელოვნური ინტელექტის კომუნიკაციის წესს. არის ეს მწვრთნელი? კრიტიკოსი? მასწავლებელი?

მაგალითად

კონტექსტის გარეშე:
„მითხარი, რა არის არასწორი ჩემს იდეაში.“

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

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

აქტივობა 2

შექმენით უკუკავშირის შენახვის შესაძლებლობა

სავარაუდო დრო: 30 წუთი

თუ ის უკვე გახსნილი გაქვთ, შეგიძლიათ გამოტოვოთ ეს ნაბიჯი. წინააღმდეგ შემთხვევაში,

  1. შესვლა Github-ში.
  2. დააწკაპუნეთ ზედა მარცხენა კუთხეში მდებარე ჰამბურგერის მენიუზე და ჩამოსაშლელი მენიუდან აირჩიეთ „კოდური სივრცეები“.
  3. როდესაც Codespaces ფანჯარა გაიხსნება, მის ხელახლა გასახსნელად დააწკაპუნეთ Github-ის მიერ თქვენს კოდის სივრცეს შემთხვევით სახელზე. 

დაიწყეთ ჩატის ფანჯარაში ქვემოთ მოცემული ამ ძირითადი ტექსტური ინსტრუქციით. 

ეს არის მოთხოვნა, რომელსაც თქვენ მისცემთ Github Copilot-ს; ის მიიღებს თქვენს ინსტრუქციებს და გააკეთებს დამატებით ვარაუდებს ნებისმიერი ცარიელი ადგილის შესავსებად. 

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

შექმენით მარტივი აპლიკაცია, რომელიც დაეხმარება მეწარმეებს ჩემი ბიზნეს იდეებისთვის 2 დაინტერესებული მხარისგან უკუკავშირის შეგროვებაში.
– სათაური უნდა იყოს „AI Founder's Toolkit“.
– მომხმარებლებმა უნდა შეიყვანონ მათ მიერ გადაჭრილი პრობლემა და შემდეგ მიიღონ 2 ადამიანის უკუკავშირი ამ პრობლემასთან დაკავშირებით.

first prompt to copilot

რჩევა:

 GitHub Copilot-ში არსებული ყველა უახლესი მოდელისა და შესაძლებლობის თვალყურის დევნება შეუძლებელია. 2025 წლის 7 იანვრის მდგომარეობით, GitHub-ს აქვს სხვადასხვა LLM მოდელი, მაგრამ მოდელის შერჩევა ნაგულისხმევად არის დაყენებული „ავტომატურზე“. ეს მათ აძლევს მოქნილობას, აირჩიონ მოდელი, რომელიც მათთვის ყველაზე მოსახერხებელია და შესაძლოა ყველაზე შესაფერისი იყოს კონკრეტული ამოცანისთვის. გირჩევთ, ჩართოთ მოდელის შერჩევა, რათა გქონდეთ არჩევანი და აირჩიოთ თქვენთვის სასურველი მოდელი. თქვენ უნდა დაეთანხმოთ მათ პირობებს „ხელოვნური ინტელექტის ფუნქციების გამოყენებაზე“ დაწკაპუნებით, რაც ჩართავს მოდელის არჩევას. მიუხედავად იმისა, რომ ეს არ არის სავალდებულო (დამაბნეველი ღილაკის ტექსტის მიუხედავად) მათი ხელოვნური ინტელექტის ფუნქციების გამოსაყენებლად, მოდელის არჩევის დაშვება აუცილებელია.

Copilot შექმნის თქვენს აპლიკაციას და გაჩვენებთ პროგრესს. 

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

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

ხელოვნური ინტელექტი სხვადასხვა ვარაუდს აკეთებს, მაგალითად, ვებ-აპლიკაციის შექმნის არჩევას ისეთი საერთო ჩარჩოს გამოყენებით, როგორიცაა HTML, CSS და Javascript. ის ასევე შეავსებს თქვენს მიერ არ მითითებულ სტილისტურ დეტალებს, როგორიცაა ფერების, შრიფტების და განლაგების არჩევა. კოდის გაგება საჭირო არ არის; უბრალოდ უყურეთ მის მუშაობას და დაიწყეთ იდეების მიღება, თუ კიდევ რა შეგიძლიათ დაამატოთ მოგვიანებით.

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

მნიშვნელოვანი რჩევა:

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

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

codespaces, allowing to run in the browser

როგორც კი Copilot აპლიკაციის კოდირებას დაასრულებს, შეგიძლიათ დაიწყოთ მისი ტესტირება შემდეგი გზებით:

  1. აპლიკაციის გასაშვებად , ეკრანის ქვედა ნაწილში, ტერმინალის პანელში აკრიფეთ „ python3 -m http.server 8000“. ეს თქვენი სასტარტო აპლიკაციის გასაშვებად უმარტივესი გზაა.
how to run app from terminal window
  1. გაიხსნება ბრაუზერის ახალი ჩანართი, სადაც თქვენი აპლიკაცია გაშვებული იქნება.
  2. შეგიძლიათ შეიყვანოთ თქვენი პრობლემის განცხადება.
  3. დაამატეთ თქვენი ყველა საწყისი მეგობრისა და ოჯახის წევრის უკუკავშირი „მეწარმეული აზროვნების“ სამუშაო ფურცელიდან.
  4. დააწკაპუნეთ გამოხმაურების შესანახად.
  5. დარწმუნდით, რომ ინფორმაცია გამომავალი არეალში ჩანს.

პრობლემების მოგვარება:

თუ თქვენი აპლიკაცია არ ჩანს:

  • შეგიძლიათ Copilot-ს ჰკითხოთ: „როგორ გავუშვა ჩემი აპლიკაცია?“ ან „დამეხმარეთ შეცდომების გამართვაში, თუ რატომ ვერ ვხედავ ფორმას და ვერ ვპოულობ გამოვლენილ პრობლემებს“. ეს არის ის, რასაც ჩვენ ხელოვნური ინტელექტის დახმარებით გამართვას ვუწოდებთ , რომელსაც შემდგომ თავებში შეისწავლით.

თუ თქვენი აპლიკაცია არ იტვირთება:

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

თუ გამომავალი არ ემთხვევა თქვენს მოლოდინს:

  • არა უშავს. კორექტირების შეტანას მოგვიანებით ისწავლით.

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

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

დააკოპირეთ და ჩასვით ქვემოთ მოცემული მოთხოვნა ჩატის მოთხოვნაში Github Copilot პანელში, თქვენი Codespaces ეკრანის მარჯვენა მხარეს. 

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

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

აპლიკაციას უნდა ჰქონდეს:

– სათაური ზედა ნაწილში: „ხელოვნური ინტელექტის დამფუძნებლების ინსტრუმენტების ნაკრები“

– ქვესათაური: „დაიწყეთ ჩემს პრობლემასთან დაკავშირებით გამოხმაურების შეგროვება“.

– ტექსტური არე, სადაც შემიძლია შევიყვანო ჩემი პრობლემა და აღვწერო ჩემი ბიზნეს პრობლემა, რომლის მოგვარებაც მსურს

– „დაინტერესებული მხარე 1“-ის განყოფილება ტექსტური არეებით: 

  1. ეს პრობლემა მათთანაც ხომ არ არის აქტუალური?
  2. რომელი ასპექტები მიაჩნიათ მათ ყველაზე მნიშვნელოვნად?
  3. რა კითხვები ან შეშფოთება მოგდის თავში?
  4. რა გამოგრჩათ ამ პრობლემაში?

– „დაინტერესებული მხარე 2“-ის განყოფილება იგივე ოთხი ტექსტური არეთი 

– ღილაკი სახელწოდებით „პრობლემისა და გამოხმაურების შენახვა“

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

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

გახსოვდეთ, თუ აპლიკაციის გაშვებისას პრობლემებს წააწყდებით ან გამომავალი ინფორმაცია არასწორად გამოიყურება, სთხოვეთ Copilot-ს დახმარება ამის გარკვევაში.

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

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

ვალდებულების აღებისა და ძალისხმევისთვის:

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

ჩვენთვის, ხელოვნურმა ინტელექტმა შექმნა კარგი commit შეტყობინება:

codespaces commit window

3. შესაძლოა მიიღოთ შეტყობინება: „დადასტურებისთვის ეტაპობრივი ცვლილებები არ არის“. თუ ასეა, დადასტურებისთვის დააჭირეთ ღილაკს „დიახ“ .

4. დააწკაპუნეთ „ცვლილებების სინქრონიზაციაზე“ Codepace პლატფორმის Github-თან სინქრონიზაციისთვის.

5. დაბრუნდით Github-ში, თქვენს საცავში და ფილიალში, რათა შეამოწმოთ, რომ ფაილები იქ ჩანს. მასში უნდა იყოს ნაჩვენები ყველა ფაილი, რომელიც შეიქმნა, შეიცვალა ან წაიშალა. აქ არის გარკვეული გამონაკლისები (მინიშნება: ფაილები ჩამოთვლილია gitignore ფაილში). 

ეს ნაბიჯი უზრუნველყოფს, რომ თქვენი ცვლილებები შენახული იქნება ფილიალში და ამცირებს შესრულებული სამუშაოს დაკარგვის რისკს, თუ თქვენს Codespace გარემოში რამე მოხდება. შემდგომ მოდულებში თქვენ შეისწავლით თუ რას წარმოადგენს ეს „Git“ ბრძანებები.

თქვენ ახლახან შექმენით აპლიკაცია!

დაუთმეთ ერთი წუთით იმის დაფასებას, რაც ახლახან გააკეთეთ. 

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

აღსანიშნავია:

  1. თქვენ კოდი არ დაგიწერიათ. თქვენ უბრალოდ აღწერეთ, რა გინდოდათ.
  2. ხელოვნურმა ინტელექტმა დაშვებები გამოიყენა თქვენს მიერ არ მითითებული დეტალების შესავსებად (ფერები, განლაგება, ჩანაცვლების ველის ტექსტი და ა.შ.).

ჩვენს შემთხვევაში, მას დაემატა რამდენიმე რამ, რაც ჩვენს ინსტრუქციებში არ იყო მითითებული, მაგალითად:

  • „ადგილმდებარეობის ველების ტექსტები“ თითოეული ტექსტის ჩანაწერისთვის
  • გამოხმაურების რედაქტირების ღილაკი
  • წარმატების შეტყობინება გამოხმაურების გაგზავნის შემდეგ 

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

მონაცემების შენახვა

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

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

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

როგორ ინახავს ვებ აპლიკაციები მონაცემებს

როდესაც ვებ-აპლიკაციას ქმნით (მაგალითად, Google AI Studio-ს მიერ შექმნილს), უსაფრთხოების მიზნით, ფაილების პირდაპირ მომხმარებლის კომპიუტერში შენახვა შეუძლებელია. ამის ნაცვლად, ვებ-აპლიკაციები იყენებენ ბრაუზერის მეხსიერებას , ჩაშენებულ ფუნქციას, რომელიც ვებსაიტებს საშუალებას აძლევს, მონაცემები ლოკალურად შეინახონ თქვენს ბრაუზერში.

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

  1. რა : ბრაუზერის მეხსიერების ტიპები
  2. როგორ : როგორ იწერება მონაცემები შესანახად
  3. WHERE : სადაც მონაცემები ინახება

რა არის ლოკალური ბრაუზერის საცავი? 

ბრაუზერის საცავის ორი ძირითადი ტიპი არსებობს:

  1. ლოკალური საცავი : მონაცემები შენახულია ბრაუზერის დახურვის შემდეგაც კი
  2. სესიის შენახვა : მონაცემები ქრება ბრაუზერის ჩანართის დახურვისას

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

როგორ მუშაობს ეს?

ბრაუზერის საცავი მონაცემებს ინახავს გასაღები-მნიშვნელობის წყვილების სახით, ლექსიკონის მსგავსად, სადაც მონაცემთა თითოეულ ნაწილს აქვს სახელი (გასაღები) და მნიშვნელობა.

მაგალითად:

  • გასაღები => პრობლემა
  • ღირებულება => „ფერმერებს არ შეუძლიათ თავიანთი საქონლის გაყიდვა“

როგორც გასაღები, ასევე მნიშვნელობა უნდა იყოს ტექსტი (სტრიქონები) და ინახება JSON ფორმატში . JSON (JavaScript Object Notation) არის სტანდარტული ფორმატი მონაცემების წარმოსადგენად, რომლის წაკითხვაც მარტივია როგორც ადამიანებისთვის, ასევე კომპიუტერებისთვის.

მთელი JSON სტრუქტურა ინახება localStorage-ში ერთი სტრიქონის მნიშვნელობის სახით, შემდგომი ჩადგმით, თუ არსებობს მეტი გასაღებ-მნიშვნელობის წყვილი.

მაგალითად, პრობლემისა და 2 ადამიანისგან მიღებული გამოხმაურების შენახვამ შეიძლება წარმოქმნას შემდეგი JSON სტრიქონი:

				
					{
    "problem": "Farmers from local rural communities can't sell their farming goods",
    "feedback": [
        {"person": "J Smith", "resonates": "Yes, sees it daily"},
        {"person": "M Jones", "resonates": "Note sure it's a big issue"}
    ]
}

სად ინახება მონაცემები?

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

სინამდვილეში, მისი ნახვა ბრაუზერში შეგიძლიათ. აი, როგორ შეგიძლიათ მისი ნახვა Chrome- ის ბრაუზერის გამოყენებით.

  1. დააწკაპუნეთ მაუსის მარჯვენა ღილაკით ნებისმიერ ადგილას ნებისმიერ ადგილას და აირჩიეთ „შემოწმება“ (ან დააჭირეთ F12)
  2. დააჭირეთ ღილაკს „აპლიკაცია“ (Chrome-ში)
  3. გვერდითა ზოლში მოძებნეთ „ადგილობრივი საცავი “
  4. დააწკაპუნეთ მასზე თქვენი შენახული მონაცემების სანახავად (შესაძლოა ჯერ არაფერი გქონდეთ შენახული, ამიტომ შესაძლოა ცარიელი იყოს)

შეზღუდვა: 

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

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

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

  • მომხმარებლის პარამეტრების შენახვა
  • მიმდინარე სამუშაოების შენახვა, რათა მომხმარებლებმა არ დაკარგონ მონაცემები
  • მოწყობილობებს შორის მონაცემების სინქრონიზაცია (მოგვიანებით მოწყობილობებში)
  • გარე სერვისებთან და API-ებთან დაკავშირება
აქტივობა 3

ლოკალური მეხსიერების დამატება

სავარაუდო დრო: 20 წუთი

გადადით Github.com-ზე, გადადით თქვენს კოდურ სივრცეებზე და გახსენით კოდურ სივრცეები თქვენი Founder's Toolkit აპლიკაციისთვის.

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

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

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

– მომხმარებლის მიერ ინფორმაციის შენახვის შემდეგ, შეყვანილი ჩანაწერი(ები) უნდა გამოჩნდეს შეყვანის ფორმის ქვემოთ

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

  1. შეიყვანეთ თქვენი პრობლემა და გამოხმაურება თითოეული დაინტერესებული მხარისთვის
  2. დააწკაპუნეთ პრობლემისა და გამოხმაურების შესანახად
  3. განაახლეთ გვერდი (F5-ის დაჭერით, ბრაუზერის განახლების ღილაკზე დაწკაპუნებით ან გადახედვის პანელის ზედა მარჯვენა კუთხეში, Codespaces-ში აპლიკაციის გადატვირთვის ღილაკზე დაწკაპუნებით)
  4. დაადასტურეთ, რომ თქვენს მიერ წარდგენილი მონაცემები გამოჩნდება
  5. თუ ის არ გამოჩნდება, გამოიყენეთ Copilot, რათა დაგეხმაროთ პრობლემის გარკვევასა და მის ამუშავებაში.

დასრულების შემდეგ, თქვენ უნდა შეძლოთ ნახოთ, რა დანერგა Copilot-მა. 

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

  • განახლდა script.js ფაილი
  • ფორმის შეყვანები გადაყვანილია JSON ფორმატის სტრიქონად შესაბამისი გასაღებებით და დაემატა დროის ნიშნული.
  • JSON შენახულია თქვენი ბრაუზერის ლოკალურ მეხსიერებაში
  • იღებს მონაცემებს აპლიკაციის ჩატვირთვისას

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

local storage view in developer tools

აქ მოცემულია შექმნილი JSON-ის უფრო სუფთა ხედი. 

				
					[
    {
    "problem": "Farmers in rural Chiapas, Mexico struggle to sell their farming products at fair prices",
    "stakeholder1": {
        "resonate": "Yes — my neighbors grow amazing coffee and honey but only sell to the same buyer who pays very little.",
        "aspects": "Finding buyers who pay fairly and on time, not months later.",
        "concerns": "How would farmers get their products to buyers because the roads here are difficult.",
        "missing": "Many farmers don't have smartphones so how would they use an app?"
      },
      "stakeholder2": {
        "resonate": "Absolutely. I see farmers walk hours to the market and come back with unsold vegetables.",
        "aspects": "Knowing ahead of time if someone will actually buy, so the trip isn't wasted.",
        "concerns": "Internet is unreliable here — sometimes no signal for days. Would an app still work?",
        "missing": "Trust and safety is everything. Here carrying cash can be dangerous."
      },
      "timestamp": "2026-01-07T23:08:35.579Z"
    },
    {
        "problemStatement": "farmers selling their products",
        "stakeholder1": {
            "resonance": "Yes — my neighbors grow amazing coffee and honey but only sell to the same buyer who pays very little.",
            "importantAspects": "Finding buyers who pay fairly and on time, not months later.",
            "questionsConcerns": "How would farmers get their products to buyers because the roads here are difficult.",
            "missingPoints": "Many farmers don’t have smartphones so how would they use an app?"
        },
        "stakeholder2": {
            "resonance": "Absolutely. I see farmers walk hours to the market and come back with unsold vegetables.",
            "importantAspects": "Knowing ahead of time if someone will actually buy, so the trip isn't wasted.",
            "questionsConcerns": "Internet is unreliable here — sometimes no signal for days. Would an app still work?",
            "missingPoints": "Trust and safety is everything. Here carrying cash can be dangerous."
        },
        "timestamp": "2026-01-03T19:27:37.272Z"
    }
]
  1. გადადით წყაროს კონტროლზე მარცხენა პანელში.
  2. შეიყვანეთ ცვლილებების აღწერა და დააჭირეთ ღილაკს „დადასტურება“, რათა ეს ცვლილებები თქვენს საცავში დააფიქსიროთ. 
  3. ცვლილებების სინქრონიზაცია. 

ახლა თქვენ გაქვთ საშუალება, შეიყვანოთ და შეინახოთ მომხმარებლის გამოხმაურება თქვენი პროექტისთვის. ეს სასარგებლო იქნება თქვენი პროექტის წინსვლისას. ჩვენ გავაგრძელებთ ამ Founder's Toolkit აპლიკაციის შექმნას შემდგომ გაკვეთილებში, რათა ხელოვნური ინტელექტის გამოყენებით შექმნის მეტი უნარი შევიძინოთ.

ბრაუზერის მეხსიერების შეზღუდვები

ბრაუზერის ლოკალური შენახვის შესახებ რამდენიმე მნიშვნელოვანი რამ უნდა გესმოდეთ:

რას აკეთებს კარგად

  • ინახავს მონაცემებს გვერდის განახლებებს შორის
  • სწრაფი და მარტივი
  • მუშაობს ოფლაინში
  • ანგარიში/შესვლა საჭირო არ არის

რას არ აკეთებს 

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

ანარეკლი

თქვენ საკმაოდ დიდი დრო დაუთმეთ ვიბ-კოდირებას, რათა შეექმნათ Founder's Toolkit აპლიკაცია, რომელიც სხვადასხვა ინფორმაციის შენახვასა და სინთეზირებას მოახდენდა. აქ მოცემულია რამდენიმე კითხვა, რომლებზეც უნდა დაფიქრდეთ:

Sunset and reflection over lake
01

ხელოვნური ინტელექტის კოდირების პარტნიორი
რამემ გაგაკვირვათ, როდესაც ამ მოქმედ აპლიკაციას ვიბრაციული კოდით წერდით?
02

კოდური სივრცეები
როგორია თქვენი კოდის GitHub კოდურ სივრცეში გაშვება? როგორ შეიძლება ამან შეცვალოს თქვენი მუშაობის წესი?
03

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

ძირითადი ტერმინები

  • GitHub: პლატფორმა, რომელიც კოდის შენახვისა და გაზიარებისთვის შეიქმნა.
  • კოდური სივრცეები: GitHub პლატფორმის შესაძლებლობა, რომელიც საშუალებას აძლევს განვითარების გარემოს, რომელიც თქვენს ბრაუზერში VS Code-ს მართავს, თქვენი კოდი გაუშვას.
  • GitHub Copilot: ხელოვნური ინტელექტის კოდირების ასისტენტი, რომელიც ბუნებრივი ენის აღწერილობების საფუძველზე ქმნის კოდს, რომელსაც LLM-ები ამუშავებენ.
  • საცავი (Repo): თქვენი პროექტის საქაღალდე GitHub-ზე, რომელიც შეიცავს თქვენი ყველა კოდის ფაილს და ორგანიზებულია სხვადასხვა ფილიალში, სადაც შეგიძლიათ ითანამშრომლოთ სხვა დეველოპერებთან.
  •  
  • დამფუძნებლის ინსტრუმენტარიუმი : აპლიკაცია, რომელიც სტუდენტების განვითარებასთან ერთად ტექნიკურ ერთეულებში განვითარდება.
  • ვიბრაციული კოდირება: მარტივი ენით იმის აღწერა, რაც გსურთ და ხელოვნურ ინტელექტს კოდის გენერირების საშუალება. ასევე ცნობილია, როგორც „კოდის გარეშე შემუშავება“.
  • ბრაუზერის საცავი: ჩაშენებული ფუნქცია, რომელიც საშუალებას აძლევს ვებ აპლიკაციებს შეინახონ მონაცემები ლოკალურად თქვენს ბრაუზერში, სერვერის საჭიროების გარეშე.
  • localStorage: ბრაუზერის მეხსიერების ტიპი, რომელიც ბრაუზერის დახურვის შემდეგაც კი რჩება. თქვენი მონაცემები რჩება მანამ, სანამ მათ არ წაშლით.
  • sessionStorage: ბრაუზერის მეხსიერების ტიპი, რომელიც ინახება ერთი გვერდის სესიის განმავლობაში. მონაცემები იწმინდება ჩანართის ან ბრაუზერის ფანჯრის დახურვისას.
  • JSON (JavaScript ობიექტის ნოტაცია): მონაცემთა ორგანიზების სტანდარტული ფორმატი, რომელიც იკითხება როგორც ადამიანების, ასევე კომპიუტერების მიერ. წარმოითქმის როგორც „ჯეისონი“.
  • გასაღები-მნიშვნელობის წყვილი: მონაცემების შენახვის გზა, სადაც თითოეულ ნაწილს აქვს სახელი (გასაღები) და მნიშვნელობა. როგორც საქაღალდეზე არსებული იარლიყი.
  • სწრაფი ინჟინერია: მკაფიო, კონკრეტული ინსტრუქციების დაწერის პრაქტიკა, რომელიც ხელოვნურ ინტელექტს სასარგებლო შედეგების მიღებაში ეხმარება.
  • არადეტერმინისტული: ხელოვნური ინტელექტი არ წარმოქმნის იდენტურ შედეგებს ერთი და იგივე შემავალი სიგნალებისთვის. თითოეული პასუხი შეიძლება ოდნავ განსხვავდებოდეს.

დამატებითი რესურსები

დანართი

სწრაფი ინჟინერია

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

ის ძირითადად გამოიყენება ტექსტზე დაფუძნებულ ხელოვნურ ინტელექტსა და ბუნებრივი ენის დამუშავების (NLP) ამოცანებში.

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

რა არის მოთხოვნილებები?

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

კარგი მინიშნებები უნდა

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

რატომ არის მნიშვნელოვანი სწრაფი ინჟინერია?

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

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

ტექნიკები

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

  1. იყავით კონკრეტული
  2. კონტექსტის მიწოდება
  3. მოიყვანეთ მაგალითები 
    • ერთჯერადი მინიშნება – მოიყვანეთ შეყვანა/გამოყვანის მაგალითი.
      • მაგალითი:
        „ტექსტი: 45 წლის ჯეინ სმიტი ლონდონში პროგრამული უზრუნველყოფის დეველოპერია.“
         JSON: 'სახელი': 'ჯეინ სმიტი', 'ასაკი': 45, 'როლი': 'ვებ დეველოპერი', 'ქალაქი': 'ლონდონი'
         ტექსტი: 29 წლის ჯონ დოუ სტუდენტია პარიზში.
         JSON: [ახალი შეყვანა აქ]
    • მცირედი სტიმული – მოიყვანეთ რამდენიმე მაგალითი, რათა LLM-ის სტუდენტებს დაეხმაროთ ამ ნიმუშის შესწავლაში.
      • სასარგებლოა უფრო რთული ამოცანებისთვის, სადაც მრავალი მაგალითი შეიძლება დაგეხმაროთ
  4. ფორმატის მითითება
  5. იტერაციულად დახვეწა
  • აზროვნების ჯაჭვი - სთხოვეთ LLM-ს, აჩვენოს თავისი მსჯელობა და/ან ნაბიჯები.
  • როლის განაწილება - მაგ. „თქვენ ექსპერტი ხართ…“
  • უარყოფითი მინიშნება - მაგ. „არ ჩართოთ…“
  • ტემპერატურის კონტროლი - მაგ. კრეატიულობა vs თანმიმდევრულობა
  • თვითთანმიმდევრულობა - მოითხოვეთ მრავალი შედეგი და შემდეგ სთხოვეთ სამართლის მაგისტრს, აირჩიოს „საუკეთესო“ შედეგი.
  • ფიქრების ხე - სთხოვს LLM-ს, შეისწავლოს მსჯელობის მრავალი დარგი, რათა გადაწყვიტოს საბოლოო პასუხი.
  • გაძლიერებული გენერაციის მოძიება (RAG) – LLM-ს სთხოვს გამოიყენოს გარე ინფორმაცია უკეთესი კონტექსტის მისაცემად.

აქ მოცემულია ინსპირაციის ტექნიკის სრული სია: https://www.ibm.com/think/topics/prompt-engineering-techniques

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