BCE WithLogitsLoss 샘플 불 균형 처리 방안
6764 단어 BCEWithLogitsLoss견본불 균형
본 견본 의 loss 가중치 를 높 여 BCE WithLogitsLoss 의 소스 코드 를 보 려 고 시도 합 니 다.
Examples::
>>> target = torch.ones([10, 64], dtype=torch.float32) # 64 classes, batch size = 10
>>> output = torch.full([10, 64], 0.999) # A prediction (logit)
>>> pos_weight = torch.ones([64]) # All weights are equal to 1
>>> criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
>>> criterion(output, target) # -log(sigmoid(0.999))
tensor(0.3135)
Args:
weight (Tensor, optional): a manual rescaling weight given to the loss
of each batch element. If given, has to be a Tensor of size `nbatch`.
size_average (bool, optional): Deprecated (see :attr:`reduction`). By default,
the losses are averaged over each loss element in the batch. Note that for
some losses, there are multiple elements per sample. If the field :attr:`size_average`
is set to ``False``, the losses are instead summed for each minibatch. Ignored
when reduce is ``False``. Default: ``True``
reduce (bool, optional): Deprecated (see :attr:`reduction`). By default, the
losses are averaged or summed over observations for each minibatch depending
on :attr:`size_average`. When :attr:`reduce` is ``False``, returns a loss per
batch element instead and ignores :attr:`size_average`. Default: ``True``
reduction (string, optional): Specifies the reduction to apply to the output:
``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: no reduction will be applied,
``'mean'``: the sum of the output will be divided by the number of
elements in the output, ``'sum'``: the output will be summed. Note: :attr:`size_average`
and :attr:`reduce` are in the process of being deprecated, and in the meantime,
specifying either of those two args will override :attr:`reduction`. Default: ``'mean'``
pos_weight (Tensor, optional): a weight of positive examples.
Must be a vector with length equal to the number of classes.
그 중의 매개 변수 posweight 의 사용 에 의문 이 있 습 니 다.BCEloss 의 예 posweight=torch.ones([64])\#All weights are equal to 1,왜 64 개의 class 가 있 는 지 모 르 겠 습 니 다.BCEloss 는 2 분류 문제 에 대한 loss 이기 때문에 검색 을 통 해 여러 개의 태그 분류 가 있다 는 것 을 알 게 되 었 습 니 다.다 중 태그 분 류 는 여러 개의 태그 입 니 다.태그 마다 label(0 과 1)이 두 개 있 습 니 다.이런 작업 은 BCEloss 를 사용 할 수 있 습 니 다.
이제 BCE With LogitsLoss 의 pos 를 말씀 드 리 겠 습 니 다.weight 사용법
예 를 들 어 우 리 는 양음 두 가지 견본 이 있 는데 정 견본 의 수량 은 100 개 이 고 마이너스 견본 은 400 개 이다.우 리 는 양음 견본 의 loss 를 가중 처리 하고 정 견본 의 loss 가중치 를 4 배로 확대 하 며 이런 방식 으로 견본 의 불 균형 문 제 를 완화 시 키 려 고 한다.
criterion = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([4]))
# pos_weight (Tensor, optional): a weight of positive examples.
# Must be a vector with length equal to the number of classes.
pos_weight 에는 tensor 목록 이 있 습 니 다.태그 갯 수 와 같 아야 합 니 다.예 를 들 어 우 리 는 현재 2 분류 입 니 다.샘플 loss 의 가중치 만 다시 쓰 면 됩 니 다.다 중 태그 분류 라면 64 개의 태그 가 있 습 니 다.
Examples::
>>> target = torch.ones([10, 64], dtype=torch.float32) # 64 classes, batch size = 10
>>> output = torch.full([10, 64], 0.999) # A prediction (logit)
>>> pos_weight = torch.ones([64]) # All weights are equal to 1
>>> criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
>>> criterion(output, target) # -log(sigmoid(0.999))
tensor(0.3135)
보충:Pytorch―BCEWithLogitsLoss()의 문제점등가 표현
1、pytorch:
torch.sigmoid() + torch.nn.BCELoss()
2.스스로 작성
def ce_loss(y_pred, y_train, alpha=1):
p = torch.sigmoid(y_pred)
# p = torch.clamp(p, min=1e-9, max=0.99)
loss = torch.sum(- alpha * torch.log(p) * y_train \
- torch.log(1 - p) * (1 - y_train))/len(y_train)
return loss~
3.검증
import torch
import torch.nn as nn
torch.cuda.manual_seed(300) # GPU
torch.manual_seed(300) # CPU
def ce_loss(y_pred, y_train, alpha=1):
# loss
p = torch.sigmoid(y_pred)
# p = torch.clamp(p, min=1e-9, max=0.99)
loss = torch.sum(- alpha * torch.log(p) * y_train \
- torch.log(1 - p) * (1 - y_train))/len(y_train)
return loss
py_lossFun = nn.BCEWithLogitsLoss()
input = torch.randn((10000,1), requires_grad=True)
target = torch.ones((10000,1))
target.requires_grad_(True)
py_loss = py_lossFun(input, target)
py_loss.backward()
print("*********BCEWithLogitsLoss***********")
print("loss: ")
print(py_loss.item())
print(" : ")
print(input.grad)
input = input.detach()
input.requires_grad_(True)
self_loss = ce_loss(input, target)
self_loss.backward()
print("*********SelfCELoss***********")
print("loss: ")
print(self_loss.item())
print(" : ")
print(input.grad)
테스트 결과:C.위의 결 과 를 통 해 알 수 있 듯 이 제 가 작성 한 loss 는 pytorch 에서 제공 하 는 j 와 대체적으로 일치 합 니 다.
C.그런데 이 정도 면 되 나 요?NO! BCE WithLogitsLoss()의 강점 을 소개 한다.
C BCE WithLogitsLoss()는 nan 에 대한 처리 능력 이 좋 습 니 다.제 가 쓴 코드(4 층 신경 망,층 간 활성화 함 수 는 ReLU 를 사용 하고 출력 층 활성화 함 수 는 sigmoid()를 사용 합 니 다.데이터 처리 문제 로 인해 저희 가 작성 한 CE 의 loss 에 nan 이 발생 할 수 있 습 니 다.이 유 는 다음 과 같 습 니 다.
C 우선 신경 네트워크 출력의 pretarget 이 크 면 sigmoid 이후 의 p 가 1 이 고 torch.log(1-p)는 nan 입 니 다.
C.clamp(함수 가 이 nan 을 해제 하지만 교체 과정 에서 네트워크 출력 이 점점 커 질 수 있 기 때문에(층 간 에 ReLU 를 사용)우리 가 쓴 loss 가 특정한 수치 에 빠 져 최적화 할 수 없습니다.그러나 BCE WithLogitsLoss()는 이런 상황 에서 나타 난 nan 을 잘 처리 해 더 좋 은 결 과 를 얻 었 다.
C.이 실험의 목적 은 CE 와 FL 의 차 이 를 비교 하기 위해 서 입 니 다.FL 을 직접 작성 하려 면 반드시 CE 를 직접 작성 해 야 합 니 다.BCE With LogitsLoss()를 사용 할 수 없습니다.
2.사용 장면
2 분류+sigmoid()
sigmoid 를 출력 층 비 선형 표현의 분류 문제 로 사용 합 니 다.
주의사항
입력 형식
입력 을 요구 하 는 input 와 target 은 모두 float 형식 입 니 다.
이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
BCE WithLogitsLoss 샘플 불 균형 처리 방안그 중의 매개 변수 posweight 의 사용 에 의문 이 있 습 니 다.BCEloss 의 예 posweight=torch.ones([64])\#All weights are equal to 1,왜 64 개의 clas...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.