מדריך PyTorch CNN: בנה ואמן רשתות עצביות קונבולוציוניות בפייתון

מדריכים
Python

רשתות נוירונים קונבולוציונליות (CNNs) הן יסוד בראיית מחשב מודרנית, המאפשרות יישומים כמו זיהוי תמונות, זיהוי פנים ורכבים שמנה. רשתות אלו מיועדות לחילוץ אוטומטי של דפוסים ותכונות מתוך תמונות, מה שהופך אותן לחזקות יותר מטכניקות למידת מכונה מסורתיות למשימות חזותיות.

במדריך זה, נכין רשת נוירונים קונבולוציונלית באמצעות PyTorch, סביבת למידה עמוקה הידידותית למשתמש ויעילה ביותר למחקר ויישומים בייצור.

דרישות מוקדמות: למידה עמוקה ו-PyTorch

לפני שנתחיל בפרטי רשתות נוירונים קונבולוציונליות, עליכם להכיר את תחום הלמידה העמוקה ואת ספריות הפייתון שנשתמש בהן במהלך הגדרת הסביבה שלנו.

למידה עמוקה היא תת-תחום של למידת מכונה, שבו מבנה המודל היסודי הוא רשת של קלטים, שכבות נסתרות ופלטים. רשת כזו יכולה להכיל שכבה אחת או יותר של נסתרים. ההשראה המקורית מאחורי למידה עמוקה הייתה ליצור מודלים שנשענים על איך שמוח האדם לומד: דרך תאים מחוברים בשם נוירונים. לכן אנו ממשיכים לקרוא למודלים של למידה עמוקה "רשתות נוירונים". מבני המודלים השכבתיים האלה דורשים נתונים הרבה יותר למידה מאשר מודלים אחרים של למידה מודרכת כדי להפיק דפוסים מהנתונים הלא מסודרים. בדרך כלל אנו מדברים על לפחות מאות אלפי נקודות נתונים.

בעוד שישנם מספר מסגרות וחבילות שם ליישום אלגוריתמים למידה עמוקה, אנו נתמקד ב-PyTorch, אחת המסגרות הפופולריות והמתוחזקות ביותר. בנוסף לשימוש של מהנדסי למידת מכונה עמוקה בתעשייה, PyTorch הוא כלי מועדף בקרב חוקרים. הרבה מאמרים בתחום הלמידה העמוקה מתפרסמים באמצעות PyTorch. המסגרת עוצבה כך שתהיה אינטואיטיבית וידידותית למשתמש, ומשתפת הרבה נקודת מגע עם ספריית הפייתון NumPy.

אם נדרשת הכרה במושגים אלו, שקול להירשם כיום לקורס
Deep Learning with PyTorch.

מהו רשת נוירונים קונבולוצייתית (CNN)?

רשתות נוירונים קונבולוציוניות, בשמם הנפוץ CNN או ConvNet, הן סוג ספציפי של רשת נוירונים עמוקה המתאימה מאוד למשימות ראיית מחשב. המצאת ה-CNNs חוזרת לשנות ה-1980. אך, הן רק הפכו לפופולריות בתחילת שנות ה-2010, לאחר המהפכות בחישוב התוצאה ממימוש יחידות עיבוד גרפי (GPUs). באמת, הפופולריות המהירה של CNNs עזרה לשדרג את תחום הרשתות הנוירוניות, מובילה למה שנקרא ה-"גל השלישי של רשתות נוירונים" שאנו חיים בו גם היום.

CNNs מושפעות באופן מסוים מהמוח הראי של האדם. לקורטקס יש אזורים קטנים של תאים הרגישים לאזורים ספציפיים בשדה הראייה. הרעיון זה התרחש על ידי ניסיון מרתק שביצעו Hubel ו-Wiesel ב-1962.

