وظائف الخسارة في PyTorch

مقدمة

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

الأحداث المتوقعة

هذه المقالة تتطلب فهم الشبكات العصبية. على مستوى عالٍ ، تتكون الشبكات العصبية من نقاط مترابطة (“الخلايا العصبية”) التي تنظم في طبقات. وتتعلم وتقدم تخمينات عن طريق عملية “التمرين” التي تتنقل عبر الوزنات والمتغيرات المترابطة بين الخلايا العصبية. فهم الشبكات العصبية يشمل معرفة أطباقها المختلفة (طبقة الإدخال، الطبقات الخفية، طبقة الخارج)، والمعاملات التحفيزية، والخوارزميات التحسينية (أنواع متنوعة

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

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

وبعد أن حصلنا على تفسير عالي المستوى لما هو خسائر، دعونا نبحث عن أكثر تفاصيل تقنية حول كيفية عمل خسائر البيانات.

ما هي الخسائر البيانات؟

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

على الرغم من أن خسائر البيانات تعطينا معلومات حيوية عن أداء نموذجنا، لكنها ليست الوظيفة الرئيسية للخسائر، لأن هنالك تقنيات أكثر مرونة لتقييم نماذجنا، مثل الدقة والنسبات الـ F. أهمية خسائر البيانات تتم تحقيقها في التدريب على الأقل، حيث نهزم وزنات نموذجنا في الاتجاه الذي يقلل من الخسائر. بفعل ذلك، نرفع معدل

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

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

تلك المعاملات الخسارة في PyTorch

يأتي PyTorch مع عدد كبير من تلك المعاملات الأساسية مع تصميمات بسيطة تسمح للمطورين بتواجد تلك المعاملات المختلفة بسرعة كبيرة أثناء التدريب. كل تلك المعاملات الخسارة مُقَبِلة في وحدة nn في PyTorch وهي نوع أساسي لجميع الشبكات العصبية. هذا يجعل إضافة معاملة خسارة إلى مشروعك سهلًا بمجرد إضافة خط واحد من البرمجيات. دعونا ننظر إلى كيفية إضافة معاملة خسارة متوسط الخطأ في PyTorch.

import torch.nn as nn
MSE_loss_fn = nn.MSELoss()

يمكن استخدام ما يرجع من البرمجيات الأعلاه لحساب مدى تعقيد التنبؤ من خلال تقنية التعقيد تلو القيم الحقيقية في قالب المادة التالية.

#predicted_value هو التنبؤ من شبكة عصبينا
#target هو القيمة الحقيقية في قاعدتنا
#loss_value هو خسارة بين التنبؤ المقترح والقيمة الحقيقية
Loss_value = MSE_loss_fn(predicted_value, target)

لقد حصلنا على فكرة عن كيفية استخدام معاملات الخسارة في PyTorch، دعونا نغوص في ما يحدث خلف مرايا المعاملات الخسارة التي يقدمها PyTorch.

ما هي المعاملات الخسارة المتاحة في PyTorch?

معظم هذه المعاملات الخسارة التي يأتي مع PyTorch تختلف في التصنيف إلى ثلاثة أجيال – خسارة التقدم، خسارة التصنيف، وخسارة الترتيب.

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

معاملات الخسارة التصنيفية تتعلق بالقيم التي تختلف بينها، مثل مهمة تصنيف الأشياء كما إسماء الصناديق أو القلم أو القنينة.

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

معاملة خسارة L1 / خسارة الerror المعادي المتوسط

يقوم معادلة خسارة L1 بحساب الخطأ المعمولي بين كل قيمة في التensor المتوقع وتلك في الهدف. يقوم بحساب الاختلافات المصادفة بين كل قيمة في التensor المتوقع وتلك في الهدف، ومن ثم يحسب المجموع لجميع القيم التي تم استعمالها من خلال حساب الاختلافات المصادفة. وأخيرًا يحسب معدل هذه المجموعة للحصول على الخطأ المعمولي المتوسط (MAE). وهي واجهة خسارة L1 مرنة لمعالجة الضجيج.

import torch.nn as nn

#size_average and reduce are deprecated

#reduction specifies the method of reduction to apply to output. Possible values are 'mean' (default) where we compute the average of the output, 'sum' where the output is summed and 'none' which applies no reduction to output

Loss_fn = nn.L1Loss(size_average=None, reduce=None, reduction='mean')

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss_fn(input, target)
print(output) #tensor(0.7772, grad_fn=<L1LossBackward>)

القيمة الواحدة المترجمة هي الخسارة المحسوبة بين التensors المتوارين بأبعاد 3 بوصة 5 بوصة.

Mean Squared Error

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

import torch.nn as nn

loss = nn.MSELoss(size_average=None, reduce=None, reduction='mean')
# تفسير ما يلي عناصر معادلة خسارة L1.

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
print(output) # tensor(0.9823, grad_fn=<MseLossBackward>)

خسارة التعايش التحليلي

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

يتم تكوين طبقة الناعم من قسمين – أولاً ما يلي تكوين التخمينات للفئة المعينة.

yi هو نتيجة شبكة العمل العشو

import numpy as np

np.exp(34) #583461742527454.9
np.exp(-34) #1.713908431542013e-15

الجزء الثاني هو قيمة التنظيفة ويستخدم لضمان أن نتيجة طبقة الsoftmax دائمًا قيمة من الإحتمالات.

يحصل ذلك من خلال حوسبة مجموع الأعداد المصادر لكل قسم من التخصيص. يبدو المعادلة النهائية للsoftmax كما يلي:

]

