الشبكة العصبية التلافيفية – تنفيذ PyTorch على مجموعة بيانات CIFAR-10

أعاد نشره أفلاطون

المتابعون: 0

تم نشر هذه المقالة كجزء من مدونة علوم البيانات

المُقدّمة

سيفار 10 | الشبكات العصبية التلافيفية pytorch — صورة 1

تم تقديم الشبكات العصبية التلافيفية ، والتي تسمى أيضًا ConvNets ، لأول مرة في الثمانينيات من قبل Yann LeCun ، الباحث في علوم الكمبيوتر الذي عمل في الخلفية. بنى LeCun على عمل عالم ياباني كونيهيكو فوكوشيما ، وهو شبكة أساسية للتعرف على الصور.

يمكن للإصدار القديم من CNN ، المسمى LeNet (بعد LeCun) ، رؤية الأرقام المكتوبة بخط اليد. سي إن إن تساعد في العثور على الرموز السرية من البريد. ولكن على الرغم من خبرتهم ، ظلت ConvNets قريبة من رؤية الكمبيوتر والذكاء الاصطناعي لأنهم واجهوا مشكلة كبيرة: لم يتمكنوا من التوسع كثيرًا. تتطلب شبكات CNN الكثير من البيانات وتدمج الموارد للعمل بشكل جيد مع الصور الكبيرة.

في ذلك الوقت ، كانت هذه الطريقة قابلة للتطبيق فقط على الصور منخفضة الدقة. Pytorch هي مكتبة يمكنها القيام بعمليات التعلم العميق. يمكننا استخدام هذا لأداء الشبكات العصبية التلافيفية. تحتوي الشبكات العصبية التلافيفية على طبقات عديدة من الخلايا العصبية الاصطناعية. الخلايا العصبية الاصطناعية ، المحاكاة المعقدة للنظائر البيولوجية ، هي وظائف رياضية تحسب الكتلة المرجحة للمدخلات المتعددة وتفعيل قيمة المنتج.

الشبكات العصبية التلافيفية pytorch — صورة 2

تُظهر لنا الصورة أعلاه نموذجًا لشبكة CNN يأخذ صورة تشبه الرقم 2 ويعطينا نتيجة الرقم الذي تم عرضه في الصورة كرقم. سنناقش بالتفصيل كيف نحصل على هذا في هذه المقالة.

CIFAR-10 هي مجموعة بيانات تحتوي على مجموعة من الصور من 10 فئات مختلفة. تُستخدم مجموعة البيانات هذه على نطاق واسع للأغراض البحثية لاختبار نماذج مختلفة للتعلم الآلي وخاصةً لمشاكل رؤية الكمبيوتر. في هذه المقالة ، سنحاول بناء نموذج شبكة عصبية باستخدام Pytorch واختباره على مجموعة بيانات CIFAR-10 للتحقق من دقة التنبؤ التي يمكن الحصول عليها.

استيراد مكتبة PyTorch

استيراد numpy مثل استيراد الباندا np كما pd

استيراد torch torch.nn.functional as F من torchvision import dataets، التحويلات من torch import nn import matplotlib.pyplot as plt import numpy as np import seaborn as sns #from tqdm.notebook import tqdm from tqdm import tqdm

في هذه الخطوة ، نقوم باستيراد المكتبات المطلوبة. يمكننا أن نرى أننا نستخدم NumPy للعمليات العددية والباندا لعمليات إطار البيانات. تُستخدم مكتبة الشعلة لاستيراد Pytorch.

يحتوي Pytorch على مكون nn يُستخدم لاستخراج عمليات ووظائف التعلم الآلي. تم استيراد هذا كـ F. يتم استخدام مكتبة torchvision حتى نتمكن من استيراد مجموعة بيانات CIFAR-10. تحتوي هذه المكتبة على العديد من مجموعات بيانات الصور وتستخدم على نطاق واسع للبحث. يمكن استيراد التحويلات حتى نتمكن من تغيير حجم الصورة إلى حجم متساوٍ لجميع الصور. يتم استخدام tqdm حتى نتمكن من تتبع التقدم أثناء التدريب ويتم استخدامه للتخيل.

اقرأ مجموعة البيانات المطلوبة

