์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | ||
6 | 7 | 8 | 9 | 10 | 11 | 12 |
13 | 14 | 15 | 16 | 17 | 18 | 19 |
20 | 21 | 22 | 23 | 24 | 25 | 26 |
27 | 28 | 29 | 30 |
- object detection
- ์ด๋ถ ํ์
- ๊ฐ๋์ ๋ง๋ก
- ์๋ฐ์คํฌ๋ฆฝํธ
- DP
- ์กฐํฉ๋ก
- ๋ถํ ์ ๋ณต
- ๊ฐ๋์_๋ง๋ก
- ํ๋ก์ด๋ ์์ฌ
- ํฌ๋ฃจ์ค์นผ
- lazy propagation
- ๋ฌธ์์ด
- NEXT
- pytorch
- c++
- back propagation
- dropout
- ์ฐ์ ์์ ํ
- ๋ค์ต์คํธ๋ผ
- Overfitting
- ๋ฏธ๋๋_ํ์ฌ์_๊ณผ๊ฑฐ๋ก
- ํ๊ณ ๋ก
- ๋๋น ์ฐ์ ํ์
- tensorflow
- ์๊ณ ๋ฆฌ์ฆ
- 2023
- ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ
- dfs
- BFS
- ๋ฐฑํธ๋ํน
- Today
- Total
Doby's Lab
DropPath๋ ๋ฌด์์ด๋ฉฐ, Dropout๊ณผ ๋ฌด์จ ์ฐจ์ด๊ฐ ์์๊น? (timm ํ์ฉ ๋ฐ ์คํ์์ค ๋ถ์) ๋ณธ๋ฌธ
DropPath๋ ๋ฌด์์ด๋ฉฐ, Dropout๊ณผ ๋ฌด์จ ์ฐจ์ด๊ฐ ์์๊น? (timm ํ์ฉ ๋ฐ ์คํ์์ค ๋ถ์)
๋๋น(Doby) 2024. 5. 12. 12:17๐ค Problem
๋น์ ๋ชจ๋ธ ์คํ์์ค๋ฅผ ๋ณด๋ค ๋ณด๋ฉด, ์ข
์ข
DropPath
๋ผ๋ ํด๋์ค๋ก๋ถํฐ ์ธ์คํด์ค๋ฅผ ์์ฑํ์ฌ ๋ชจ๋ธ์์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ฅผ ์์ฃผ ๋ด
๋๋ค. ๋ํ, ์ด DropPath
๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์๋ timm
์ด๋ผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
๊ทธ๋์, ์ค๋์ DropPath
๊ฐ ๋ฌด์์ด๋ฉฐ, timm
์ด๋ผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ฌด์์ธ์ง ๊ทธ ๋ด๋ถ์ ์ด๋ป๊ฒ ๊ตฌํ๋์ด ์๋์ง๋ฅผ ๊ธฐ๋กํด๋๋ ค๊ณ ํฉ๋๋ค.
๐ DropPath๋?(= Stochastic Depth)
DropPath๋ Dropout์ ์ด๋ฆ๊ณผ ์ ์ฌํ๊ฒ ๊ธฐ๋ฅ๋ ์ ์ฌํ ์ญํ ์ ์ํํฉ๋๋ค.
์ด ๊ฐ๋ ์ Deep Networks with Stochastic Depth์์ ๋ฑ์ฅํ ๊ฐ๋ ์ผ๋ก Residual connection์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ๋ชจ๋ธ์์ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฅ์ ๋๋ค. ๋ ผ๋ฌธ์์๋ ์ด๋ฅผ Stochastic Depth๋ผ ์ธ๊ธํ๊ธฐ๋ ํฉ๋๋ค.
์ ๊ทธ๋ฆผ์์ DropPath๊ฐ ์ํํ๊ณ ์ ํ๋ ๊ฒ์ ๋๋คํ ํ๋ฅ ์ ๋ฐ๋ผ \(f_l(H_{l-1})\)์ ์๋ตํ๋ ๊ฒ์ ๋๋ค.
์ฆ, ๋ชจ๋ธ์ Output์ด ๋๋คํ ํ๋ฅ ์ ๋ฐ๋ผ \(f(x)+x\)๊ฐ ๋ ์๋ ์๊ณ , \(x\)๊ฐ ๋ ์๋ ์๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ , ์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์น ๋จ์๋ก ํ์ตํ ๋, ๋ฐฐ์น ๋ด์ ์ํ ๋ณ๋ก ๋๋คํ ํ๋ฅ ์ ์ํด ์ ์ฉ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ฉด, ์ด๋ฅผ ํตํด ์ข์์ง๋ ๊ฒ์ด ๋ฌด์์ด๋?
1๏ธโฃ Training time savings
DropPath๊ฐ ์ ์ฉ์ด ๋๋ฉด, ๊ธฐ์กด Block์์ Residual connection ๊ตฌ์กฐ๋ง ๋จ๊ฒ ๋๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋คํธ์ํฌ์ ๊ธธ์ด๊ฐ ์งง์์ง๋๋ค. ์ด์ ๋ฐ๋ผ, ํ์ต ์๊ฐ์ด ์ค์ด๋ค๊ฒ ๋ฉ๋๋ค.
์ ๋ ผ๋ฌธ์์ ์คํํ ๊ฒฐ๊ณผ๋ก, Survival probability๊ฐ 0.5์ผ ๋๋ ํ์ต ์๊ฐ์ด 25% ์ ๋๋ก ์ค์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ , 0.5์ผ ๋ ๋ชจ๋ธ์ ์ฑ๋ฅ์ด ์ ์ผ Optimal ํ์ต๋๋ค.
๋ํ, Survival probability๊ฐ 0.2์ผ ๋๋ ์ฑ๋ฅ ์์ฒด๋ DropPath๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒ๊ณผ ๋น์ทํ๋ฐ, ํ์ต ์๊ฐ์ 40%๋ก ํ ์ค์์ต๋๋ค.
2๏ธโฃ Implict model ensemble
๊ทธ๋ฆฌ๊ณ , ๋ชจ๋ธ ๋ด์ \(L\)๊ฐ์ Residual Block์ด ์๋ค๊ณ ํ์ ๋, DropPath๋ฅผ ์ ์ฉ์ํค๋ฉด ์๋ก ๋ค๋ฅธ \(2^L\)๊ฐ์ ๋ชจ๋ธ์ ํ์ต์ํค๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค. (์๋ํ๋ฉด, ์ ์ฉํ๋๋ ์ ํ๋๋์ ๊ฒฝ์ฐ์ ์๊ฐ ์์ด์) ์ฆ, ์์๋ธ์ ํจ๊ณผ๋ฅผ ๊ฐ์ ธ์จ๋ค๋ ๊ฒ์ ๋๋ค.
์ด๋ฅผ ์ฆ๋ช ํ ์ ์๋ ๊ฒฐ๊ณผ๋ก ๋ฒค์น๋งํฌ ๋ฐ์ดํฐ์ ์ ํ์ต์์ผ Test error๋ฅผ ์ฌ๋ฌ ์ฐ๊ตฌ๋ค๊ณผ ๋น๊ตํ ๊ฒฐ๊ณผ, ํ์คํ ๋ ์ฑ๋ฅ์ด ์ข์์ ๋ณด์์ต๋๋ค.
๐ timm
๋ด ์คํ์์ค ๋ถ์ & ๋ฐฐ์ด ์
timm
๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ Hugging face์์ ์ด๋ฏธ์ง ๋ชจ๋ธ(pre-train๋ ๋ชจ๋ธ ํฌํจ)์ ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๋๋ค. ๋ฟ๋ง ์๋๋ผ ์ฌ๋ฌ ๊ธฐ๋ฅ์ ์ํํ๋ ๋ ์ด์ด๋ ์คํ ์์ค๋ก ์ ๊ณต์ ํ๊ณ ์์ต๋๋ค. (timm.models.layers
)
๋ด๋ถ์ ๊ตฌํ๋์ด์๋ DropPath
ํด๋์ค์์ ๊ตฌํ์ ์ผ๋ก ๋ฐฐ์ด ๊ฒ ๋ง์์ ์ด์ ๋ํด์ ์ ๋ฆฌ๋ฅผ ํด๋ณด๋ ค๊ณ ํฉ๋๋ค. ์ ๋ถ๋ฅผ ์ ๊ธฐ์๋ ๋ค์ ๊ธ์ด ๊ธธ์ด์ง๊ธฐ ๋๋ฌธ์ ๋ด์ฉ๋ค์ ๋ชจ๋ ์ฃผ์์ผ๋ก ์ ์ด๋์์ต๋๋ค.
https://github.com/huggingface/pytorch-image-models/blob/main/timm/layers/drop.py#L150
pytorch-image-models/timm/layers/drop.py at main · huggingface/pytorch-image-models
PyTorch image models, scripts, pretrained weights -- ResNet, ResNeXT, EfficientNet, NFNet, Vision Transformer (ViT), MobileNet-V3/V2, RegNet, DPN, CSPNet, Swin Transformer, MaxViT, CoAtNet, ConvNeX...
github.com
์ ์คํ์์ค์ 150๋ฒ ์ค๋ถํฐ ์ฃผ์์ ์ ์ด๋์์ต๋๋ค.
def drop_path(x, drop_prob: float = 0., training: bool= False, scale_by_keep: bool = True):
r"""
์ด ํจ์๋ f(x) + x์์ x์ ์ ์ฉ๋๋ ํจ์์ด๋ค.
"""
if drop_prob == 0. or not training:
return x
keep_prob = 1 - drop_prob
# (1) ์๋์ shape์ด ๊ฐ์ง๋ ์๋ฏธ
"""
Batch๋ฅผ ๊ณ ๋ คํ (x.shape[0],)๋ฅผ ์ ์ธํ๊ณ ๋ณธ๋ค๋ฉด,
(1,) * (x.ndim - 1)๋ง ๋ณด๋ฉด ๋๋๋ฐ
์ด๋ ์๋ sample ์์ฒด์ ndim๋งํผ tensor์ shape์ ๊ฐ๋๋ก ํ๋ ๊ฒ์ด๋ค.
์ฆ, (Batch Size, 1, 1, ..., 1)์ shape์ด ๋๋ค๋ ์๋ฏธ์ธ๋ฐ
์ด๋ ํ
์์ ๋ชจ๋ ์์๋ค์ ๋ํด ์ฐ์ฐ์ ํ ์ ์๋๋ก ์๋์ ์ผ๋ก ์ด๋ฐ
shape์ ๊ฐ๋๋ก ํ๋ ๊ฒ์ด๋ค. = Broading Semantics ์ฌ์ฉ
-> ์ด๋ ๊ฒ ํด์ผ Sample๋ง๋ค ๋
๋ฆฝ์ ์ผ๋ก Drop์ด ๊ฐ๋ฅํ๋ค.
"""
shape = (x.shape[0],) + (1,) * (x.ndim - 1)
# (2) Tensor.new_empty(size)
"""
https://pytorch.org/docs/stable/generated/torch.Tensor.new_empty.html
size๋งํผ์ uninitialized data๋ก ํ
์๋ฅผ ์ฑ์ด๋ค.
์๋ณธ์ ํ
์์ ๊ฐ์ torch.dtype, torch.device๋ฅผ ๊ฐ๊ฒ ๋๋ค.
๊ทธ๋์ ์ด ๋ฉ์๋์ ์ฉ๋๋ ์๋ง ์๋ณธ ํ
์์ ๋์ผํ ์ํ(dtype, device)๋ฅผ
๊ฐ์ง๋๋ก ํ๋ ๊ฒ์ผ๋ก ์ถ์ธกํ๊ณ ์๋ค.
new_empty๋ฅผ ์ด ๊ฑด bernouli_()๋ฅผ ํตํด์ ์๋ก์ด ๊ฐ์ผ๋ก ์ฑ์ธ ๊ฒ์ด๋ผ
์ด๋ค ํน์ ๊ฐ์ผ๋ก ์ด๊ธฐํํ๋ ๊ฒ์ ๋ฉ๋ชจ๋ฆฌ ๋นํจ์จ์ ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
"""
# (3) Tensor.bernoulli_()
"""
https://pytorch.org/docs/stable/generated/torch.Tensor.bernoulli_.html
ํ
์ ๊ฐ๊ฐ์ element๋ค์ด ๋ฒ ๋ฅด๋์ด ์ํ์ ํตํด์ ๋์จ ๊ฒฐ๊ณผ๋ค.
random_tensor์ ํ ๋นํ ๊ฑฐ๋ฉด, ๊ตณ์ด inplace operation์ผ๋ก ์ฌ์ฉํ์ด์ผ ํ๋?
์ด๊ฒ์ inplace operation์ผ๋ก ํด์ผ Tensor์ mutability๊ฐ ๋ณด์ฅ๋์ด
์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ์ง ์๊ธฐ ๋๋ฌธ์ ํจ์จ์ ์ธ ๊ด์ ์์ bernoulli()๊ฐ ์๋
bernoulli_()๊ฐ ์ฌ์ฉ๋์๋ค๊ณ ์ถ์ธกํ๋ค.
"""
random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
if keep_prob > 0.0 and scale_by_keep:
"""
(๋์ ์ถ์ธก)
๋
ผ๋ฌธ์์ scale_by_keep์ ๋ชฉ์ ์ ์ฐพ์ง๋ ๋ชป ํ์์ง๋ง,
์๋ง ์์์์ผ๋ก ๋ดค์ ๋, keep_prob์ ์ํด ์ฌ๋ผ์ง๋ sample๋ค์ ๋ํด์
๋ชจ๋ธ์ ๋ชจ๋ธ ๋ด๋ถ ํน์ ๋ ์ด์ด๋ค์ด ํ์ตํ๊ฒ ๋๋ ๋ฐ์ดํฐ์ ์๊ฐ ์ค์ด๋๋ ๊ฒ์ด๋ผ
ํ๋จํ๊ฒ ๋๋ค.
์ด ๋๋ฌธ์ ๋ ์ด์ด์ ๊ด์ ์์ Drop์ด ๋๋ ์ํ์ ๋ํด ๊ฐ์๊ฐ
๋ณด์ฅ์ด ๋๋๋ก ํ๊ธฐ ์ํด์ Drop์ด ๋์ง ์๋ ์ํ์ ๋ํด ๊ฐ์ค์น๋ฅผ ๋ถ์ฌํ๋ค.
-> ์ด๋ keep_prob์ ์ญ์๋ก ๋ณด์ฅํ๋ค.
์ด๋ฅผ ํตํด, ์์ด์ง ์ํ์ ๋ํด ๋ค๋ฅธ ์ํ์ ๊ฐ์ค์น ๋ ๋ถ์ฌํจ์ผ๋ก์จ
ํ์ตํ ๋ฐ์ดํฐ์ ์๋ฅผ ๋ณด์กดํ๋ ํจ๊ณผ๋ฅผ ๊ฐ์ง๋๋ก ํ๋ค.
"""
random_tensor.div_(keep_prob)
return x * random_tensor
class DropPath(nn.Module):
def __init__(self, drop_prob: float = 0., scale_by_keep: bool = True):
super(DropPath, self).__init__()
self.drop_prob = drop_prob
self.scale_by_keep = scale_by_keep
def forward(self, x):
return drop_path(x, self.drop_prob, self.training, self.scale_by_keep)
๐ ์๊ฒ๋ ๊ฒ
๋ค์ํ ๋ฉ์๋์ ์ฌ์ฉ์
๋๋ค. ํนํ, ํ
์ ๋ด์ฅ ๋ฉ์๋๋ฅผ ๋ง์ด ์ฌ์ฉํ์ผ๋ฉฐ, ๋ฉ์๋ ์ด๋ฆ ๋์ '_
'(์ธ๋ ๋ฐ) ์ ๋ฌด์ ๋ฐ๋ผ inplace operation์ธ์ง ์๋์ง๊ฐ ๋ฌ๋ผ์ง๊ฒ ๋ฉ๋๋ค. ๋ฉ๋ชจ๋ฆฌ์ ๊ด์ (Mutable, Immutable)์์ ์ inplace operation์ ์ฌ์ฉํ๋์ง ์์๋ณด๋ ๊ฒ๋ ์ฌ๋ฐ์์ต๋๋ค. div_()
, bernoulli_()
๋ํ, Tuple์ ์ฐ์ฐ ๊ท์น์ ์ฌ์ฉํ์ฌ ์๋ก์ด ํ ์์ Shape์ ๋ง๋๋ ๊ณผ์ ์ด ๋ฐฐ์ธ ์ ์ด๋ผ๊ณ ๋๊ผ์ต๋๋ค. ์ด ๊ณผ์ ์์ ์ด์ ์ ๋ฐฐ์ด Broadcasting Semantics๋ฅผ ํ์ฉํ์ฌ ๊ฐ ์ํ์ DropPath๋ฅผ ์ ์ฉํ๋ ๊ฒ๋ ์ธ์์ ์ด์์ต๋๋ค.
๐ Reference
https://arxiv.org/abs/1603.09382
Deep Networks with Stochastic Depth
Very deep convolutional networks with hundreds of layers have led to significant reductions in error on competitive benchmarks. Although the unmatched expressiveness of the many layers can be highly desirable at test time, training very deep networks comes
arxiv.org
https://github.com/huggingface/pytorch-image-models/blob/main/timm/layers/drop.py#L150
pytorch-image-models/timm/layers/drop.py at main · huggingface/pytorch-image-models
PyTorch image models, scripts, pretrained weights -- ResNet, ResNeXT, EfficientNet, NFNet, Vision Transformer (ViT), MobileNet-V3/V2, RegNet, DPN, CSPNet, Swin Transformer, MaxViT, CoAtNet, ConvNeX...
github.com
https://pytorch.org/docs/stable/generated/torch.Tensor.new_tensor.html
torch.Tensor.new_tensor — PyTorch 2.3 documentation
Shortcuts
pytorch.org
https://pytorch.org/docs/stable/generated/torch.Tensor.bernoulli_.html
torch.Tensor.bernoulli_ — PyTorch 2.3 documentation
Shortcuts
pytorch.org