შესავალი PyTorch-ში

ეს ნოუთბუქი AI დამწყებთათვის სასწავლო გეგმები-ის ნაწილია. ეწვიეთ საცავს სასწავლო მასალების სრული ნაკრებისთვის.

ნერვული ჩარჩოები

ჩვენ გავიგეთ, რომ ნერვული ქსელების მოსამზადებლად გჭირდებათ:

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

რა საშუალებას გაძლევთ გააკეთოთ ნერვული ქსელის ჩარჩოები:

• იმუშავეთ ტენსორებით ნებისმიერ გამოთვლაზე, CPU ან GPU, ან თუნდაც TPU
• გრადიენტების ავტომატური გამოთვლა (ისინი აშკარად დაპროგრამებულია ყველა ჩაშენებული ტენზორული ფუნქციისთვის)

სურვილისამებრ:

• ნერვული ქსელის კონსტრუქტორი / უმაღლესი დონის API (აღწერეთ ქსელი, როგორც ფენების თანმიმდევრობა)
• მარტივი სასწავლო ფუნქციები (fit, როგორც Scikit Learn-ში)
• ოპტიმიზაციის მთელი რიგი ალგორითმები გრადიენტული წარმოშობის გარდა
• მონაცემთა დამუშავების აბსტრაქციები (რომელიც იდეალურად იმუშავებს GPU-ზეც)

ყველაზე პოპულარული ჩარჩოები

• Tensorflow 1.x - პირველი ფართოდ ხელმისაწვდომი ჩარჩო (Google). ნებადართულია განსაზღვროს სტატიკური გამოთვლითი გრაფიკი, დააყენოს იგი GPU-ზე და მკაფიოდ შეაფასოს იგი
• PyTorch - ფეისბუქის ჩარჩო, რომელიც იზრდება პოპულარობით
• Keras - უფრო მაღალი დონის API Tensorflow/PyTorch-ის თავზე ნერვული ქსელების გაერთიანებისა და გამარტივების მიზნით (Francois Chollet)
• Tensorflow 2.x + Keras - Tensorflow-ის ახალი ვერსია ინტეგრირებული Keras ფუნქციონირებით, რომელიც მხარს უჭერს დინამიური გამოთვლის გრაფიკს, რაც საშუალებას გაძლევთ შეასრულოთ ტენზორული ოპერაციები, რომლებიც ძალიან ჰგავს numpy-ს (და PyTorch)