trainData = pd.read_csv ('cifar-10 / trainLabels.csv') trainData.head ()

بمجرد قراءة مجموعة البيانات ، يمكننا رؤية ملصقات مختلفة مثل الضفدع والشاحنة والغزلان والسيارات وما إلى ذلك.

تحليل البيانات باستخدام PyTorch

طباعة ("عدد النقاط:" ، trainData.shape [0]) طباعة ("عدد الميزات:" ، trainData.shape [1]) طباعة ("الميزات:" ، trainData.columns.values) طباعة ("عدد من قيم فريدة ") لـ col في trainData: print (col،": "، len (trainData [col] .unique ())) plt.figure (figsize = (12,8،XNUMX))

الإخراج:

عدد النقاط: 50000 عدد الميزات: 2 الميزات: ['id' 'label'] عدد القيم الفريدة id: 50000 label: 10

في هذه الخطوة ، نقوم بتحليل مجموعة البيانات ونرى أن بيانات القطار لدينا بها حوالي 50000 صف بمعرفها والتسمية المرتبطة بها. يوجد إجمالي 10 فصول كما في الاسم CIFAR-10.

الحصول على مجموعة التحقق باستخدام PyTorch

من torch.utils.data import random_split val_size = 5000 train_size = len (مجموعة البيانات) - val_size train_ds، val_ds = random_split (مجموعة البيانات، [train_size، val_size]) len (train_ds)، len (val_ds)

هذه الخطوة مماثلة لخطوة التدريب ، لكننا نريد تقسيم البيانات إلى مجموعات تدريب وتحقق من الصحة.

(45000، 5000)

من torch.

يحتوي torch.utils على أداة تحميل بيانات يمكن أن تساعدنا في تحميل البيانات المطلوبة لتجاوز المعلمات المختلفة مثل رقم العامل أو حجم الدُفعة.

تحديد الوظائف المطلوبة

@ torch.no_grad () دقة def (المخرجات ، الملصقات): _ ، preds = torch.max (المخرجات ، dim = 1) إرجاع torch.tensor (torch.sum (preds == labels) .item () / len (preds )) فئة ImageClassificationBase (nn.Module): def training_step (ذاتي ، دفعة): الصور ، الملصقات = الدُفعات = self (images) # إنشاء خسارة تنبؤات = F. ، labels) عودة الخسارة، accu def validation_step (self، batch): images، labels = batch out = self (images) # Generateهلة loss = F.cross_entropy (out، labels) # حساب الخسارة acc = الدقة (out، labels) # حساب إرجاع الدقة {'Loss': loss.detach ()، 'Accuracy': acc} def validation_epoch_end (self، outputs): batch_losses = [x ['Loss'] for x in output] epoch_loss = torch.stack (batch_losses ) .mean () # الجمع بين الخسائر batch_accs = [x ['Accuracy'] لـ x في المخرجات] epoch_acc = torch.stack (batch_accs) .mean () # دمج دقة الإرجاع {'الخسارة': epoch_loss.item ()، ' الدقة ': epoch_acc.item ()} def epoch_end (self، epoch، result): pr int ("Epoch:"، epoch + 1) print (f'Train Accuracy: {result ["train_accuracy"] * 100: .2f}٪ Validation Accuracy: {result ["Accuracy"] * 100: .2f}٪ ' ) print (f'Train Loss: {result ["train_loss"] :. 4f} Validation Loss: {result ["Loss"] :. 4f} ')

كما يمكننا أن نرى هنا ، فقد استخدمنا تطبيق فئة ImageClassification وهو يأخذ معلمة واحدة وهي nn.Module. ضمن هذا الفصل ، يمكننا تنفيذ الوظائف المختلفة أو الخطوات المختلفة مثل التدريب والتحقق من الصحة وما إلى ذلك. الوظائف هنا هي تطبيقات بسيطة للبايثون.

تأخذ خطوة التدريب الصور والتسميات على دفعات. نستخدم الانتروبيا المتقاطعة لوظيفة الخسارة ونحسب الخسارة ونعيد الخسارة. هذا مشابه لخطوة التحقق كما نرى في الوظيفة. نهايات العصر تجمع بين الخسائر والدقة وأخيراً نطبع الدقة والخسائر.

