دروس PyTorch

ملخص البرنامج التعليمي Pytorch

في هذا البرنامج التعليمي لـ Pytorch، ستتعلم كل المفاهيم من الصفر. يغطي هذا البرنامج التعليمي مواضيع أساسية ومتقدمة مثل تعريف Pytorch، ومزايا وعيوب Pytorch، والمقارنة، والتثبيت، وإطار عمل Pytorch، والانحدار، وتصنيف الصور. هذا البرنامج التعليمي لـ Pytorch مجاني تمامًا.

ما هو PyTorch؟

PyTorch هي مكتبة تعلم آلي مفتوحة المصدر تعتمد على Torch لمعالجة اللغة الطبيعية باستخدام Python. إنه مشابه لـ NumPy ولكن مع دعم قوي لوحدة معالجة الرسومات. فهو يقدم رسومًا بيانية حسابية ديناميكية يمكنك تعديلها أثناء التنقل بمساعدة autograd. يعد PyTorch أيضًا أسرع من بعض الأطر الأخرى. تم تطويره من قبل مجموعة أبحاث الذكاء الاصطناعي التابعة لفيسبوك في عام 2016.

مميزات وعيوب PyTorch

فيما يلي مزايا وعيوب PyTorch:

مزايا باي تورش

مكتبة بسيطة
كود PyTorch بسيط. فمن السهل أن نفهم، ويمكنك استخدام المكتبة على الفور. على سبيل المثال، ألقِ نظرة على مقتطف الشفرة أدناه:

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

كما ذكرنا أعلاه، يمكنك تحديد نموذج الشبكة بسهولة، ويمكنك فهم الكود بسرعة دون الكثير من التدريب.

الرسم البياني الحسابي الديناميكي

مصدر الصورة: استكشاف التعلم العميق باستخدام PyTorch

تقدم Pytorch رسمًا بيانيًا حسابيًا ديناميكيًا (DAG). الرسوم البيانية الحسابية هي طريقة للتعبير عن التعبيرات الرياضية في نماذج أو نظريات الرسم البياني مثل العقد والحواف. ستقوم العقدة بالعملية الحسابية، والحافة عبارة عن Tensor سيتم إدخالها في العقد وتحمل مخرجات العقدة في Tensor.

DAG عبارة عن رسم بياني يحمل شكلًا عشوائيًا وقادرًا على إجراء عمليات بين رسوم بيانية إدخال مختلفة. في كل تكرار، يتم إنشاء رسم بياني جديد. لذا، من الممكن أن يكون لدينا نفس بنية الرسم البياني أو إنشاء رسم بياني جديد بعملية مختلفة، أو يمكننا تسميته رسمًا بيانيًا ديناميكيًا.

أفضل أداء

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

كما ترون أدناه، مقارنة الرسوم البيانية مع vgg16 وresnet152

محلي Python

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

تطبق Pytorch أيضًا البرمجة الحتمية، وهي بالتأكيد أكثر مرونة. لذلك، من الممكن طباعة قيمة الموتر في منتصف عملية الحساب.

مساوئ PyTorch

يتطلب PyTorch تطبيقات خارجية للتصور. كما يحتاج أيضًا إلى خادم API للإنتاج.

بعد ذلك في هذا البرنامج التعليمي PyTorch، سنتعرف على الفرق بين PyTorch وTensorFlow.

باي تورتش مقابل. Tensorflow

معامل	PyTorch	Tensorflow
تعريف النموذج	يتم تعريف النموذج في فئة فرعية ويقدم حزمة سهلة الاستخدام	يتم تعريف النموذج بالعديد، وتحتاج إلى فهم بناء الجملة
دعم GPU	نعم	نعم
نوع الرسم البياني	التفاعل	ساكن
الأدوات	لا توجد أداة التصور	يمكنك استخدام أداة التصور Tensorboard
المجتمع	المجتمع لا يزال ينمو	مجتمعات نشطة كبيرة

تثبيت PyTorch

لينكس

