ხმის გააქტიურებული ასისტენტი - MAX: 10 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

ჰეი ამ ინსტრუქციურში მე ვაპირებ ვისაუბრო იმაზე, თუ როგორ უნდა გავაკეთოთ ჩატ ბოტი MAX (სახელად ჩემი სახელი !!!)

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

ასე რომ ყველამ მხარი დამიჭირეთ ……

ჩემი პირველი ინსტრუქცია !!!!!!!

ნერვიულობის შეგრძნება იმის შესახებ, რაც მოხდება …………….

ნაბიჯი 1: იცოდე კონკურსის შესახებ

გამარჯობა ინჟინრებო და დიზაინერებო ……

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

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

VOICE გააქტიურებული გამოწვევა არის ჩემი პირველი პლატფორმა ინსტრუქციის წერის თვალსაზრისით.

პრიზებმა ძალიან გამახარა (დიახ !!! ძალიან ბევრი ……..).

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

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

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

ᲘᲡᲔ…

დავიწყოთ მოგზაურობა ………………

ნაბიჯი 2: სად ვიცოდი ნივთების შესახებ?

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

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

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

წიგნები, რომლებიც მოიძებნა, მოიცავს:

1. ხელოვნური ინტელექტი თანამედროვე მიდგომა
2. ხელოვნური. ინტელექტი. 21 -ე საუკუნეში. მე -2. გამოცემა
3. Ღრმა სწავლება

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

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

იმ დროს მე ასევე ვისწავლე სხვადასხვა პროგრამირების ენები (C ++, C, Python, Java…), რაც ძალიან საინტერესოა.

თემის შესახებ მეტის წაკითხვისას გავიგე ერთი მნიშვნელოვანი რამ ………………..

პროგრამირების ენები არის საფუძველი თითოეული მანქანების სწავლის პროცესისთვის

მანქანათმცოდნეობა არის AI გამოყენების პროცესი

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

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

შენც შეგიძლია ამის გაკეთება ……

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

ასე რომ თქვენ შეგიძლიათ დაათვალიეროთ ინტერნეტი და გაიგოთ მეტი თუ გსურთ ………

ნაბიჯი 3: დავიწყოთ

სანამ ინსტრუქციის წერას დავიწყებდი, ვფიქრობდი დამეწერა ის, რაც გასაგები იქნებოდა:

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

ასე რომ, მე ვფიქრობ, რომ მე ეს გავაკეთე ყოველგვარი შეცდომის გარეშე (იმედია).

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

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

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

ნაბიჯი 4: როგორ მუშაობს სინამდვილეში?

Ნაბიჯი 1:

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

Მაპატიეთ ……

დამავიწყდა მეთქვა,

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

1. როდესაც MAX– ს არ ესმის იმის შესახებ, რაზე ლაპარაკობს მომხმარებელი.

2. როდესაც მომხმარებელი იმეორებს საკუთარ თავს.

3. მისალოცი განცხადებებისათვის.

4. როდესაც მომხმარებელი არაფერს აკრიფებს და უბრალოდ აგრძელებს Enter- ის დაჭერას.

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

ნაბიჯი 2:

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

ნაბიჯი 3:

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

ნაბიჯი 4:

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

ნაბიჯი 5:

