Cross Entropy
Entropy
Entropy๋ self-information์ ํ๊ท
What is self-information?
Within the context of information theory, self-information is defined as the amount of information that knowledge about (the outcome of) a certain event, adds to someoneโs overall knowledge. The amount of self-information is expressed in the unit of information: a bit.
https://psychology.wikia.org/wiki/Self-information
์ ๋ณด์ด๋ก ์ ํต์ฌ ์์ด๋์ด๋ ์ ์ผ์ด๋์ง ์๋ ์ฌ๊ฑด(unlikely event)์ ์์ฃผ ๋ฐ์ํ๋ ์ฌ๊ฑด๋ณด๋ค ์ ๋ณด๋์ด ๋ง๋ค(informative)๋ ๊ฒ์ ๋๋ค. ์์ปจ๋ โ์์นจ์ ํด๊ฐ ๋ฌ๋คโ๋ ๋ฉ์ธ์ง๋ก ๋ณด๋ผ ํ์๊ฐ ์์ ์ ๋๋ก ์ ๋ณด ๊ฐ์น๊ฐ ์์ต๋๋ค. ๊ทธ๋ฌ๋ โ์ค๋ ์์นจ์ ์ผ์์ด ์์๋คโ๋ ๋ฉ์ธ์ง๋ ์ ๋ณด๋ ์ธก๋ฉด์์ ๋งค์ฐ ์ค์ํ ์ฌ๊ฑด์ ๋๋ค. ์ด ์์ด๋์ด๋ฅผ ๊ณต์ํํด์ ํํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์์ฃผ ๋ฐ์ํ๋ ์ฌ๊ฑด์ ๋ฎ์ ์ ๋ณด๋์ ๊ฐ์ง๋ค. ๋ฐ์์ด ๋ณด์ฅ๋ ์ฌ๊ฑด์ ๊ทธ ๋ด์ฉ์ ์๊ด์์ด ์ ํ ์ ๋ณด๊ฐ ์๋ค๋ ๊ฑธ ๋ปํ๋ค.
- ๋ ์์ฃผ ๋ฐ์ํ๋ ์ฌ๊ฑด์ ๋ ๋์ ์ ๋ณด๋์ ๊ฐ์ง๋ค.
- ๋ ๋ฆฝ์ฌ๊ฑด(independent event)์ ์ถ๊ฐ์ ์ธ ์ ๋ณด๋(additive information)์ ๊ฐ์ง๋ค. ์์ปจ๋ ๋์ ์ ๋์ ธ ์๋ฉด์ด ๋๋ฒ ๋์ค๋ ์ฌ๊ฑด์ ๋ํ ์ ๋ณด๋์ ๋์ ์ ๋์ ธ ์๋ฉด์ด ํ๋ฒ ๋์ค๋ ์ ๋ณด๋์ ๋ ๋ฐฐ์ด๋ค.
๊ฐ ์ฌ๊ฑด์ ๋ํด์ ์ ๋ณด์ ์(ํ๋ฅ ๋ณ์)์ ๋ํ ๊ธฐ๋๊ฐ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
\[i(A) = log_b({1\over P(A)}) = -log_b{P(A)}\]b: ์ ๋ณด์ ๋จ์ ๋ณดํต e๋ฅผ ์ฌ์ฉํ๋ค.
Entropy:
\[H(X) = \sum_j{P(A_j)i(A_j)} = -\sum{P(A_j)log_2P(A_j)}\]Cross Entropy
Cross Entropy๋ Deep Learning์์ ์ฃผ๋ก Loss Function์ผ๋ก ์ฌ์ฉ๋๋ค.
๋ค์ ํ๋ฅ ์์์ CrossEntropy๋ฅผ ๋ณด์.
P์ Q๋ผ๋ ํ๋ฅ ๋ถํฌ๊ฐ ์กด์ฌํ ๋์ ํฌ๋ก์ค ์ํธ๋กํผ๋ ์ด๋ค ์๋ฏธ์ธ๊ฐ.
ํฌ๋ก์ค ์ํธ๋กํผ (P, Q):
Q์ ์ํฉ์์์ ์๊ธฐ์ ๋ณด(A)๊ฐ ์ค์ P ์์์ P์ ํ๋ฅ ๋ก ๋ํ๋์ ๋์ ๊ธฐ๋๊ฐ.
Cross Entropy๋ฅผ ์ฌ์ฉํด์ P์ Q์ ํ๋ฅ ๋ถํฌ๋ฅผ ๋น๊ตํ๋ค.
P๋ ground truth๋ผ๊ณ ๋ณด๋ฉด ๋๊ณ , Q๋ ์์ธก๊ฐ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
๋ณดํต DL์ ํ ๋ label์ ohe๋ฅผ ์ํด๋ output๊ณผ label์ ์
๋ ฅํ๋ฉด,
pytorch CrossEntropy ํด๋์ค์์ ์๋์ผ๋ก ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
ํ์ดํ ์น ๊ธฐ์ค์ผ๋ก๋ BinaryCrossEntropy, CrossEntropy ํด๋์ค๊ฐ ์กด์ฌํ๋ค.
Pytorch CrossEntropy
ํ์ดํ ์น ๊ณต์๋ฌธ์์ ๋์จ ์์
import torch
import torch.nn as nn
loss = nn.CrossEntropyLoss()
data = torch.randn(3, 5, requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)
print(data)
print(target)
output = loss(data, target)
print(output)
output.backward()
output
tensor([[ 0.1449, -0.5543, -0.1170, -1.3969, -0.1700],
[ 0.1715, 1.0151, 0.6917, 1.4723, -0.3305],
[ 0.7153, 1.7428, -0.7265, -0.5458, 0.1957]], requires_grad=True)
tensor([2, 4, 1])
tensor(1.5741, grad_fn=<NllLossBackward>)
network๋ฅผ ๋๊ณ ๋์ค๋ฉด class ๊ฐ์ ๋งํผ output์ผ๋ก ๋์จ๋ค.
์์ ์์๋ target์ผ๋ก 3๊ฐ์ ๋ฐ์ดํฐ๋ง ์ฃผ์ด์ง ๊ฒ์ด๋ค.
data tensor์ ์๋ ๊ฐ ํ๋ง๋ค target์ ๊ฐ element๊ฐ ๋์ํ๋ค.
zero indexing์ด๊ธฐ ๋๋ฌธ์ ์ฒซ ํ์ tensor๋ 3๋ฒ์งธ ๋ฐ์ดํฐ์ธ -0.1170์ ๊ฐ์ฅ ์ต๋๋ก ํ๋ ๊ฐ์ผ๋ก ์
๋ฐ์ดํธ ๋ ๊ฒ์ด๋ค.
https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html
Leave a comment