من السهل تثبيته في Linux. يمكنك اختيار استخدام بيئة افتراضية أو تثبيتها مباشرة من خلال الوصول إلى الجذر. اكتب هذا الأمر في المحطة

pip3 install --upgrade torch torchvision

AWS ساجيماكر

Sagemaker هي إحدى المنصات الموجودة في Amazon خدمة ويب يوفر محركًا قويًا للتعلم الآلي مزودًا بتكوينات التعلم العميق المثبتة مسبقًا لعالم البيانات أو المطورين لإنشاء النماذج وتدريبها ونشرها على أي نطاق.

أولا افتح ملف Amazon ساجيماكر انتقل إلى وحدة التحكم وانقر على إنشاء مثيل دفتر الملاحظات وقم بملء جميع التفاصيل الخاصة بدفتر الملاحظات الخاص بك.

الخطوة التالية، انقر فوق فتح لتشغيل مثيل الكمبيوتر الدفتري الخاص بك.

وأخيرا، في Jupyter، انقر فوق "جديد" واختر conda_pytorch_p36 وستكون جاهزًا لاستخدام مثيل الكمبيوتر المحمول الخاص بك مع تثبيت Pytorch.

بعد ذلك في هذا البرنامج التعليمي لـ PyTorch، سنتعرف على أساسيات إطار عمل PyTorch.

أساسيات إطار عمل PyTorch

دعنا نتعرف على المفاهيم الأساسية لـ PyTorch قبل أن نتعمق أكثر. يستخدم PyTorch Tensor لكل متغير مشابهًا لـ ndarray الخاص بـ numpy ولكن مع دعم حساب GPU. هنا سنشرح نموذج الشبكة ودالة الخسارة وBackprop وOptimizer.

نموذج الشبكة

يمكن إنشاء الشبكة عن طريق التصنيف الفرعي torch.nn. هناك 2 أجزاء رئيسية،

الجزء الأول هو تحديد المعلمات والطبقات التي ستستخدمها
الجزء الثاني هو المهمة الرئيسية التي تسمى العملية الأمامية التي ستأخذ مدخلات وتتنبأ بالمخرجات.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

كما ترون أعلاه، يمكنك إنشاء فئة من nn.Module تسمى Model. يحتوي على طبقتين Conv2d وطبقة خطية. الطبقة conv2d الأولى تأخذ مدخلاً 2 وشكل الإخراج 3. الطبقة الثانية ستأخذ مدخلاً 20 وستنتج شكل مخرجات 20. الطبقة الأخيرة هي طبقة متصلة بالكامل على شكل 40 وستنتج الناتج 320.

ستأخذ العملية الأمامية مدخلات X وتغذيها إلى طبقة conv1 وتؤدي وظيفة ReLU،

وبالمثل، سيتم أيضًا تغذية طبقة conv2. بعد ذلك، سيتم إعادة تشكيل x إلى (-1، 320) وإدخالها في طبقة FC النهائية. قبل إرسال الإخراج، ستستخدم وظيفة تنشيط softmax.

يتم تعريف العملية الخلفية تلقائيًا عن طريق الترقية التلقائية، لذلك ما عليك سوى تحديد العملية الأمامية.

فقدان وظيفة

تُستخدم دالة الخسارة لقياس مدى قدرة نموذج التنبؤ على التنبؤ بالنتائج المتوقعة. لدى PyTorch بالفعل العديد من وظائف الخسارة القياسية في وحدة torch.nn. على سبيل المثال، يمكنك استخدام Cross-Entropy Loss لحل مشكلة تصنيف PyTorch متعددة الفئات. من السهل تحديد دالة الخسارة وحساب الخسائر:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

من السهل استخدام حساب دالة الخسارة الخاصة بك مع PyTorch.

دعامة خلفية

لإجراء الانتشار العكسي، ما عليك سوى استدعاء التابع los.backward()‎. سيتم حساب الخطأ ولكن تذكر مسح التدرج الموجود باستخدام Zero_grad()

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

محسن