في موديل الnn في PyTorch، يدمج الخسران المعاكس مع المخرج العامل المعاكس والخسران السلبي المعاكس (NLL) في وظيفة خسران واحدة.

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

خسران المعاكس السلبي (NLL)

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

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
الدخل له حجم N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
كل عنصر في الهدف يجب أن يكون 0 <= قيمة < C
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
مثال خسائر ثنائية أعماقية (يستخدم, على سبيل المثال, مع معايير الصور)
N, C = 5, 4
loss = nn.NLLLoss()
الدخل له حجم N x C x أعلى x أعراض
data = torch.randn(N, 16, 10, 10)
conv = nn.Conv2d(16, C, (3, 3))
m = nn.LogSoftmax(dim=1)
كل عنصر في الهدف يجب أن يكون 0 <= قيمة < C
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
print(output) تينسار (1.4892, معالجة التقليل = )

نقد NLLLoss — المستندات PyTorch 1.9.0

خسائر التوازي الثنائي

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

import torch.nn as nn

m = nn.Sigmoid()
loss = nn.BCELoss()
input = torch.randn(3, requires_grad=True)
target = torch.empty(3).random_(2)
output = loss(m(input), target)
print(output) تينسار (0.4198, معالجة التقليل = )

خسارة التعايش الثنائي مع المعلومات المستقبلية

ذكرنا في الأجزاء السابقة أن خسارة التعايش الثنائي تخرج عادةً من طبقة السجلويد لضمان أن تحصل على ما بين 0 و 1 للخروج. تتكامل خسارة التعايش الثنائي مع المعلومات المستقبلية هذين النواحين في طبقة واحدة فقط. ووفقًا للتوثيقات PyTorch, هذه نسخة أكثر مستقرةً رقميًا لأنها تستفيد من حيلة مجموعة الأسماك المستمرة.

import torch
import torch.nn as nn

target = torch.ones([10, 64], dtype=torch.float32)  # 64 فئات, حجم المجموعة = 10
output = torch.full([10, 64], 1.5)  # تنبؤ من نوعه (معلومات المستقبلية)
pos_weight = torch.ones([64])  # جميع الوزنات تساوي 1
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
loss = criterion(output, target)  # -log(sigmoid(1.5))
print(loss) #tensor(0.2014)

خسارة الل1 الناعم

تراكم الخسارة L1 الناعم يدمج منحنى من مادتي الخسارة MSE والخسارة MAE من خلال قيمة أولية هيوسية بتا. هذا المعايير تم عرضه في الورقة السريعة ل-Fast R-CNN. عندما يكون ما يختلف بين قيمة الحقيقة الأساسية وقيمة التنبؤ المتوقع أقل من بتا، يستخدم المعايير المقارنة مع الخسارة المكونة من المادة المتضاربة، مثل خسارة MSE. منحنى خسارة MSE هو منحنى متواصل ، وهذا يعني أن معدل التخفيض لكل قيمة الخسارة يختلف ويمكن الاستخدام في كل مكان. بالإضافة إلى ذلك، وعندما يخفض قيمة الخسارة ، يندرج التخفيض أيضًا، وهذا الأمر مفيد أثناء التنزل المتقارن. ومع ذلك فإن للقيمة الكبيرة تنفجر التخفيض، ولهذا السبب يتم تحويل المعايير إلى MAE، حيث يكون معدل التخفيض تقريبًا ثابت لكل قيمة الخسارة عندما يزيد ما يختلف بينه أكثر من بتا ويتم إلimination من التفجير المحتمل للتخفيض.

import torch.nn as nn

loss = nn.SmoothL1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)

print(output) #tensor(0.7838, grad_fn=<SmoothL1LossBackward>)

خسارة التكامل الزاوي

تلك الخسارة التي تستخدم في المهام المساوية والنصف-مساوية للقياس من التشابه بين المعطيات الإثنين. إنها تستخدم عندما يوجد حامل حقل إدخالي وحامل تسمية تحويل القيم تحتوي على قيم من 1 أو -1. إنها تستخدم في مشاكل تتضمن التكاملات الغير خطية والتعلم النصف-مساوي.

import torch
import torch.nn as nn

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)

hinge_loss = nn.HingeEmbeddingLoss()
output = hinge_loss(input, target)
output.backward()

print('input: ', input)
print('target: ', target)
print('output: ', output)

#input:  tensor([[ 1.4668e+00,  2.9302e-01, -3.5806e-01,  1.8045e-01,  #1.1793e+00],
#       [-6.9471e-05,  9.4336e-01,  8.8339e-01, -1.1010e+00,  #1.5904e+00],
#       [-4.7971e-02, -2.7016e-01,  1.5292e+00, -6.0295e-01,  #2.3883e+00]],
#       requires_grad=True)
#target:  tensor([[-0.2386, -1.2860, -0.7707,  1.2827, -0.8612],
#        [ 0.6747,  0.1610,  0.5223, -0.8986,  0.8069],
#        [ 1.0354,  0.0253,  1.0896, -1.0791, -0.0834]])
#output:  tensor(1.2103, grad_fn=<MeanBackward0>)

خسارة الترتيب بالحافة

تقع خسارة الترتيب بالحافة ضمن أنواع الخسارات التقدمية التي رئيسي هدفها، بخلف غيرها من تشكيلات الخسارات، هو قياس مسافة الترتيب بين مجموعة من المدخلات في قاعدة البيانات. تتمحور وظيفة خسارة الترتيب بالحافة حول معيارين وما يليهما التعريف الرقمي الذي يحمل إلا 1 أو -1. إذا كان التعريف 1، فإنه مفترض أن تكون المدخل الأول أعلى ترتيب من المدخل الثاني وإذا كان التعريف -1، فيمكن الافتراض أن المدخل الثاني يجب أن يكون أعلى ترتيب من المدخل الأول. هذه العلاقة تظهر بالمعادلة والبرمجيات التالية.

import torch.nn as nn

loss = nn.MarginRankingLoss()
input1 = torch.randn(3, requires_grad=True)
input2 = torch.randn(3, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:  tenssor([-1.1109,  0.1187,  0.9441], requires_grad=True)
#input2:  tensor([ 0.9284, -0.3707, -0.7504], requires_grad=True)
#output:  tensor(0.5648, grad_fn=<MeanBackward0>)

خسارة الفارز الثلاثي

هذا المعيار يقيس الشبه بين نقاط البيانات باستخدام توالي من عينات التعلم المدربة. التوالي يتضمن عينة المرشد، وعينة الموافقة، وعينة المعارضة. الهدف هو 1) حصل على المسافة بين العينة الموافقة والمرشد بقلة قدر ممكن، و2) حصل على المسافة بين المرشد والمعارضة تكون أكبر من القيمة المعينة بالمسافة بين العينة الموافقة والمرشد. عادةً، تختلف العينة الموافقة عن نفس الفئة التي تختلف عن العينة المعارضة. إذًا، من خلال استخدام هذه الوزنة، نحن نحاول استخدام خسارة الفارز الثلاثي للتنبؤ بقيمة عالية من الشبه بين العينة المرشدة والعينة الموافقة، وقيمة خفيفة من الشبه بين العينة المرشدة والعينة المعارضة.

import torch.nn as nn

triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2)
anchor = torch.randn(100, 128, requires_grad=True)
positive = torch.randn(100, 128, requires_grad=True)
negative = torch.randn(100, 128, requires_grad=True)
output = triplet_loss(anchor, positive, negative)
print(output)  #tensor(1.1151, grad_fn=<MeanBackward0>)

