בניית רשת עצבית קונבולוציונית עם PyTorch - KDnuggets

הועלה מחדש על ידי אפלטון

עוקב: 0

בניית רשת עצבית Convolutional עם PyTorch
תמונה מאת המחבר

A Convolutional Neural Network (CNN או ConvNet) הוא אלגוריתם למידה עמוקה שתוכנן במיוחד עבור משימות שבהן זיהוי אובייקטים הוא חיוני - כמו סיווג תמונות, זיהוי ופילוח. רשתות CNN מסוגלות להשיג דיוק מתקדם במשימות ראייה מורכבות, להפעיל יישומים רבים מהחיים האמיתיים כגון מערכות מעקב, ניהול מחסנים ועוד.

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

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

רשתות עצביות Convolutional (CNNs) משמשות בדרך כלל למשימות סיווג תמונות. ברמה גבוהה, CNNs מכילים שלושה סוגים עיקריים של שכבות:

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

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

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

בניית רשת עצבית Convolutional עם PyTorch
gif מאת IceCream Labs

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

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

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

# Conv layers self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)
self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size) # Pooling layer
self.pool = nn.MaxPool2d(kernel_size) # Fully-connected layers self.fc1 = nn.Linear(in_features, out_features)
self.fc2 = nn.Linear(in_features, out_features)

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

בחלק זה, נטען את CIFAR10 ונבנה ונאמן מודל סיווג מבוסס CNN באמצעות PyTorch. מערך הנתונים CIFAR10 מספק תמונות RGB בגודל 32×32 על פני עשר מחלקות, דבר שימושי לבדיקת מודלים של סיווג תמונות. ישנן עשר מחלקות המסומנות במספרים שלמים 0 עד 9.

הערה: קוד הדוגמה הוא הגרסה ששונתה מ MachineLearningMastery.com בלוג.

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

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision transform = torchvision.transforms.Compose( [torchvision.transforms.ToTensor()]
) train = torchvision.datasets.CIFAR10( root="data", train=True, download=True, transform=transform
) test = torchvision.datasets.CIFAR10( root="data", train=False, download=True, transform=transform
)

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar-10-python.tar.gz 100%|██████████| 170498071/170498071 [00:1000:00, 15853600.54it/s] Extracting data/cifar-10-python.tar.gz to data
Files already downloaded and verified

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

batch_size = 32
trainloader = torch.utils.data.DataLoader( train, batch_size=batch_size, shuffle=True
)
testloader = torch.utils.data.DataLoader( test, batch_size=batch_size, shuffle=True
)

כדי להמחיש את התמונה באצווה אחת של התמונות, נשתמש בפונקציית matplotlib ו-torchvision.

from torchvision.utils import make_grid
import matplotlib.pyplot as plt def show_batch(dl): for images, labels in dl: fig, ax = plt.subplots(figsize=(12, 12)) ax.set_xticks([]); ax.set_yticks([]) ax.imshow(make_grid(images[:64], nrow=8).permute(1, 2, 0)) break
show_batch(trainloader)

כפי שאנו יכולים לראות, יש לנו תמונות של מכוניות, בעלי חיים, מטוסים וסירות.

בניית רשת עצבית Convolutional עם PyTorch

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

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

class CNNModel(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(3, 32, kernel_size=(3,3), stride=1, padding=1) self.act1 = nn.ReLU() self.drop1 = nn.Dropout(0.3) self.conv2 = nn.Conv2d(32, 32, kernel_size=(3,3), stride=1, padding=1) self.act2 = nn.ReLU() self.pool2 = nn.MaxPool2d(kernel_size=(2, 2)) self.flat = nn.Flatten() self.fc3 = nn.Linear(8192, 512) self.act3 = nn.ReLU() self.drop3 = nn.Dropout(0.5) self.fc4 = nn.Linear(512, 10) def forward(self, x): # input 3x32x32, output 32x32x32 x = self.act1(self.conv1(x)) x = self.drop1(x) # input 32x32x32, output 32x32x32 x = self.act2(self.conv2(x)) # input 32x32x32, output 32x16x16 x = self.pool2(x) # input 32x16x16, output 8192 x = self.flat(x) # input 8192, output 512 x = self.act3(self.fc3(x)) x = self.drop3(x) # input 512, output 10 x = self.fc4(x) return x

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

model = CNNModel()
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

בשלב ההכשרה, נאמן את המודל שלנו למשך 10 עידנים.

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

n_epochs = 10
for epoch in range(n_epochs): for i, (images, labels) in enumerate(trainloader): # Forward pass outputs = model(images) loss = loss_fn(outputs, labels) # Backward pass and optimize optimizer.zero_grad() loss.backward() optimizer.step() correct = 0 total = 0 with torch.no_grad(): for images, labels in testloader: outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Epoch %d: Accuracy: %d %%' % (epoch,(100 * correct / total)))

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

Epoch 0: Accuracy: 41 %
Epoch 1: Accuracy: 46 %
Epoch 2: Accuracy: 48 %
Epoch 3: Accuracy: 50 %
Epoch 4: Accuracy: 52 %
Epoch 5: Accuracy: 53 %
Epoch 6: Accuracy: 53 %
Epoch 7: Accuracy: 56 %
Epoch 8: Accuracy: 56 %
Epoch 9: Accuracy: 57 %

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

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

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

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