تنفيذ وحدة الشبكة العصبية التلافيفية

فئة Cifar10CnnModel (ImageClassificationBase): def __init __ (self): super () .__ init __ () self.network = nn.Sequential (nn.Conv2d (3، 32، kernel_size = 3، padding = 1)، nn.ReLU ()، nn.Conv2d (32، 64، kernel_size = 3، stride = 1، padding = 1)، nn.ReLU ()، nn.MaxPool2d (2، 2)، # output: 64 x 16 x 16 nn.BatchNorm2d (64) ، nn.Conv2d (64، 128، kernel_size = 3، stride = 1، padding = 1)، nn.ReLU ()، nn.Conv2d (128، 128، kernel_size = 3، stride = 1، padding = 1)، nn .ReLU ()، nn.MaxPool2d (2، 2)، # output: 128 x 8 x 8 nn.BatchNorm2d (128)، nn.Conv2d (128، 256، kernel_size = 3، stride = 1، padding = 1) ، nn.ReLU ()، nn.Conv2d (256، 256، kernel_size = 3، stride = 1، padding = 1)، nn.ReLU ()، nn.MaxPool2d (2، 2)، # output: 256 x 4 x 4 nn.BatchNorm2d (256) ، nn.Flatten () ، nn الخطي (256 * 4 * 4 ، 1024) ، nn.ReLU () ، nn الخطي (1024 ، 512) ، nn.ReLU () ، nn الخطي (512 ، 10)) def إلى الأمام (ذاتي ، xb): إرجاع الشبكة الذاتية (xb)

هذا هو أهم جزء في تنفيذ الشبكة العصبية. طوال الوقت ، نستخدم وحدة nn التي قمنا باستيرادها من الشعلة. كما نرى في السطر الأول ، فإن Conv2d وحدة نمطية تساعد في تنفيذ شبكة عصبية تلافيفية. يمثل المعامل الأول 3 هنا أن الصورة ملونة وبتنسيق RGB. إذا كانت صورة ذات تدرج رمادي لكنا اخترنا 1.

32 هو حجم قناة الإخراج الأولية وعندما ننتقل إلى طبقة conv2d التالية ، سيكون لدينا 32 كقناة إدخال و 64 كقناة إخراج.

المعلمة الثالثة في السطر الأول تسمى حجم النواة وتساعدنا في الاهتمام بالفلاتر المستخدمة. عملية الحشو هي المعلمة الأخيرة.

عملية الالتواء متصلة بطبقة تنشيط و Relu هنا. بعد طبقتين Conv2d ، لدينا عملية تجميع قصوى بحجم 2 * 2. القيمة الخارجة من هذا يتم ضبطها على دفعات لتحقيق الاستقرار ولتجنب التحول المتغير الداخلي. تتكرر هذه العمليات مع طبقات أكثر لتعميق الشبكة وتقليل الحجم. أخيرًا ، قمنا بتسوية الطبقة حتى نتمكن من بناء طبقة خطية لتعيين القيم إلى 10 قيم. سيحدد احتمال كل خلية عصبية من هذه الخلايا العصبية العشرة الفئة التي تنتمي إليها صورة معينة بناءً على الاحتمال الأقصى.

درب النموذج

@ torch.no_grad () تقييم def (model ، data_loader): model.eval () outputs = [model.validation_step (دفعة) للدفعة في data_loader] نموذج الإرجاع. = 10 ، Learning_rate = 0.001): best_valid = بلا سجل = [] محسن = torch.optim.Adam (model.parameters () ، معدل التعلم ، weight_decay = 0.0005) للحقبة في النطاق (العهود): # نموذج طور التدريب. ) train_losses = [] train_accuracy = [] للدفعة في tqdm (train_loader): الخسارة ، accu = model.training_step (دفعة) train_losses.append (الخسارة) train_accuracy.append (accu) loss.backward () optimizer.step () محسن .zero_grad () # نتيجة مرحلة التحقق = نتيجة تقييم (نموذج ، val_loader) ['train_loss'] = torch.stack (train_losses) .mean (). item () نتيجة ['train_accuracy'] = torch.stack (train_accuracy). يعني (). item () model.epoch_end (epoch، result) if (best_valid == None or best_valid