خسارة التعبير الزاوي

يقيس الخسارة التكوينية المقاربة المعادلة المقاربة بين معلوماتين x1 و x2 و تواريخ تعريفية y التي تحتوي على قيم 1 أو -1. يستخدم لقياس درجة تشابه المعلومتين أو عدم تشابههم.

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

import torch.nn as nn

loss = nn.CosineEmbeddingLoss()
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:  tensor([[ 1.2969e-01,  1.9397e+00, -1.7762e+00, -1.2793e-01, #-4.7004e-01,
#         -1.1736e+00],
#        [-3.7807e-02,  4.6385e-03, -9.5373e-01,  8.4614e-01, -1.1113e+00,
#          4.0305e-01],
#        [-1.7561e-01,  8.8705e-01, -5.9533e-02,  1.3153e-03, -6.0306e-01,
#          7.9162e-01]], requires_grad=True)
#input2:  tensor([[-0.6177, -0.0625, -0.7188,  0.0824,  0.3192,  1.0410],
#        [-0.5767,  0.0298, -0.0826,  0.5866,  1.1008,  1.6463],
#        [-0.9608, -0.6449,  1.4022,  1.2211,  0.8248, -1.9933]],
#       requires_grad=True)
#output:  tensor(0.0033, grad_fn=&

خسارة الانفراد الكلبك-ليبلر

عندما تعطينا نسق معين من التوزيعات، بوجد توزيع P و Q، يقيس الخسارة الكلبك-ليبلر (KL) الإنفراد كم يمكن أن يخسر المعلومات عندما يحل محل P (وهو ما نعتقد أنه التوزيع الحقيقي) بوجود Q. من خلال قياس مقدار المعلومات التي يخسرها عند استخدام Q لتقريب P، يمكننا أن نحصل على ما يماثل بين P و Q، وبذلك نقود خوارزميتنا لإنتاج توزيع قريب جداً من التوزيع الحقيقي، P. خسارة المعلومات عند استخدام Q لتقريب P لا تماثل عند استخدام P لتقريب Q، وبالتالي ليس الانفراد الكلبك-ليبلر متجانس.

import torch.nn as nn

loss = nn.KLDivLoss(size_average=None, reduce=None, reduction='mean', log_target=False)
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
output = loss(input1, input2)

print('output: ', output) #tensor(-0.0284, grad_fn=<KlDivBackward>)

بناء وصفة خسارة مختصرة

يوفر بينورك لنا طريقتين محددتين لبناء وصفة خسارة خاصة بحلولنا؛ وهي إستخدام تعريف تقني وإستخدام وصفة تقنية. دعونا نرى كيف يمكننا تنفيذ كلا الطرق بدءاً من تنفيذ الوصفة التقنية.

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

def custom_mean_square_error(y_predictions, target):
  square_difference = torch.square(y_predictions - target)
  loss_value = torch.mean(square_difference)
  return loss_value

في البرمجيات السابقة، قمنا بتعريف خاصة الخسارة للحساب معدل الخسارة المعتاد بموجه تخمين وموجه هدف.

y_predictions = torch.randn(3, 5, requires_grad=True);
target = torch.randn(3, 5)
pytorch_loss = nn.MSELoss();
p_loss = pytorch_loss(y_predictions, target)
loss = custom_mean_square_error(y_predictions, target)
print('custom loss: ', loss)
print('pytorch loss: ', p_loss)

#custom loss:  tensor(2.3134, grad_fn=<MeanBackward0>)
#pytorch loss:  tensor(2.3134, grad_fn=<MseLossBackward>)

يمكننا حساب الخسارة بواسطة خاصة معدل الخسارة ومعدل PyTorch الخاص بلوس للمعيار المتوسط للخسارة للتأكد من أننا حصلنا على نفس النتائج.

خسارة خاصة مع Python Classes

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

class Custom_MSE(nn.Module):
  def __init__(self):
    super(Custom_MSE, self).__init__();

  def forward(self, predictions, target):
    square_difference = torch.square(predictions - target)
    loss_value = torch.mean(square_difference)
    return loss_value
  
  def __call__(self, predictions, target):
     square_difference = torch.square(y_predictions - target)
     loss_value = torch.mean(square_difference)
     return loss_value

آخر أفكار

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