הרשתות הנוירונים המלומדות (CNNs) מנסות לשקף את התכונה הזו על ידי יצירת רשתות נוירונים מורכבות המורכבות משכבות שונות המיועדות למשימות שונות. ה־CNNs נקראות "קדימות" משום שהמידע זורם ישירות דרך המודל. אין חיבורים בחזרה שבהם פלטי המודל מוחזרים אליו עצמו, בניגוד למודלים אחרים שמשתמשים בטכניקות כמו השקפת אחורה.

במיוחד, קונספט סטנדרטי של רשת נוירונים מלומדים (CNN) כולל את השכבות הבאות:

שכבת קונבולוציה

זוהי הבלוק הראשון של רשת נוירונים מלומדים. כפי שמרמז השם, המשימה המתמטית העיקרית היא הקונבולוציה, המהווה את החלקה של פונקציית חלופין על מטריצה של פיקסלים המייצגת תמונה. הפונקציה הנעה שמופעלת על המטריצה נקראת לקרנל או פילטר. בשכבת הקונבולוציה, מופעלים מספר פילטרים שווים בגודל, וכל פילטר משמש לזיהוי דפוס ספציפי בתמונה, כגון העקומה של הספרות, הקצוות, הצורה המלאה של הספרות ועוד. 

פונקציית הפעלה

בדרך כלל, פונקציית הפעלה המקובלת (ReLU) מופעלת לאחר כל פעולת קונבולוציה. הפונקציה הזו עוזרת לרשת ללמוד יחסים לא לינאריים בין התכונות בתמונה, וכך מקנה לרשת עמידות יותר לזיהוי דפוסים שונים. כמו כן, היא עוזרת להוזית בעיות הגרדיינט המתמוטט. 

שכבת פידוח

המטרה של שכבת ה-Pooling היא למשוך את המאפיינים החשובים ביותר מהמטריצה הקונבולוציונית. זה מתבצע על ידי החלת פעולות איגוד מסוימות, שמפחיתות את ממד המפת המאפיינים (מטריצת הקונבולוציה), וכך מפחיתות את הזיכרון שבשימוש בזמן אימון הרשת. ה-Pooling גם רלוונטי להפחתת סיכון של אימונים יתר

שכבות המחוברות באופן מלא

אלה הן בשכבת האחרונה של הרשת העצבית הקונבולוציונית, והקלטות שלהן מתאימות למטריצה חד-ממדית שפורסמה על ידי שכבת ה-Pooling האחרונה. להן מוחלטות פונקציות הפעלה ReLU עבור לא-קויליות. 

ארכיטקטורת רשת עצבית קונבולוציונית. מקור: DataCamp

ניתן לקרוא הסבר מפורט יותר על המתמטיקה שבסיס הרשתות העצביות הקונבולוציוניות במדריך שלנו, רשתות עצביות קונבולוציוניות בפייתון.

למה להשתמש ברשתות עצביות קונבולוציוניות לסיווג תמונות?

רשתות עצבים קונבולוציונליות היו אחת מהממציאות המשפיעות ביותר בתחום ראיית מחשב. הן ביצעו הרבה יותר טוב מדגמי למידת מכונה מסורתיים, כמו SVMs, ועצים החלטה, ויצרו תוצאות ברמה העדכנית.

בנוסף, שכבות הקונבולוציה מעניקות ל־CNNs את תכונות האי-שינוי בתרגום שלהן, מעוצבות לזהות ולחשוף דפוסים ותכונות מנתונים לא מתייחסים לשינויים במיקום, כיוון, קנה מידה או תרגום.

נמצא כי-־CNNs הוכיחו את ההצלחה שלהם במגוון רחב של מחקרי מקרה ויישומים בחיי היום-יום, כמו:

  • אימות תמונות, זיהוי אובייקטים, תילוג, זיהוי פנים;
  • רכבים עצמיים המשתמשים במערכות ראייה על בסיס CNN;
  • סיווג מבנה הקריסטל באמצעות רשת עצבים קונבולוציונלית;
  • מערכות מצלמות אבטחה.