history = fit (model، train_dl، val_dl)

هذه خطوة أساسية لتدريب نموذجنا للحصول على النتيجة المطلوبة. ستلائم وظيفة الملاءمة هنا بيانات القطار و Val مع النموذج الذي أنشأناه. تأخذ وظيفة الملاءمة في البداية قائمة تسمى المحفوظات تهتم ببيانات التكرار لكل حقبة. نقوم بتشغيل حلقة for حتى نتمكن من تكرارها على كل فترة. لكل دفعة ، نتأكد من إظهار التقدم باستخدام tqdm. نحن نسمي خطوة التدريب التي قمنا بتنفيذها من قبل ونحسب الدقة والخسارة. الانتقال للخلف ومحسن التشغيل الذي حددناه سابقًا. بمجرد القيام بذلك ، نتتبع قائمتنا وتساعدنا الوظائف في طباعة التفاصيل والتقدم.

من ناحية أخرى ، تستخدم وظيفة التقييم وظيفة Eval ، ولكل خطوة ، نأخذ الدُفعة التي تم تحميلها من مُحمل البيانات ، ويتم حساب المخرجات. ثم يتم تمرير القيمة إلى نهاية حقبة التحقق التي حددناها سابقًا ويتم إرجاع القيمة ذات الصلة.

رسم النتائج

في هذه الخطوة ، سوف نتخيل الدقة مقابل كل حقبة. يمكننا أن نلاحظ أنه مع زيادة العصر ، تستمر دقة النظام في الزيادة وبالمثل تستمر الخسارة في التناقص. يشير الخط الأحمر هنا إلى تقدم بيانات التدريب والأزرق للتحقق من الصحة. يمكننا أن نرى أنه كان هناك قدر كبير من التخصيص في نتائجنا لأن بيانات التدريب تتفوق تمامًا على نتيجة التحقق وبالمثل في حالة الخسارة. بعد 10 حقب ، يبدو أن بيانات القطار تتجاوز دقة 90 ٪ ولكنها تفقد حوالي 0.5. تأتي بيانات الاختبار حول 81٪ والخسائر قريبة من 0.2.

def plot_accuracies (history): Validation_accuracies = [x ['Accuracy'] لـ x in history] Training_Accuracies = [x ['train_accuracy'] لـ x in history] plt.plot (Training_Accuracies، '-rx') plt.plot (Validation_accuracies ، "-bx") plt.xlabel ("حقبة") plt.ylabel ("دقة") plt.legend (["تدريب" ، "التحقق من الصحة"]) plt.title ("الدقة مقابل عدد العصور") ؛ مؤامرة_ دقة (التاريخ)

def plot_losses (history): train_losses = [x.get ('train_loss') لـ x في التاريخ] val_losses = [x ['Loss'] لـ x في التاريخ] plt.plot (train_losses، '-bx') plt.plot (val_losses، '-rx') plt.xlabel ('epoch') plt.ylabel ('loss') plt.legend (['Training'، 'Validation']) plt.title ('الخسارة مقابل عدد العصور ') ؛ plot_losses (التاريخ)

test_dataset = ImageFolder (data_dir + '/ test'، transform = ToTensor ()) test_loader = DeviceDataLoader (DataLoader (test_dataset، batch_size)، device) النتيجة = التقييم (final_model، test_loader) print (f'Test Accuracy: {result ["Accuracy") ] * 100: .2f}٪ ')

دقة الاختبار: 81.07٪

يمكننا أن نرى أننا انتهينا بدقة تبلغ 81.07٪.

الخلاصة:

صورة: https: //unsplash.com/photos/5L0R8ZqPZHk

عني: أنا طالب باحث مهتم بمجال التعلم العميق ومعالجة اللغة الطبيعية وأتابع حاليًا التخرج في الذكاء الاصطناعي.

مصدر الصورة

Image 1: https://becominghuman.ai/cifar-10-image-classification-fd2ace47c5e8
الصورة 2: https://www.analyticsvidhya.com/blog/2021/05/convolutional-neural-networks-cnn/

لا تتردد في التواصل معي على: