განმეორებადი ნერვული ქსელები

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

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

$X_0,\dots,X_n$ ნიშნების შეყვანის თანმიმდევრობის გათვალისწინებით, RNN ქმნის ნერვული ქსელის ბლოკების თანმიმდევრობას და ავარჯიშებს ამ თანმიმდევრობას ბოლოდან ბოლომდე უკანა გამრავლების გამოყენებით. თითოეული ქსელის ბლოკი იღებს $(X_i,S_i)$ წყვილს, როგორც შეყვანას და შედეგად წარმოქმნის $S_{i+1}$-ს. საბოლოო მდგომარეობა $S_n$ ან გამომავალი $X_n$ გადადის წრფივ კლასიფიკატორში შედეგის მისაღებად. ქსელის ყველა ბლოკი იზიარებს ერთსა და იმავე წონას და წვრთნიან ბოლომდე გავრცელების ერთი საშვის გამოყენებით.

იმის გამო, რომ $S_0,\dots,S_n$ მდგომარეობის ვექტორები გადადის ქსელში, მას შეუძლია ისწავლოს თანმიმდევრული დამოკიდებულებები სიტყვებს შორის. მაგალითად, როდესაც სიტყვა not გამოჩნდება სადმე მიმდევრობაში, მას შეუძლია ისწავლოს გარკვეული ელემენტების უარყოფა მდგომარეობის ვექტორში, რაც გამოიწვევს უარყოფას.

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

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

მარტივი RNN კლასიფიკატორი

მარტივი RNN-ის შემთხვევაში, ყოველი განმეორებადი ერთეული არის მარტივი წრფივი ქსელი, რომელიც იღებს შეერთებულ შეყვანის ვექტორს და მდგომარეობის ვექტორს და აწარმოებს ახალ მდგომარეობის ვექტორს. PyTorch წარმოადგენს ამ ერთეულს RNNCell კლასით, ხოლო ასეთი უჯრედების ქსელებს RNN ფენით.

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

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

ჩვენს შემთხვევაში, ჩვენ გამოვიყენებთ padded data loader-ს, ასე რომ, თითოეულ პარტიას ექნება იმავე სიგრძის შეფუთული თანმიმდევრობა. RNN ფენა მიიღებს ტენსორების ჩაშენების თანმიმდევრობას და გამოიმუშავებს ორ გამოსავალს:

• $x$ არის RNN უჯრედის გამომავალი თანმიმდევრობა თითოეულ საფეხურზე
• $h$ არის საბოლოო დამალული მდგომარეობა მიმდევრობის ბოლო ელემენტისთვის

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

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

გრძელვადიანი მოკლევადიანი მეხსიერება (LSTM)

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

LSTM ქსელი ორგანიზებულია RNN-ის მსგავსად, მაგრამ არის ორი მდგომარეობა, რომელიც გადადის ფენიდან ფენაზე: ფაქტობრივი მდგომარეობა $c$ და ფარული ვექტორი $h$. თითოეულ ერთეულზე, ფარული ვექტორი $h_i$ არის შერწყმული $x_i$ შეყვანით და ისინი აკონტროლებენ რა მოუვა $c$ მდგომარეობასკარიბჭის საშუალებით. თითოეული კარიბჭე არის ნერვული ქსელი სიგმოიდური აქტივაციით (გამომავალი $[0,1]$ დიაპაზონში), რომელიც შეიძლება ჩაითვალოს ბიტიურ ნიღბად, როდესაც მრავლდება მდგომარეობის ვექტორზე. არის შემდეგი კარიბჭე (მარცხნიდან მარჯვნივ ზემოთ სურათზე):

• forget gate იღებს დამალულ ვექტორს და ადგენს $c$ ვექტორის რომელი კომპონენტები უნდა დავივიწყოთ და რომელი გავიაროთ.
• შეყვანის კარიბჭე იღებს გარკვეულ ინფორმაციას შეყვანისა და ფარული ვექტორიდან და აყენებს მას მდგომარეობაში.
• გამომავალი კარიბჭე გარდაქმნის მდგომარეობას ზოგიერთი წრფივი შრის მეშვეობით $\tanh$ გააქტიურებით, შემდეგ ირჩევს მის ზოგიერთ კომპონენტს ფარული ვექტორის გამოყენებით $h_i$ ახალი $c_{i+1}$ მდგომარეობის შესაქმნელად.

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

შენიშვნა: LSTM-ის შინაგანი გაგებისთვის შესანიშნავი რესურსია ეს შესანიშნავი სტატია LSTM ქსელების გაგება კრისტოფერ ოლაჰის მიერ.

მიუხედავად იმისა, რომ LSTM უჯრედის შიდა სტრუქტურა შეიძლება რთულად გამოიყურებოდეს, PyTorch მალავს ამ განხორციელებას LSTMCell კლასში და უზრუნველყოფს LSTM ობიექტს მთელი LSTM ფენის წარმოსადგენად. ამრიგად, LSTM კლასიფიკატორის დანერგვა საკმაოდ ჰგავს მარტივ RNN-ს, რომელიც ზემოთ ვნახეთ:

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

შეფუთული თანმიმდევრობა

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

ამისათვის PyTorch-ში დაინერგა დატენილი თანმიმდევრობის შენახვის სპეციალური ფორმატი. დავუშვათ, რომ ჩვენ გვაქვს შეყვანილი მინი პარტია, რომელიც ასე გამოიყურება:[[1,2,3,4,5], [6,7,8,0,0], [9,0,0,0,0]]აქ 0 წარმოადგენს შეფუთულ მნიშვნელობებს, ხოლო შეყვანის თანმიმდევრობების რეალური სიგრძის ვექტორი არის [5,3,1].

იმისათვის, რომ ეფექტურად ვავარჯიშოთ RNN შეფუთული თანმიმდევრობით, ჩვენ გვინდა დავიწყოთ RNN უჯრედების პირველი ჯგუფის ვარჯიში დიდი მინი პარტიით ([1,6,9]), მაგრამ შემდეგ დავასრულოთ მესამე მიმდევრობის დამუშავება და გავაგრძელოთ ვარჯიში მოკლე მინი პარტიებით ([2,7], [3,8]) და ა.შ. ამრიგად, შეფუთული თანმიმდევრობა წარმოდგენილია როგორც ერთი ვექტორი - ჩვენს შემთხვევაში [1,6,9,2,7,3,8,4,5] და სიგრძის ვექტორი ([5,3,1]), საიდანაც ჩვენ შეგვიძლია მარტივად აღვადგინოთ ორიგინალური შეფუთული მინი პარტია.

შეფუთული თანმიმდევრობის შესაქმნელად, ჩვენ შეგვიძლია გამოვიყენოთ torch.nn.utils.rnn.pack_padded_sequence ფუნქცია. ყველა განმეორებადი ფენა, მათ შორის RNN, LSTM და GRU, მხარს უჭერს შეფუთულ მიმდევრობებს, როგორც შეყვანას და აწარმოებს შეფუთულ გამომავალს, რომლის გაშიფვრა შესაძლებელია torch.nn.utils.rnn.pad_packed_sequence-ის გამოყენებით.

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

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

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

ახლა ჩავატაროთ ტრენინგი:

შენიშვნა: თქვენ შეიძლება შეამჩნიეთ პარამეტრი use_pack_sequence, რომელსაც გადავცემთ ტრენინგის ფუნქციას. ამჟამად, pack_padded_sequence ფუნქცია მოითხოვს, რომ სიგრძის მიმდევრობის ტენსორი იყოს CPU მოწყობილობაზე და, შესაბამისად, სასწავლო ფუნქციამ უნდა თავიდან აიცილოს სიგრძის თანმიმდევრობის მონაცემების GPU-ზე გადატანა ვარჯიშის დროს. შეგიძლიათ იხილოთ train_emb ფუნქციის განხორციელება torchnlp.py ფაილში.

ორმხრივი და მრავალშრიანი RNN

ჩვენს მაგალითებში, ყველა განმეორებადი ქსელი მოქმედებდა ერთი მიმართულებით, მიმდევრობის დასაწყისიდან ბოლომდე. ბუნებრივად გამოიყურება, რადგან წააგავს სიტყვის კითხვისა და მოსმენის ხერხს. თუმცა, რადგან ბევრ პრაქტიკულ შემთხვევაში გვაქვს შემთხვევითი წვდომა შეყვანის თანმიმდევრობაზე, შეიძლება აზრი ჰქონდეს განმეორებითი გამოთვლების გაშვებას ორივე მიმართულებით. ასეთ ქსელებს უწოდებენ ორმხრივი RNN-ებს და მათი შექმნა შესაძლებელია bidirectional=True პარამეტრის RNN/LSTM/GRU კონსტრუქტორზე გადაცემით.

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

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

სურათი ეს მშვენიერი პოსტი-დან ფერნანდო ლოპესიდან

PyTorch ხდის ასეთი ქსელების მშენებლობას მარტივ ამოცანას, რადგან თქვენ უბრალოდ უნდა გადასცეთ num_layers პარამეტრი RNN/LSTM/GRU კონსტრუქტორს, რათა ავტომატურად ააშენოთ განმეორების რამდენიმე ფენა. ეს ასევე ნიშნავს, რომ ფარული/მდგომარეობის ვექტორის ზომა პროპორციულად გაიზრდება და თქვენ უნდა გაითვალისწინოთ ეს განმეორებადი ფენების გამომავალი დამუშავებისას.

RNN სხვა ამოცანებისთვის

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