מעבר למשימות של סיווג תמונות, CNNs הם רב-תכליתיים וניתן להחיל אותם על מגוון רחב של תחומים אחרים, כמו: עיבוד שפה טבעית, ניתוח סדרות זמן, וזיהוי דיבור.

יישום של CNN עם PyTorch

עכשיו שאתה מוכר בתיאוריה של CNNs, אנחנו מוכנים לשטוף את הידיים. בסעיף זה, נבנה ונאמן רשת CNN פשוטה עם PyTorch. המטרה שלנו היא לבנות מודל שיסווג ספרות בתמונות. כדי לאמן ולבדוק את המודל שלנו, נשתמש בקובץ הנתונים המפורסם MNIST, אוסף של 70,000 תמונות בצבע אפור בגודל 28×28 פיקסלים עם ספרות כתובות ביד.

1. יבוא ספריות נדרשות

למטה תוכל למצוא את הספריות שנעשה שימוש בהן במדריך זה. למעשה, נשתמש ב-PyTorch כדי לבנות את ה-CNN שלנו, ובמודול הראיה הממוחשבת של PyTorch, torchvision, להורדה וטעינת קובץ הנתונים MNIST. לבסוף, נשתמש גם ב-torchmetrics כדי להעריך את ביצועי המודל שלנו.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


import torch
from torch import optim
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

# !pip install torchvision
import torchvision

import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms

# !pip install torchmetrics
import torchmetrics

2. טעינה ועיבוד מוקדם של קובץ הנתונים

PyTorch מגיע גם עם אקוסיסטמה עשירה של כלים והרחבות, כולל torchvision, מודול לראייה ממוחשבת. Torchvision כולל מספר קבצי נתונים של תמונות שניתן להשתמש בהם לאימון ובדיקת רשתות עצביות. במדריך שלנו, נשתמש בקובץ הנתונים MNIST. 

למעשה, נבצע הורדה והמרת קובץ הנתונים MNIST לטנזור, המבנה המרכזי לנתונים ב-PyTorch, דומה למערכי NumPy אך עם יכולות האצת GPU.

אז, נשתמש גם ב־DataLoader כדי לטפל באיחוד וערבוב גם בקבוצת הנתונים לאימון ולבדיקה. DataLoader של PyTorch ניתן ליצירה מ Dataset כדי לטעון נתונים, לחלק אותם לקבוצות קטנות, ולבצע שינויים על הנתונים אם רצוי. לאחר מכן, הוא מחזיר דוגמה של נתונים מוכנה לאימון. בקוד למטה, אנו טוענים את הנתונים ושומרים אותם ב־DataLoaders עם גודל קבוצה של 60 תמונות:

batch_size = 60

train_dataset = datasets.MNIST(root="dataset/", download=True, train=True, transform=transforms.ToTensor())

train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_dataset = datasets.MNIST(root="dataset/", download=True, train=False, transform=transforms.ToTensor())

test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)

אופציונלית, ניתן לחלק את קבוצת הנתונים לאימון לשני מחלקות של אימון ואימות. אימות הוא טכניקה המשמשת בלמידת עומק להערכת ביצועי המודל במהלך האימון. זה עוזר לזהות אפשרויות של עקביות יתר וחסר עקביות יתר במודלים שלנו, וזה מאוד מועיל לאופטימיזציה של היפרפרמטרים. אך, לצורך הפשטות, לא נשתמש באימות במסגרת המדריך הזה. אם ברצונך ללמוד עוד על אימות, תוכל לקרוא הסבר מלא בקורס שלנו הקדמה ללמידה עמוקה עם PyTorch.

עכשיו שיש לנו את הנתונים שלנו, נראה איך קבוצה אקראית של ספרות נראית:

def imshow(img):
   npimg = img.numpy()
   plt.imshow(np.transpose(npimg, (1, 2, 0)))
   plt.show()

# קבל כמה תמונות אימון אקראיות
dataiter = iter(dataloader_train)
images, labels = next(dataiter)
labels
# הצג תמונות
imshow(torchvision.utils.make_grid(images))

3. הגדרת ארכיטקטורת CNN

כדי לפתור את בעיה הסיווג, נשתמש במחלקת nn.Module, מבנה הבנייה של PyTorch ליצירת ארכיטקטורות מתקדמות של רשתות עצבים.

בקוד למטה, אנו יוצרים מחלקה בשם CNN, שמורשתת את המאפיינים של מחלקת nn.Module. המחלקה CNN תהיה התבנית ל-CNN עם שני שכבות קונבולוציה, שייהוותו על ידי שכבת חיבור מלאה.

ב-PyTorch, אנו משתמשים ב־nn.Conv2d כדי להגדיר שכבת קונבולוציה. אנו מעבירים אליה את מספר המפות המאפיינים הכניסה והיציאה. אנו גם מגדירים כמה מהפרמטרים של שכבת הקונבולוציה כדי שתעבוד, כולל גודל הגנר או המסנן והריפוד.

לאחר מכן, אנו מוסיפים שכבת מקסימום אינגולינג עם nn.MaxPool2d. בה, אנו מחלקים חלון לא משותף מעל הפלט של שכבת הקונבולוציה הקודמת. בכל עמדה, אנו בוחרים את הערך המרבי מהחלון כדי להעביר קדימה. פעולה זו מפחיתה את ממדי המרחב של המפות המאפיינים, וממעיטה את מספר הפרמטרים והמורכבות החישובית ברשת. לבסוף, אנו מוסיפים שכבת ליניארית מחוברת מלאה.

פונקציית ה־forward() מגדירה כיצד השכבות השונות מחוברות, על ידי הוספת מספר פעמים של פונקציות הפעלה ReLU לאחר כל שכבת קונבולוציה.

class CNN(nn.Module):
   def __init__(self, in_channels, num_classes):

       """
       Building blocks of convolutional neural network.

       Parameters:
           * in_channels: Number of channels in the input image (for grayscale images, 1)
           * num_classes: Number of classes to predict. In our problem, 10 (i.e digits from  0 to 9).
       """
       super(CNN, self).__init__()

       # שכבת ה-convolutional הראשונה
       self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=8, kernel_size=3, padding=1)
       # שכבת max pooling
       self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
       # שכבת ה-convolutional השנייה
       self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, padding=1)
       # שכבה מאומתת מלאה
       self.fc1 = nn.Linear(16 * 7 * 7, num_classes)

   def forward(self, x):
       """
       Define the forward pass of the neural network.

       Parameters:
           x: Input tensor.

       Returns:
           torch.Tensor
               The output tensor after passing through the network.
       """
       x = F.relu(self.conv1(x))  # להחיל את ה-convolution הראשון וה-פעילות ReLU
       x = self.pool(x)           # להחיל max pooling
       x = F.relu(self.conv2(x))  # להחיל את ה-convolution השני וה-פעילות ReLU
       x = self.pool(x)           # להחיל max pooling
       x = x.reshape(x.shape[0], -1)  # לשטח את הטנזור
       x = self.fc1(x)            # להחיל שכבת מאומתת מלאה
       return x
       x = x.reshape(x.shape[0], -1)  # לשטח את הטנזור
       x = self.fc1(x)            # להחיל שכבת מאומתת מלאה
       return x

ברגע שהגדרנו את מחלקת ה-CNN, אנו יכולים ליצור את המודל שלנו ולהעביר אותו למכשיר שבו ייעשה האימון והרצה שלו.

רשתות נוירונים, כולל CNNs, מראות ביצועים טובים יותר כאשר הן רצות על יחידות GPU, אך יתכן וזה לא המקרה על המחשב שלך. לכן, נריץ את המודל על GPU רק כאשר זמין; אחרת, נשתמש ב-CPU רגיל. 

device = "cuda" if torch.cuda.is_available() else "cpu"