يوفر torch.optim خوارزميات تحسين شائعة. يمكنك تعريف مُحسِّن من خلال خطوة بسيطة:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

تحتاج إلى تمرير معلمات نموذج الشبكة ومعدل التعلم بحيث يتم تحديث المعلمات عند كل تكرار بعد عملية الدعم الخلفي.

الانحدار البسيط مع PyTorch

دعونا نتعلم الانحدار البسيط باستخدام أمثلة PyTorch:

الخطوة 1) إنشاء نموذج شبكتنا

نموذج شبكتنا عبارة عن طبقة خطية بسيطة ذات شكل مدخلات ومخرجات يساوي 1.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

وينبغي أن يكون إخراج الشبكة مثل هذا

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

الخطوة 2) بيانات الاختبار

قبل أن تبدأ عملية التدريب، عليك أن تعرف بياناتنا. يمكنك إنشاء وظيفة عشوائية لاختبار نموذجنا. ص = س³ الخطيئة (س) + 3س + 0.8 راند (100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

هنا هو مخطط مبعثر من وظيفتنا:

قبل أن تبدأ عملية التدريب، تحتاج إلى تحويل المصفوفة numpy إلى متغيرات يدعمها Torch وautograd كما هو موضح في مثال انحدار PyTorch أدناه.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

الخطوة 3) المحسن والخسارة

بعد ذلك، يجب عليك تحديد المُحسِّن ووظيفة الخسارة لعملية التدريب لدينا.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

الخطوة 4) التدريب

الآن لنبدأ عملية التدريب لدينا. في فترة زمنية تبلغ 250 عامًا، ستقوم بتكرار بياناتنا للعثور على أفضل قيمة لمعلماتنا الفائقة.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

الخطوة 5) النتيجة

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

مثال لتصنيف الصور باستخدام PyTorch

إحدى الطرق الشائعة لتعلم أساسيات التعلم العميق توجد مجموعة بيانات MNIST. وهي بمثابة "Hello World" في التعلم العميق. تحتوي مجموعة البيانات على أرقام مكتوبة بخط اليد من 0 إلى 9 بإجمالي 60,000 عينة تدريب و10,000 عينة اختبار مُسمَّاة بالفعل بحجم 28×28 بكسل.

الخطوة 1) المعالجة المسبقة للبيانات

في الخطوة الأولى من مثال تصنيف PyTorch هذا، ستقوم بتحميل مجموعة البيانات باستخدام وحدة torchvision.

قبل أن تبدأ عملية التدريب، عليك أن تفهم البيانات. ستقوم Torchvision بتحميل مجموعة البيانات وتحويل الصور مع المتطلبات المناسبة للشبكة مثل الشكل وتطبيع الصور.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

تقوم وظيفة التحويل بتحويل الصور إلى موتر وتطبيع القيمة. ستقوم الوظيفة torchvision.transforms.MNIST بتنزيل مجموعة البيانات (إذا لم تكن متوفرة) في الدليل، وتعيين مجموعة البيانات للتدريب إذا لزم الأمر وإجراء عملية التحويل.

لتصور مجموعة البيانات، يمكنك استخدام data_iterator للحصول على الدفعة التالية من الصور والتسميات. يمكنك استخدام matplot لرسم هذه الصور والتسمية المناسبة لها. كما ترون أدناه صورنا وتسمياتها.

الخطوة 2) تكوين نموذج الشبكة

الآن في مثال PyTorch هذا، ستقوم بإنشاء شبكة عصبية بسيطة لتصنيف صور PyTorch.

نقدم لك هنا طريقة أخرى لإنشاء نموذج الشبكة في PyTorch. سوف نستخدم nn.Sequential لإنشاء نموذج تسلسلي بدلاً من إنشاء فئة فرعية من nn.Module.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

هنا هو إخراج نموذج شبكتنا

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

شرح الشبكة

التسلسل هو أن الطبقة الأولى هي طبقة Conv2D مع شكل إدخال 1 وشكل إخراج 10 وحجم نواة 5
بعد ذلك، لديك طبقة MaxPool2D
وظيفة تفعيل ReLU
طبقة التسرب لإسقاط قيم الاحتمالية المنخفضة.
ثم Conv2d ثاني بشكل الإدخال 10 من الطبقة الأخيرة وشكل الإخراج 20 بحجم النواة 5
التالي طبقة MaxPool2d
وظيفة تنشيط ReLU.
بعد ذلك، سوف تقوم بتسوية الموتر قبل إدخاله في الطبقة الخطية
ستقوم الطبقة الخطية بتعيين مخرجاتنا في الطبقة الخطية الثانية باستخدام وظيفة تنشيط softmax

الخطوة 3) تدريب النموذج

قبل البدء في عملية التدريب، يلزم إعداد وظيفة المعيار والمحسن.

بالنسبة للمعيار، ستستخدم CrossEntropyLoss. بالنسبة للمحسن، ستستخدم SGD بمعدل تعلم 0.001 وزخم 0.9 كما هو موضح في مثال PyTorch أدناه.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

ستأخذ العملية الأمامية شكل الإدخال وتمريره إلى طبقة conv2d الأولى. ومن هناك، سيتم إدخاله إلى maxpool2d ووضعه أخيرًا في وظيفة تنشيط ReLU. ستحدث نفس العملية في طبقة conv2d الثانية. بعد ذلك، سيتم إعادة تشكيل المدخلات إلى (-1,320) وتغذيتها في طبقة FC للتنبؤ بالمخرجات.

الآن سوف تبدأ عملية التدريب. سوف تقوم بالتكرار من خلال مجموعة البيانات الخاصة بنا مرتين أو بفترة 2 وطباعة الخسارة الحالية في كل 2 دفعة.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

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

وهنا نتائج عملية التدريب

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

الخطوة 4) اختبار النموذج

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

سنستخدم مُكررًا لـ test_loader، وسيقوم بإنشاء مجموعة من الصور والعلامات التي سيتم تمريرها إلى النموذج المُدرَّب. سيتم عرض الناتج المتوقع ومقارنته بالناتج المتوقع.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

ملخص

PyTorch هو برنامج Torch مفتوح المصدر تعلم آلة مكتبة ل معالجة اللغة الطبيعية استخدام Python.
مزايا PyTorch: 1) مكتبة بسيطة، 2) الرسم البياني الحسابي الديناميكي، 3) أداء أفضل، 4) أصلي Python
يستخدم PyTorch Tensor لكل متغير مشابه لـ numpy's ndarray ولكن مع دعم حساب GPU.
إحدى الطرق الشائعة لتعلم أساسيات التعلم العميق هي استخدام مجموعة بيانات MNIST.

دروس PyTorch

ملخص البرنامج التعليمي Pytorch

ما هو PyTorch؟

مميزات وعيوب PyTorch

مزايا باي تورش

مساوئ PyTorch

باي تورتش مقابل. Tensorflow

تثبيت PyTorch

لينكس

AWS ساجيماكر

أساسيات إطار عمل PyTorch

نموذج الشبكة

فقدان وظيفة

دعامة خلفية

محسن

الانحدار البسيط مع PyTorch

مثال لتصنيف الصور باستخدام PyTorch

شرح الشبكة

ملخص

تلخيص هذه التدوينة بـ:

اشترك في النشرة الإخبارية

ملخص البرنامج التعليمي Pytorch

ما هو PyTorch؟

مميزات وعيوب PyTorch

مزايا باي تورش

مساوئ PyTorch

ذات المواد

باي تورتش مقابل. Tensorflow

تثبيت PyTorch

لينكس

AWS ساجيماكر

أساسيات إطار عمل PyTorch

نموذج الشبكة

فقدان وظيفة

دعامة خلفية

محسن

ذات المواد

الانحدار البسيط مع PyTorch

مثال لتصنيف الصور باستخدام PyTorch

شرح الشبكة

ملخص

تلخيص هذه التدوينة بـ:

اشترك في النشرة الإخبارية