Parte 0: función de pérdida

• La función de pérdida debe devolver valores altos para malas predicciones y valores bajos para buenas predicciones.

1.1 Definición

La entropía cruzada binaria se define como

donde y es la etiqueta ( 1 para puntos verdes y 0 para puntos rojos ) y p(y) es la probabilidad predicha de que el punto sea verde para todos los N puntos.

El perfil de la función de pérdida de registro se ve así:

1.2 Relación con la entropía y la entropía cruzada

Si milagrosamente hacemos coincidir p(y) con q(y) perfectamente , los valores calculados para la entropía cruzada y la entropía también coincidirán .

La diferencia entre entropía cruzada y entropía es la divergencia de Kullback-Leibler:

1.3 Implementar

A continuación, implementamos la entropía cruzada binaria tanto en sklearn como en 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 Referencia

• Comprender la entropía cruzada binaria / pérdida de registro: una explicación visual

2.1 Idea básica

Para calcular cuán similares son dos vectores, ¡calcula su producto escalar! Esta es también la idea básica del filtrado colaborativo.

S(y) es la salida de su función softmax. ¡L es la verdad fundamental!

2.2 Implementación

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