model = CNN(in_channels=1, num_classes=10).to(device)
print(model)
>>> CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

4. אימון המודל CNN

כעת שיש לנו את המודל שלנו, הגיע הזמן לאמן אותו. כדי לעשות זאת, נצטרך תחילה לקבוע איך נמדד את ביצועי המודל. מאחר שאנו מתמודדים עם בעיה של סיווג מרובה קטגוריות, נשתמש בפונקציית ההפסד בעלת האנטרופיה צלבית, הזמינה ב-PyTorch כ-nn.CrossEntropyLoss. נשתמש גם באופטימיזציה של אדם (Adam), אחד מהאלגוריתמים לאופטימיזציה הפופולריים ביותר. 

# הגדרת פונקציית ההפסד
criterion = nn.CrossEntropyLoss()

# הגדרת ה־optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001)

נעבור על עשרת ה־epochs ועל אצוות האימון כדי לאמן את המודל ולבצע את רצף הצעדים הרגיל של כל אצווה, כפי שמוצג להלן. 

num_epochs=10
for epoch in range(num_epochs):
 # עוברים על אצוות האימון
   print(f"Epoch [{epoch + 1}/{num_epochs}]")

   for batch_index, (data, targets) in enumerate(tqdm(dataloader_train)):
       data = data.to(device)
       targets = targets.to(device)
       scores = model(data)
       loss = criterion(scores, targets)
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()
Epoch [1/10]
100%|██████████| 1000/1000 [00:13<00:00, 72.94it/s]
Epoch [2/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.27it/s]
Epoch [3/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.16it/s]
Epoch [4/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.00it/s]
Epoch [5/10]
100%|██████████| 1000/1000 [00:13<00:00, 75.69it/s]
Epoch [6/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.24it/s]
Epoch [7/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.23it/s]
Epoch [8/10]
100%|██████████| 1000/1000 [00:12<00:00, 78.16it/s]
Epoch [9/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.96it/s]
Epoch [10/10]
100%|██████████| 1000/1000 [00:12<00:00, 77.93it/s]

5. מערכת הערכה של המודל

לאחר שהמודל אומן, נוכל להעריך את ביצועיו על סט הנתונים לבחינה. נשתמש בדיוק, מדד פופולרי לבעיות של סיווג. הדיוק מודד את היחס בין מקרים שנסו נכונה לסך הכל מקרים במערכת. הוא מחושב על ידי חלוקת מספר הניחושים הנכונים על ידי מספר הניחושים הכולל שנעשו על ידי המודל.

ראשית, אנו מגדירים את מדד הדיוק מתוך torchmetrics. לאחר מכן, אנו משתמשים בשיטת .eval של המודל כדי לשים את המודל במצב הערכתי, מכיוון שחלק מהשכבות במודלים של PyTorch מתנהגות באופן שונה בשלבי האימון לעומת שלבי הבדיקה. אנו גם מוסיפים קשת פייתון עם torch.no_grad, המציינת שלא נבצע חישובי נטייה.

לאחר מכן, אנו מעבור על דוגמאות הבדיקה ללא חישובי נטייה. עבור כל קבוצת בדיקה, אנו מקבלים פלטים מהמודל, מציבים את המחלקה הכי סבירה, ומעבירים אותה לפונקציית הדיוק יחד עם התוויות. לבסוף, אנו מחשבים את המדדים ומדפיסים את התוצאות. קיבלנו ציון דיוק של 0.98, שמעיד על כך שהמודל שלנו סיווג נכון 98% מהספרות. לא רע!

# הגדרת מטריקת דיוק מרובת המחלקות
acc = Accuracy(task="multiclass",num_classes=10)

# עוברים על קבוצות הנתונים
model.eval()
with torch.no_grad():
   for images, labels in dataloader_test:
       # מקבלים תחזיות עבור קבוצת הנתונים לבדיקה
       outputs = model(images)
       _, preds = torch.max(outputs, 1)
       acc(preds, labels)
       precision(preds, labels)
       recall(preds, labels)