ამ ნოუთბუქში ჩვენ ვისწავლით PyTorch-ის გამოყენებას. თქვენ უნდა დარწმუნდეთ, რომ დაინსტალირებული გაქვთ PyTorch-ის უახლესი ვერსია - ამისათვის მიჰყევით ინსტრუქციები მათ საიტზე. როგორც წესი, ეს ისეთივე მარტივია, როგორც გაკეთებაpip install torch torchvisionან``` conda install pytorch -c pytorch

ძირითადი ცნებები: ტენსორი

Tensor არის მრავალგანზომილებიანი მასივი. ძალიან მოსახერხებელია ტენსორების გამოყენება სხვადასხვა ტიპის მონაცემების წარმოსადგენად:

• 400x400 - შავ-თეთრი სურათი
• 400x400x3 - ფერადი სურათი
• 16x400x400x3 - 16 ფერადი სურათის მინი პარტია
• 25x400x400x3 - ერთი წამი 25-fps ვიდეოდან
• 8x25x400x400x3 - 8 1 წამიანი ვიდეოს მინი პარტია

მარტივი ტენსორები

თქვენ შეგიძლიათ მარტივად შექმნათ მარტივი ტენსორები np მასივების სიებიდან, ან შექმნათ შემთხვევითი:

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

ადგილზე და გარე ოპერაციები

ტენსორის ოპერაციები, როგორიცაა +/add აბრუნებს ახალ ტენსორებს. თუმცა, ზოგჯერ საჭიროა არსებული ტენზორის ადგილზე შეცვლა. ოპერაციების უმეტესობას აქვს საკუთარი ანალოგები, რომლებიც მთავრდება _-ით:

აი, როგორ შეგვიძლია გამოვთვალოთ ჯამი ან ყველა მწკრივი მატრიცაში გულუბრყვილოდ:

მაგრამ მისი გამოყენება ბევრად უკეთესია

შეგიძლიათ მეტი წაიკითხოთ PyTorch ტენსორების შესახებ ოფიციალური დოკუმენტაცია-ში

გამოთვლითი გრადიენტები

უკანა გამრავლებისთვის საჭიროა გრადიენტების გამოთვლა. ჩვენ შეგვიძლია დავაყენოთ PyTorch Tensor-ის ნებისმიერი ატრიბუტი requires_grad``True-ზე, რაც გამოიწვევს ამ ტენზორის ყველა ოპერაციას გრადიენტის გამოთვლებისთვის. გრადიენტების გამოსათვლელად, თქვენ უნდა გამოიძახოთ backward() მეთოდი, რის შემდეგაც გრადიენტი ხელმისაწვდომი გახდება grad ატრიბუტის გამოყენებით:

უფრო ზუსტად რომ ვთქვათ, PyTorch ავტომატურად აგროვებს გრადიენტებს. თუ backward-ის გამოძახებისას მიუთითებთ retain_graph=True-ს, გამოთვლითი გრაფიკი შენარჩუნდება და ახალი გრადიენტი დაემატება grad ველს. იმისათვის, რომ გამოთვლითი გრადიენტები თავიდან დავიწყოთ, ჩვენ გვჭირდება grad ველის გადატვირთვა 0-ზე აშკარად zero_()-ის დარეკვით:

გრადიენტების გამოსათვლელად PyTorch ქმნის და ინახავს გამოთვლით გრაფიკს. თითოეული ტენსორისთვის, რომელსაც აქვს requires_grad დროშა დაყენებული True-ზე, PyTorch ინარჩუნებს სპეციალურ ფუნქციას, სახელწოდებით grad_fn, რომელიც გამოთვლის გამოხატვის წარმოებულს ჯაჭვის დიფერენციაციის წესის მიხედვით:

აქ c გამოითვლება mean ფუნქციის გამოყენებით, შესაბამისად grad_fn მიუთითებს ფუნქციაზე, სახელად MeanBackward.

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

დავუშვათ, გვაქვს ვექტორული ფუნქცია $\vec{y}=f(\vec{x})$, სადაც $\vec{x}=\langle x_1,\dots,x_n\rangle$ და $\vec{y}=\langle y_1,\dots,y_m\rangle$, შემდეგ $\vec{y}$-ის გრადიენტი $\vec{x}$-ის მიმართ განისაზღვრება Jacobian-ით:

$$ \begin{align}J=\left(\begin{მასივი}ccc} \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\ \vdots & \ddots & \vdots\ \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}} \end{მასივი}\right)\end{გასწორება} $$

იმის ნაცვლად, რომ მოგვცეს წვდომა მთელ Jacobian-ზე, PyTorch გამოთვლის პროდუქტს $v^T\cdot J$ of Jacobian რაღაც ვექტორით. $v=(v_1 \წერტილები v_m)$. ამისათვის ჩვენ უნდა გამოვიძახოთ backward and pass v as an argument. The size of v უნდა იყოს იგივე, რაც საწყისი ტენზორის ზომა, რომლის მიმართაც ჩვენ გამოვთვალოთ გრადიენტი.

მეტი იაკობიანების გამოთვლის შესახებ PyTorch-ში შეგიძლიათ იხილოთ ოფიციალური დოკუმენტაცია-ში

მაგალითი 0: ოპტიმიზაცია გრადიენტური დაღმართის გამოყენებით

შევეცადოთ გამოვიყენოთ ავტომატური დიფერენციაცია, რათა ვიპოვოთ მარტივი ორცვლადიანი ფუნქციის მინიმუმი $f(x_1,x_2)=(x_1-3)^2+(x_2+2)^2$. დაე, ტენსორმა x შეინარჩუნოს წერტილის მიმდინარე კოორდინატები. ჩვენ ვიწყებთ საწყისი წერტილით $x^{(0)}=(0,0)$ და გამოვთვალეთ შემდეგი წერტილი თანმიმდევრობით გრადიენტული წარმოშობის ფორმულის გამოყენებით: $$ x^{(n+1)} = x^{(n)} - \eta\nabla f $$ აქ $\eta$ არის ეგრეთ წოდებული სწავლის გაბრაზება (კოდში აღვნიშნავთ lr-ით), ხოლო $\nabla f = (\frac{\partial f}{\partial x_1},\frac{\partial f}{\partial x_2})$ - $f$-ის გრადიენტი.

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

ახლა მოდით გავაკეთოთ გრადიენტური დაღმართის 15 გამეორება. თითოეულ გამეორებაში ჩვენ განვაახლებთ x კოორდინატებს და დავბეჭდავთ მათ, რათა დავრწმუნდეთ, რომ ვუახლოვდებით მინიმალურ წერტილს (3,-2):

მაგალითი 1: ხაზოვანი რეგრესია

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

წრფივი რეგრესია განისაზღვრება სწორი ხაზით $f_{W,b}(x) = Wx+b$, სადაც $W, b$ არის მოდელის პარამეტრები, რომლებიც უნდა ვიპოვოთ. შეცდომა ჩვენს მონაცემთა ბაზაში ${x_i,y_u}{i=1}^N$ (ასევე უწოდებენ დაკარგვის ფუნქციას) შეიძლება განისაზღვროს, როგორც საშუალო კვადრატული შეცდომა: $$ \mathcal{L}(W,b) = {1\ მეტი N}\sum{i=1}^N (f_{W,b}(x_i)-y_i)^2 $$

მოდით განვსაზღვროთ ჩვენი მოდელი და დაკარგვის ფუნქცია:

ჩვენ მოვამზადებთ მოდელს მინი პატჩების სერიაზე. ჩვენ გამოვიყენებთ გრადიენტულ დაშვებას, მოდელის პარამეტრების კორექტირებას შემდეგი ფორმულების გამოყენებით: $$ \დაწყება{მასივი}{l} W^{(n+1)}=W^{(n)}-\eta\frac{\partial\mathcal{L}}{\partial W} \ b^{(n+1)}=b^{(n)}-\eta\frac{\partial\mathcal{L}}{\partial b} \ \დასრულება{მასივი} $$

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

ჩვენ ახლა მივიღეთ ოპტიმიზებული პარამეტრები $W$ და $b$. Note that their values are similar to the original values used when generating the dataset ($W=2, b=1$)

გამოთვლები GPU-ზე

გამოთვლებისთვის GPU-ს გამოსაყენებლად PyTorch მხარს უჭერს ტენსორების გადატანას GPU-ზე და გამოთვლითი გრაფიკის აგებას GPU-სთვის. ტრადიციულად, ჩვენი კოდის დასაწყისში ჩვენ განვსაზღვრავთ ხელმისაწვდომ გამოთვლით მოწყობილობას device (რომელიც არის cpu ან cuda), შემდეგ კი გადავიტანთ ყველა ტენსორს ამ მოწყობილობაზე .to(device) ზარის გამოყენებით. ჩვენ ასევე შეგვიძლია შევქმნათ ტენსორები მითითებულ მოწყობილობაზე წინასწარ, პარამეტრის device=... გადაცემით ტენზორის შექმნის კოდზე. ასეთი კოდი მუშაობს ცვლილებების გარეშე როგორც CPU-ზე, ასევე GPU-ზე:

მაგალითი 2: კლასიფიკაცია

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

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

ტრენინგი ერთშრიანი პერცეპტრონი

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

ჩვენს ნერვულ ქსელს ექნება 2 შეყვანა და 1 გამომავალი. წონის მატრიცას $W$ ექნება ზომა $2\ჯერ1$ და მიკერძოების ვექტორი $b$ -- $1$.

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

გაითვალისწინეთ, რომ ჩვენ ვიყენებთ W.data.zero_() W.zero_()-ის ნაცვლად. ჩვენ ეს უნდა გავაკეთოთ, რადგან ჩვენ არ შეგვიძლია პირდაპირ შევცვალოთ ტენზორი, რომელსაც აკონტროლებენ Autograd მექანიზმის გამოყენებით.

ძირითადი მოდელი იქნება იგივე, რაც წინა მაგალითში, მაგრამ დაკარგვის ფუნქცია იქნება ლოგისტიკური დანაკარგი. ლოგისტიკური დანაკარგის გამოსაყენებლად, ჩვენ უნდა მივიღოთ ალბათობა, როგორც ჩვენი ქსელის გამოსავალი, ანუ გამომავალი $z$ უნდა მივიყვანოთ დიაპაზონში [0,1] sigmoid აქტივაციის ფუნქციის გამოყენებით: $p=\sigma(z)$.

თუ მივიღებთ ალბათობას $p_i$ i-ის შეყვანის მნიშვნელობისთვის, რომელიც შეესაბამება $y_i\in{0,1}$ ფაქტობრივ კლასს, ჩვენ გამოვთვლით დანაკარგს $\mathcal{L_i}=-(y_i\log p_i + (1-y_i)log(1-p_i))$.

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

ზარი binary_crossentropy_with_logits-ზე უდრის ზარს sigmoid-ზე, რასაც მოჰყვება ზარი binary_crossentropy-ზე

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

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

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

ახლა ჩვენ შეგვიძლია შევამოწმოთ მთელი მონაცემთა ბაზა, რათა გავავარჯიშოთ ჩვენი ქსელი 15 ეპოქისთვის:

მიღებული პარამეტრები:

იმისათვის, რომ დავრწმუნდეთ, რომ ჩვენი ტრენინგი მუშაობდა, მოდით დავხატოთ ხაზი, რომელიც ჰყოფს ორ კლასს. გამოყოფის ხაზი განისაზღვრება განტოლებით $W\ჯერ x + b = 0.5$

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

მოდი ავხსნათ რა ხდება აქ:

• pred არის პროგნოზირებული ალბათობების ვექტორი მთელი ვალიდაციის მონაცემთა ნაკრებისთვის. ჩვენ ვიანგარიშებთ მას ჩვენი ქსელის მეშვეობით ორიგინალური ვალიდაციის მონაცემების valid_x გაშვებით და ალბათობების მისაღებად sigmoid-ის გამოყენებით.
• pred.view(-1) ქმნის ორიგინალური ტენზორის გაბრტყელ ხედს. view მსგავსია reshape ფუნქციის numpy-ში.
• pred.view(-1)>0.5 აბრუნებს ლოგიკური ტენსორის ან ჭეშმარიტების მნიშვნელობას, რომელიც აჩვენებს წინასწარმეტყველურ კლასს (False = კლასი 0, True = კლასი 1)
• ანალოგიურად, torch.tensor(valid_labels)>0.5) ქმნის ჭეშმარიტების მნიშვნელობების ლოგიკურ ტენსორს ვალიდაციის ეტიკეტებისთვის
• ჩვენ შევადარებთ ამ ორ ტენსორს ელემენტის მიხედვით და მივიღებთ სხვა ლოგიკურ ტენსორს, სადაც True შეესაბამება სწორ პროგნოზს, ხოლო False - არასწორს.
• ჩვენ ამ ტენსორს ვცვლით მცურავ წერტილად და ვიღებთ მის საშუალო მნიშვნელობას torch.mean-ის გამოყენებით - ეს არის სასურველი სიზუსტე

ნერვული ქსელები და ოპტიმიზატორები

PyTorch-ში განსაზღვრულია სპეციალური მოდული torch.nn.Module, რომელიც წარმოადგენს ნერვულ ქსელს. თქვენი საკუთარი ნერვული ქსელის განსაზღვრის ორი მეთოდი არსებობს:

• თანმიმდევრული, სადაც თქვენ უბრალოდ მიუთითებთ ფენების სიას, რომლებიც მოიცავს თქვენს ქსელს
• როგორც კლასი მემკვიდრეობით torch.nn.Module-დან

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

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

• Linear - მკვრივი წრფივი ფენა, ერთშრიანი პერცეპტრონის ტოლფასი. მას აქვს იგივე არქიტექტურა, რაც ზემოთ განვსაზღვრეთ ჩვენი ქსელისთვის
• Softmax, Sigmoid, ReLU - ფენები, რომლებიც შეესაბამება აქტივაციის ფუნქციებს
• ასევე არსებობს სხვა ფენები ქსელის სპეციალური ტიპებისთვის - კონვოლუცია, განმეორებადი და ა.შ. ბევრ მათგანს მოგვიანებით განვიხილავთ.

PyTorch-ში აქტივაციის ფუნქციისა და დაკარგვის ფუნქციების უმეტესობა ხელმისაწვდომია ორი ფორმით: ფუნქციის (torch.nn.functional სახელთა სივრცის შიგნით) და შრის სახით (torch.nn სახელთა სივრცის შიგნით). აქტივაციის ფუნქციებისთვის ხშირად უფრო ადვილია ფუნქციური ელემენტების გამოყენება torch.nn.functional-დან, ცალკეული ფენის ობიექტის შექმნის გარეშე.

თუ გვსურს ვავარჯიშოთ ერთშრიანი პერცეტრონი, შეგვიძლია გამოვიყენოთ ერთი ჩაშენებული Linear ფენა:

როგორც ხედავთ, parameters() მეთოდი აბრუნებს ყველა იმ პარამეტრს, რომელიც უნდა დარეგულირდეს ტრენინგის დროს. ისინი შეესაბამება წონის მატრიცას $W$ და მიკერძოებას $b$. თქვენ შეგიძლიათ შენიშნოთ, რომ მათ აქვთ requires_grad დაყენებული True, რადგან ჩვენ გვჭირდება გრადიენტების გამოთვლა პარამეტრების მიმართ.

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

ოპტიმიზატორის გამოყენებით, ჩვენი სასწავლო ციკლი ასე გამოიყურება:

თქვენ შეიძლება შეამჩნიოთ, რომ ჩვენი ქსელის მონაცემების შესატანად გამოსაყენებლად, ჩვენ შეგვიძლია გამოვიყენოთ net(x) net.forward(x)-ის ნაცვლად, რადგან nn.Module ახორციელებს Python __call__() ფუნქციას

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

ქსელის, როგორც ფენების თანმიმდევრობის განსაზღვრა

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

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

ქსელის კლასის განსაზღვრა

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

ამოცანა 1: დახაზეთ ზარალის ფუნქციისა და სიზუსტის გრაფიკები ტრენინგის დროს და დამოწმების მონაცემები

ამოცანა 2: სცადეთ გადაჭრათ MNIST კლასიფიკაციის პრობლემა ამ კოდის გამოყენებით. მინიშნება: გამოიყენეთ crossentropy_with_logits როგორც დაკარგვის ფუნქცია.

ქსელის განსაზღვრა, როგორც PyTorch Lightning მოდული

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

ჯერ PyTorch Lightining-ის ინსტალაცია და იმპორტი გვჭირდება. ეს შეიძლება გაკეთდეს ბრძანებით

იტვირთება…

იმისათვის, რომ ჩვენმა კოდმა იმუშაოს Lightning-ში, ჩვენ უნდა გავაკეთოთ შემდეგი:

1. შექმენით pl.LightningModule-ის ქვეკლასი და დაამატეთ მას მოდელის არქიტექტურა __init__ მეთოდით და forward pass მეთოდით.
2. გამოყენებული ოპტიმიზატორი გადაიტანეთ configure_optimizers() მეთოდზე.
3. განსაზღვრეთ ტრენინგის და ვალიდაციის პროცესი შესაბამისად training_step და validation_step მეთოდებში.
4. (სურვილისამებრ) განახორციელეთ ტესტირების (test_step მეთოდი) და პროგნოზირების პროცესი (predict_step მეთოდი).

ასევე უნდა გვესმოდეს, რომ PyTorch Lightning-ს აქვს მოდელების ჩაშენებული თარგმანი სხვადასხვა მოწყობილობებზე, იმისდა მიხედვით, თუ სად მდებარეობს DataLoaders შემომავალი მონაცემები. ამიტომ, ყველა ზარი .cuda() ან .to(device) უნდა წაიშალოს კოდიდან.

მოდით ასევე დავამატოთ ვალიდაცია Dataset და DataLoader:

ახლა ჩვენი მოდელი მზად არის ტრენინგისთვის. Pytorch Lightning-ში ეს პროცესი ხორციელდება Trainer კლასის ობიექტის მეშვეობით, რომელიც არსებითად "არევს" მოდელს ნებისმიერ მონაცემთა ნაკრებთან.

Takeaways

• PyTorch გაძლევთ საშუალებას იმუშაოთ ტენსორებზე დაბალ დონეზე, თქვენ გაქვთ ყველაზე მეტი მოქნილობა.
• არსებობს მოსახერხებელი ხელსაწყოები მონაცემებთან მუშაობისთვის, როგორიცაა Datasets და Dataloaders.
• თქვენ შეგიძლიათ განსაზღვროთ ნერვული ქსელის არქიტექტურა Sequential სინტაქსის გამოყენებით, ან კლასის მემკვიდრეობით torch.nn.Module-დან
• ქსელის განსაზღვრისა და ტრენინგის კიდევ უფრო მარტივი მიდგომისთვის - გადახედეთ PyTorch Lightning-ს