მე მჭირდება სიტყვების შეცვლა, ის თვითონ გააკეთებს ამას (მაგალითად, ჩემი გარდაქმნა შენსას და ა.

ნაბიჯი 5: მოგვწერეთ კოდი …………

მე ვიყენებ Turbo C IDE 3.0 რადგან ეს არის IDE [ინტეგრირებული განვითარების გარემო]

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

MAX ცნობს გარკვეულ საკვანძო სიტყვებს.

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

საკვანძო სიტყვა გამოყოფილია მონაცემთა ფაილში პასუხებისგან @ KWD @ ნიშნით.

ჟეტონი არის პროგრამირების ყველა ასპექტის უმცირესი ნაწილი.

ეს ნიშანი აღნიშნავს, რომ შემდეგი ხაზი არის საკვანძო სიტყვა და არა პასუხი.

@ KWD@ გამარჯობა

ᲒᲐᲛᲐᲠᲯᲝᲑᲐ, ᲠᲝᲒᲝᲠ ᲮᲐᲠ

ᲒᲐᲛᲐᲠᲯᲝᲑᲐ ᲫᲕᲘᲠᲤᲐᲡᲝ !

ᲙᲐᲠᲒᲐᲓ ᲕᲐᲠ

როგორ იყო თქვენი სამუშაო?

ᲠᲐᲛᲓᲔᲜᲘ ᲬᲚᲘᲡ ᲮᲐᲠ?

ᲛᲔ ᲕᲘᲖᲐᲛ

თქვენ ასე მოიქცევით. მეც მჯერა ამის…

თქვენ შეძლებთ ამის გაკეთებას?

დამიჯერებ?

დიახ

ᲓᲐᲠᲬᲛᲣᲜᲔᲑᲣᲚᲘ ᲮᲐᲠ ?

როგორ შეგიძლიათ ასე დარწმუნებული იყოთ?

არა

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

არასოდეს თქვა არა…

ᲐᲠᲐᲡᲝᲓᲔᲡ ᲗᲥᲕᲐ ᲐᲠᲐᲡᲝᲓᲔᲡ

არასოდეს იყოს უხეში

არასოდეს იყავი ამპარტავანი !!!!

არასოდეს თქვა, რომ ამის გაკეთება არ შემიძლია

არასოდეს იყო ოპტიმისტი

კომპიუტერული

მე ვიცი როგორ ვიმუშაო კომპიუტერზე.

თქვენ ამჟამად იყენებთ კომპიუტერს. მართალია?

მაგალითად, 'გამარჯობა', ზემოაღნიშნული ლექსიკონიდან, MAX გასცემს ერთ -ერთ შემდეგ პასუხს:

გამარჯობა, როგორ ხარ ძვირფასო!

ᲙᲐᲠᲒᲐᲓ ᲕᲐᲠ

როგორ იყო თქვენი სამუშაო?

ᲠᲐᲛᲓᲔᲜᲘ ᲬᲚᲘᲡ ᲮᲐᲠ?

ნაბიჯი 6: კლასები

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

ჩვენ ვქმნით ორ კლასს:

progstr - ეს გამოიყენება მომხმარებლის შეყვანის შესახებ ინფორმაციის შესანახად.

resp - ეს გამოიყენება ინფორმაციის შენახვისათვის სხვადასხვა პასუხების შესახებ

კლასის პროგრესი {

საჯარო:

დამხმარე მომხმარებლის [MAX_USER_INPUT];

char საკვანძო სიტყვა [30];

int გასაღები;

int keyno;

int nullip;

// კონსტრუქტორი

progstr () {keyno = -1; nullip = 0; გასაღები = 0;

}

} ip;

კლასის პასუხი

{

int tot_resp;

int last_resp;

char პასუხები [MAX_RESP_NO] [MAX_RESP_LEN];

ხმამაღალი სიტყვა [MAX_KWD_LEN];

საჯარო:

// კონსტრუქტორი

resp ()

{

tot_resp = 0;

last_resp = -1;

}

int getcount ()

{

დაბრუნება last_resp;

}

ბათილი დამატებული სიტყვა (სიმბოლო $ [MAX_KWD_LEN])

{

strcpy (სიტყვა, str);

}

char * getword ()

{

დაბრუნების სიტყვა;

}

void addresp (char str [MAX_RESP_LEN])

{

strcpy (პასუხები [++ last_resp], str);

}

// განსაზღვრულია მოგვიანებით

void display_resp (int num);

ბათილია quit_display_resp (int num);

};

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

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

keyno ინახავს შესაბამისი საკვანძო სიტყვის შესაბამის კლავიშს.

nullip მიუთითებს მისცა თუ არა მომხმარებელს რაიმე Null შეყვანა, ანუ ის უბრალოდ აჭერს Enter სხვას არაფრის გაკეთების გარეშე.

ახლა მოდით გადავიდეთ მეორე კლასზე, რესპ.

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

რეალურად პასუხები ინახება პასუხებში [MAX_RESP_NO] [MAX_RESP_LEN] და შესაბამისი საკვანძო სიტყვა ინახება მასივის სიტყვაში.

კონსტრუქტორი: ის გამოიყენება პასუხების საერთო რაოდენობის ინიციალიზაციისათვის 0. რატომ last_resp ინიციალიზირებულია -1 – ზე, ნათელი გახდება, როდესაც გადახედავთ add_resp ფუნქციას.

int getcount ():

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

ბათილი დამატება (char str [MAX_KWD_LEN]):

ეს გამოიყენება საკვანძო სიტყვის დასამატებლად.

char * getword ():

გამოიყენება საკვანძო სიტყვის დასაბრუნებლად კლასის კონკრეტული ობიექტისთვის resp.

void addresponse (…):

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

void display_resp (int):

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

void quit_display_resp (int):

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

ნაბიჯი 7: ფუნქციები

void initialize_global ()

{

strcpy (wordin [0], "ARE");

strcpy (wordout [0], "AM");

strcpy (wordin [1], "AM");

strcpy (wordout [1], "ARE");

strcpy (wordin [2], "WERE");

strcpy (wordout [2], "WAS");

strcpy (wordin [3], "WAS");

strcpy (wordout [3], "WERE");

strcpy (wordin [4], "შენ");

strcpy (wordout [4], "ME");

strcpy (wordin [5], "I");

strcpy (wordout [5], "YOU");

strcpy (wordin [6], "YOUR");

strcpy (wordout [6], "MY");

strcpy (wordin [7], "MY");

strcpy (wordout [7], "YOUR");

strcpy (wordin [8], "IVE");

strcpy (wordout [8], "YOU'VE");

strcpy (wordin [9], "YOU'VE");

strcpy (wordout [9], "IVE");

strcpy (wordin [10], "მე ვარ");

strcpy (wordout [10], "YOU'RE");

strcpy (wordin [11], "YOU'RE");

strcpy (wordout [11], "მე ვარ");

strcpy (wordin [12], "ME");

strcpy (wordout [12], "შენ");

strcpy (wordin [13], "შენ");

strcpy (wordout [13], "ME");

}

მოდით ახლა დავწეროთ ფუნქცია მომხმარებლისთვის პასუხების ჩვენებისათვის. For- ის მარყუჟში პირველი if განცხადება გამოიყენება მიზანმიმართული აკრეფის შეცდომის გამო, რათა ის უფრო ადამიანურად გამოიყურებოდეს;-). აკრეფის შეცდომისთვის შემთხვევით ირჩევა ერთი სიმბოლო. ცალკეული შემთხვევები განიხილება, როგორიცაა New Line და Backspace. (იფიქრეთ რატომ?). ახლა წარმოგიდგენთ რაღაც ახალს. განსაკუთრებული პერსონაჟი - *. ჩარ * წარმოადგენს ყველა ტექსტს, რომელიც აღმოჩენილია გამოვლენილი საკვანძო სიტყვის შემდეგ და ერთ – ერთი შემდეგი პუნქტუაციის ნიშნის წინ.

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

AMIT> შემიძლია ხვალ ინდოეთში წასვლა?

MAX> რა, თუ არ წახვალ ხვალ ხელახლა?

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

ᲨᲔᲛᲘᲫᲚᲘᲐ

რა მოხდება, თუ არ *

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

AMIT> შემიძლია გადავიდე საყიდლებზე?

MAX> რა, თუ არ მიდიხართ საყიდლებზე?

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

• ტექსტი სიტყვის გადატანამდე. (აქ, გადადით საყიდლებზე)
• გადატანილი საკვანძო სიტყვა. (აქ, შენი, ჩემი ნაცვლად)
• ტექსტი გადატანის შემდეგ საკვანძო სიტყვა. (აქ მე ?)

ნაბიჯი 8: საქმეების მოგვარება შესაძლებელია ………

ნაბიჯი 9: მოძებნეთ საკვანძო სიტყვა მომხმარებლის შეყვანისას

MAX_KEY მიუთითებს DAT ფაილში საკვანძო სიტყვების რაოდენობას.

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

ნაბიჯი 10: დასკვნა

Სულ ეს არის ………

შენ გააკეთე !!!!!!!

მე ვფიქრობ, რომ ყველამ ნათლად გაიგო ყველაფერი ……