# מחשבים את סך הדיוק בבדיקה
test_accuracy = acc.compute()
print(f"Test accuracy: {test_accuracy}")

>>> Test accuracy: 0.9857000112533569

ניתן גם להשתמש במדדי סיווג פופולריים נוספים, כולל זיכרון ודיוק. אנו מספרים לכם הכל על מדדים אלו עם דוגמאות מעשיות בקורס שלנו Intermediate Deep Learning with PyTorch Course.

שיפור ביצועי המודל

עוד ועוד, במרכז על יכולת הביצועים החזקה, ישנן מספר אסטרטגיות שאפשר להשתמש בהן כדי לשפר את הדיוק, העמידות והכלליות של המודל לנתונים חדשים.

בחלק זה, נבחן טכניקות מרכזיות כגון הרחבת נתונים, כיוון היפרפרמטרים, ולמידת העברה כדי לייעל את ביצועי המודל שלנו.

טכניקות הרחבת נתונים

הרחבת נתונים היא טכניקה המשמשת לשיפור הדיוק של המודל שלנו על ידי יצירת נתוני אימון חדשים באופן אקראי. לדוגמה, בעת טעינת הנתונים, ניתן להחיל שינויים על תמונות האימון, כגון שינוי גודל, היפוך אופקי או אנכי, סיבוב אקראי, וכדומה. בכך, ניתן ליצור תמונות מרוחבות ולשייך אותן לאותו התו כמו התמונה המקורית, ובכך להגדיל את גודל סט האימון.

הוספת שינויים אקראיים לתמונות המקוריות מאפשרת לנו ליצור נתונים נוספים ולהגדיל את גודל והון סט האימון. זה מקנה למודל עמידות יותר לשוניות ועיוותים הנמצאים באופן נפוץ בתמונות בעולם האמיתי, ומפחית את העליות מאשר המודל להתעלם מהשינויים האקראיים.

עם זאת, חשוב להיות זהירים בנוגע להרחבת הנתונים, שלפעמים יכולה לגרום נזק לתהליך האימון. לדוגמה, בבעיה שלנו, אם נחליף את ההיפוך האנכי למספר "6", זה יראה כמו המספר "9". העברתו למודל תוית כ"6" תבלבל את המודל ותפריע לאימון. הדוגמאות הללו מראות כי לפעמים, הרחבות ספציפיות יכולות להשפיע על התו.

כיוון היפרפרמטרים

דרך נוספת לשפר את ביצועי המודל שלנו היא על ידי שינוי הערכים של היפרפרמטרים המעורבים בשכבות שונות של המודל. תהליך זה, כיוון היפרפרמטרים, מחייב הבנה עמוקה של המתמטיקה שבסיס הרשתות העצביות והחשיבות של היפרפרמטרים השונים.

לדוגמה, ניתן לכוון את שכבות ה־CNN על ידי שינוי גודל המסננים או בהגדלת הריפוד. ניתן גם להגדיר ערך שונה למשקלים הראשוניים של הנוירונים.

מכיוון שלא תהיה לנו ידע מושלם על הערכים האופטימליים של היפרפרמטרים מראש, יידרש מעט מדרג של ניסיון וטעות. ניתן לבצע זאת בדרך כלל באמצעות טכניקה שנקראת חיפוש ברשת, שמאפשרת לך להעריך באופן מערכתי את המודל ברשת של ערכי פרמטרים.

עם זאת, חשוב להיות זהירים בעת השימוש בטכניקה זו, מאחר והיא דרך חשיבה חישובית, במיוחד כאשר מתמודדים עם רשתות עצביות מורכבות וסטי נתונים גדולים לאימון.

