פונקציותד של PyTorch

קדמה

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

דרישות קדמות

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

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

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

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

מהן פונקציות אובדן?

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

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

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

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

פונקציות אובדן ב-PyTorch

PyTorch מגיעה עם הרבה פונקציות אובדן קאנוניות עם דפוסי עיצוב פשוטים שמאפשרים למפתחים לחזור בקלות על פונקציות האובדן השונות במהלך האימון. כל פונקציות האובדן של PyTorch ארוזות במודול nn, המחלקה הבסיסית של PyTorch לכל רשתות העצבים. זה הופך את הוספת פונקציית אובדן לפרויקט שלך לפשוטה כמו הוספת שורת קוד אחת. בואו נראה איך להוסיף פונקציית אובדן של שגיאה ריבועית ממוצעת (Mean Squared Error) ב-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 מוקטפים באופן רחב לשלושה קבוצות – פערי הריסוק, פערי הקלASSIFICATION ופערי הרינקING.

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

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

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

פער הL1 / השגיאה הממוצעת המושלמת

הפונקציית האבעבועה L1 מחשבת את הטעות הממוצעת הבסיסית בין כל ערך בטensor הצפוי לערך בטensor המטרה. היא ראשית מחשבת את ההבדל הבסיסי בין כל ערך בט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

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

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 היא היוצאה של הרשת למינה ספציפי. היוצא של הפעילות הזו הוא מספר קרוב לאפס, אך ורק אם yi גדול ושלילי, וק

import numpy as np

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

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

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

]

במודל של PyTorch, הפסד המעברי משתלב את השכבה הרכזית ואת הפסד השגרה (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, grad_fn=<NllLoss2DBackward>)

ציון 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, grad_fn=<BinaryCrossEntropyBackward>)

אפסי קריסון הצטברי הבינארי עם לוגיטס

הזכרנו בסECTION הקודמת שאפסי הקריסון הבינארי הוא בדרך כלל יוצא בעזרת שכבה סיגמואידית כדי לוודא שהיציאה נמצאת בין 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 דרך ערך היסטורי בתגיות beta. הקריטריון נאסף בעבודת המאמר של Fast R-CNN. כשההבדל הבסיסי בין הערך האמתי והערך הצפוי הוא מתחת לבתגיות beta, הקריטריון משתמש בהבדל הריבועי, דומה לאובייקט האיבוד MSE. הגרף של אובייקט האיבוד MSE הוא קו מתמשך, מה שאומר שהשיפוע עבור כל ערך האיבוד משתנה וניתן להוציא אותו בכל מקום. בנוסף, כשהערך האיבוד נפלט, השיפוע נדלה, מה שנוח בזמן ההתקדמות השיפועית. אך בערכים האיבוד הגדולים מדי, השיפוע מתפוצץ, לכן הקריטריון מעבר לMAE, בו השיפוע כמעט מובך לאורך של כל ערך האיבוד, כשההבדל הבסיסי הוא יותר גדול מבתגיות beta והאפשרות להתפוצצות השיפוע המעברת לבעלת היתרון.

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:  טנסור שלם של [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:  טנסור שלם של [-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:  טנסור של 1.2103, עם פונקציית חזרה ממונע ממוצע

איבדן רישום מרגיעה

איבדן רישום מרגיעה הוא סוג של איבדן רישומים שהמטרה שלו, שונה מכל סוג של פונקציית איבדן, היא למדוד את המרחק היחסי בין סט של קלטות במאגר נתונים. פונקציית איבדן הרישום המרגיעה לוקחת שני קלטות ותג שמונחת רק על 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:  טנסורט של [-1.1109,  0.1187,  0.9441], דרוש גיבוי=True
#input2:  טנסורט של [ 0.9284, -0.3707, -0.7504], דרוש גיבוי=True
#output:  טנסורט של 0.5648, גיבוי חזרה=<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)  #טנסורט של 1.1151, גיבוי חזרה=<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=<MeanBackward0>)

אובדן הדיברסציה של קולבאק-לייבלר

לפי שתי התפקידים, P ו-Q, אובדן הדיברסציה של קולבאק-לייבלר (קל) מודד כמה מידע נאבד כש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>)

בניית פונקציית אובדן מותאמת

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

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

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

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

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>)

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

פעולה הפסד מותאמת עם קבוצות פינקס במערך פיוני

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

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

מחשבות סופיות

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