Часть 0: Функция потерь

• Функция потерь должна возвращать высокие значения для плохих прогнозов и низкие значения для хороших прогнозов.

1.1 Определение

Бинарная кросс-энтропия определяется как

где y - метка ( 1 для зеленых точек и 0 для красных точек), а p (y) - прогнозируемая вероятность того, что точка станет зеленой для всех N точек.

Профиль функции потери журнала выглядит так:

1.2 Связь с энтропией и кросс-энтропией

Если мы каким-то чудом сопоставим p (y) с q (y) идеально , вычисленные значения перекрестной энтропии и энтропии также будут совпадать .

Разница между кросс-энтропией и энтропией - это дивергенция Кульбака-Лейблера:

1.3 Реализация

Далее мы реализуем двоичную кросс-энтропию как в sklearn, так и в pytorch.

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss
import numpy as np
x = np.array([-2.2, -1.4, -.8, .2, .4, .8, 1.2, 2.2, 2.9, 4.6])
y = np.array([0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
logr = LogisticRegression(solver='lbfgs')
logr.fit(x.reshape(-1, 1), y)
y_pred = logr.predict_proba(x.reshape(-1, 1))[:, 1].ravel()
loss = log_loss(y, y_pred)
print('x = {}'.format(x))
print('y = {}'.format(y))
print('p(y) = {}'.format(np.round(y_pred, 2)))
print('Log Loss / Cross Entropy = {:.4f}'.format(loss))
import torch.nn as nn
import torch
loss = nn.BCELoss()
a = torch.from_numpy(y_pred)
b = torch.from_numpy(y)
output = loss(a, b)
print('Log Loss from pytorch = {:.4f}'.format(output))

import torch.nn as nn
import torch
loss = nn.BCELoss()
m = nn.Sigmoid()
input = torch.randn(3)
y = np.array([0.9])
y_pred = y
a = torch.from_numpy(y_pred)
b = torch.from_numpy(y)
output = loss(a, b)
print(output)

-0.9*np.log(0.9)-0.1*np.log(0.1)

1.4 Ссылка

• Понимание двоичной кросс-энтропии / потери журнала: визуальное объяснение

2.1 Основная идея

Чтобы вычислить, насколько похожи два вектора, вычислите их скалярное произведение! Это также основная идея совместной фильтрации.

S (y) - это результат вашей функции softmax. L - чистая правда!

2.2 Реализация

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

class CrossEntropyLoss2d(nn.Module):
    
    def __init__(self):
        super(CrossEntropyLoss2d, self).__init__()
        self.nll_loss = nn.NLLLoss() #nn.NLLLoss2d()
   def forward(self, inputs, targets):
        # input: (n, c, h, w), target: (n, h, w)
        return self.nll_loss(F.log_softmax(inputs), targets)
if __name__ == "__main__":
    import torch
    x = torch.Tensor([[[1,2,1],
                       [2,3,1],
                       [0, 1,1]],
                      [[0, 1, 3],
                       [2, 3, 1],
                       [0, 0, 1]],
                      [[0,1,3],
                       [2,3,1],
                       [0, 0,1]]])
    x = x.view(1, 3, 3, 3)
    print(x.shape)
    import torch.nn as nn
    soft = nn.LogSoftmax(dim=1)(x)
    print(soft.shape)
    y = torch.LongTensor([[2,0,1],[0,0,1],[1,1,1]])
    y = y.view(1,3,3)
    loss = nn.NLLLoss2d()
    out = loss(soft,y)
    print(out)
    a_fun = CrossEntropyLoss2d()
    print(a_fun(x,y))