בנוסף, ניתן להגביר את מורכבות המודל על ידי הוספת שכבות קונבולוציוניות וליניאריות נוספות. עם זאת, חשוב להיות זהירים בעת הוספת שכבות חדשות, מאחר ומספר הנוירונים עשוי להגדל באופן דרמטי, תוצאתו עשויה להיות זמני אימון ארוך ועלולה להיות קצת מידי תאמה.

ניתן ללמוד עוד על כיוון היפרפרמטרים בקורס שלנו, מבוא ללמידה עמוקה עם PyTorch.

בשימוש במודלים מקדימים

אימון מודלי למידה עמוקה מאפס הוא תהליך ארוך ומייגע, והוא בדרך כלל דורש הרבה נתוני אימון. במקום זאת, לעיתים קרובות אנו יכולים להשתמש במודלים שמאומנים מראש, כלומר מודלים שכבר אומנו על משימה כלשהי.

לפעמים, אנו יכולים להשתמש במודל המאומן מראש אם הוא כבר יכול לפתור את המשימה שמעניינת אותנו. במקרים אחרים, אולי נצטרך להתאים את המודל המאומן מראש כדי להתאים למשימה החדשה. זה ידוע בשם למידה מועברת.

שימוש במודלים שמאומנים מראש ב-PyTorch הוא די קל. Torchvision מספקת אוסף של מודלים שמאומנים מראש עבור משימות שונות הקשורות לתמונות. מודלים אלו מאומנים מראש על מערכי נתונים גדולים של תמונות וזמינים בקלות. בדקו את הקורס שלנו למידה עמוקה עבור תמונות עם PyTorch כדי ללמוד כל מה שאתם צריכים לדעת עליהם.

פריסת מודל ה-CNN

לאחר שאימנתם את מודל הסיווג המדויק שלכם ב-PyTorch, אתם יכולים עכשיו לשמור את המודל ואת המשקלים המאומנים מראש שלו לשימוש עתידי ולשתף אותו עם הצוות שלכם, תוך שאתם דואגים שהם יוכלו לטעון אותו בקלות.

כדי לשמור מודל, אנו יכולים להשתמש ב-torch.save. סיומת קובץ נפוצה עבור מודלי טורצ' היא pt או pth. כדי לשמור את המשקלים של המודל, אנו מעבירים את model.state_dict ל-torch.save ומספקים את שם הקובץ המוצא, לדוגמה, MulticlassCNN.pth.

כדי לטעון דגם שנשמר, אנו מאתחלים דגם חדש עם אותה ארכיטקטורה. לאחר מכן אנו משתמשים בשיטת טעינת המצב dict יחד עם torch.load כדי לטעון את הפרמטרים לדגם החדש.

# שמירת הדגם
torch.save(model.state_dict(), 'MulticlassCNN.pth')

# יצירת דגם חדש
loaded_model = CNN(in_channels=1, num_classes=10)

# טעינת הדגם שנשמר
loaded_model.load_state_dict(torch.load('MulticlassCNN.pth'))
print(loaded_model)


CNN(
  (conv1): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=784, out_features=10, bias=True)
)

מסקנה

כיסינו סקירה מלאה של CNNs, סיפקנו פרטים על כל שכבה בארכיטקטורת ה־CNN. כמו כן, סיפקנו מדריך על איך ליישם CNN ב־PyTorch, עוסקים בשלבים העיקריים, מטעינת הנתונים ועיצוב הדגם עד לאימון הדגם וההערכה שלו. לבסוף, נתמקד בניתוח של מספר אסטרטגיות לשיפור ביצועי הדגם שלנו. החלקנו את כל מיומנויות אלו לסצנריו חיים הקשורים למשימת סיווג מרובה מחלקות.

יש המון ללמוד על למידה עמוקה, אחת התחומים המרתקים והדרושים ביותר בתחום הבינה המלאכותית. למזלנו, DataCamp כאן כדי לעזור. בואו ובדקו את החומרים והקורסים המיועדים ותהפכו למומחה ברשתות נוירונים:

Source:
https://www.datacamp.com/tutorial/pytorch-cnn-tutorial