์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 | 31 |
- DP
- ๋ฏธ๋๋_ํ์ฌ์_๊ณผ๊ฑฐ๋ก
- BFS
- NEXT
- ๊ฐ๋์_๋ง๋ก
- back propagation
- ๊ฐ๋์ ๋ง๋ก
- ํ๋ก์ด๋ ์์ฌ
- dfs
- ๋ฐฑํธ๋ํน
- ์ด๋ถ ํ์
- pytorch
- ์๊ณ ๋ฆฌ์ฆ
- tensorflow
- 2023
- ํฌ๋ฃจ์ค์นผ
- c++
- ์ธ๊ทธ๋จผํธ ํธ๋ฆฌ
- dropout
- ๋ค์ต์คํธ๋ผ
- object detection
- ๋๋น ์ฐ์ ํ์
- ๋ฌธ์์ด
- ๋ถํ ์ ๋ณต
- lazy propagation
- ์ฐ์ ์์ ํ
- ์๋ฐ์คํฌ๋ฆฝํธ
- ํ๊ณ ๋ก
- Overfitting
- ์กฐํฉ๋ก
- Today
- Total
Doby's Lab
Tensor๋ ์๋ก ๋ค๋ฅธ ndim์ ๋ํด์ ์ด๋ป๊ฒ ์ฐ์ฐํ ๊น? (Broadcasting Semantics) ๋ณธ๋ฌธ
Tensor๋ ์๋ก ๋ค๋ฅธ ndim์ ๋ํด์ ์ด๋ป๊ฒ ์ฐ์ฐํ ๊น? (Broadcasting Semantics)
๋๋น(Doby) 2024. 5. 4. 01:19๐ค Problem
์ค๋ ๋ค๋ฃจ์ด๋ณผ ๋ฌธ์ ๋ ์ด์ฐ ๋ณด๋ฉด ์์ ๋ถํฐ ๊ถ๊ธํ์ผ๋ ๊ทธ์ ๋ํ ๋ต์ ๊ฐ๊ฐ์ ์ผ๋ก๋ง ์๊ณ ์์๊ณ , ๋ฌธ์ ์ ์ผ๋ก ๋ค๋ฃจ์์ ๋ ์ด๋ ค์ธ ๊ฒ์ด๋ผ ์์ํ์๊ธฐ์ ์กฐ๊ธ ๋ฏธ๋ฃจ์ด์๋ ์ฃผ์ ์ ๋๋ค.
์ค๋์ ๋ฌธ์ ๋ฅผ ์ ์ํ๊ธฐ ์ ์ ์ด๊ฒ๋ถํฐ ์๊ธฐํด ๋ด
์๋ค. ์ฐ๋ฆฌ๋ ์ผ๋ฐ์ ์ผ๋ก ๋ชจ๋ธ์ ํ์ต์ํฌ ๋, ๋ฐฐ์น ๋จ์๋ก ํ์ต์ ์ํต๋๋ค. ๊ทธ๋ฌ๋ฉด ์๋ฅผ ๋ค์ด์ Input Tensor๊ฐ (4, 2)
์ shape์ ๊ฐ์ง๋ค๊ณ ํ์ ๋, Batch Size๊ฐ 16์ด๋ผ ํด๋ด
์๋ค.
์ค์ ๋ก ๋ชจ๋ธ์ ๋ค์ด๊ฐ๊ฒ ๋๋ Input Tensor์ shape์ (16, 4, 2)
๊ฐ ๋ ๊ฒ์
๋๋ค. ์ด๋, ๋ชจ๋ธ์ Weight๊ฐ Batch Size์ ๋ฐ๋ผ์ ๋๊ฐ์ด (16, weight shape)
๋ก ๋ณํ๋์? ์๋๋๋ค. ๊ทธ๋๋ก (weight shape)
์ ์ ์งํ๊ณ ์์ต๋๋ค. ์ฐจ์์ ๊ฐ์๊ฐ ๋ค๋ฅธ๋ฐ ์๋ก ์ฐ์ฐ์ ํ๊ณ ์์๋ค๋ ๊ฒ๋๋ค.
์ด๊ฒ์ ๊ฐ๋ฐ์๋ก ํ์ฌ๊ธ ํผ๋์ ๊ฐ์ ธ์ค๊ธฐ๋ ํฉ๋๋ค.
'๊ทธ๋ผ ์ด๋ป๊ฒ ์ฐ์ฐ์ ํ๋ ๊ฑฐ์ผ? ๋ด๊ฐ ์๋ํ ๋๋ก ํ๊ณ ์๊ธด ํ ๊ฑฐ์ผ?'
์ฌ๊ธฐ์ ์ค๋ ์์๋ณผ ๋ฌธ์ ๊ฐ ๋์์ต๋๋ค. ๊ทธ ๋ฌธ์ ๋ 'Tensor๋ ์๋ก ๋ค๋ฅธ ndim
(์ฐจ์์ ๊ฐ์)์ ๋ํด์ ์ด๋ป๊ฒ ์ฐ์ฐ์ ํ๋๊ฐ?'๊ฐ ์ด๋ฒ ํฌ์คํ
์ ์ฃผ์ ์
๋๋ค.
์ด ๋ฌธ์ ์ ๋ํด์๋ ์ฌ์ค Broadcasting์ ๊ฐ๋ ์ผ๋ก ์ถฉ๋ถํ ํด๊ฒฐ์ด ๊ฐ๋ฅํฉ๋๋ค. ์ด๊ฒ ์ ๋ถ์์. ๊ทธ๋์ ์ด๋ฒ ํฌ์คํ ์ ์์์ ์ธ๊ธํ ๋ฌธ์ ์ ์ ๋ํด์ Broadcasting์ ์ค๋ช ํ๋ฉด ๋๋ฉ๋๋ค.
ํ์ง๋ง, ์ ๊ฐ ์ํ๋ ๊ฑด ์ด๊ฒ ์๋๋๋ค. ์๋ํ๋ฉด, ์ ๋ Broadcasting์ ๊ฐ๋ ์ ์์๋ ์ข ์ข ๋ชจ๋ธ์ ๋ง๋ค ๋ shape๊ณผ ๊ด๋ จํ ์ค์๋ฅผ ๋ง์ด ํฉ๋๋ค.
์ฆ, ๊ฐ๋ ์ ์๊ณ ์๋ ๊ฒ๋ง์ผ๋ก Broadcasting๊ณผ ๊ด๋ จ๋ ์ฝ๋๋ฅผ ํธ๋ค๋งํ ๋๋ ์ด๋ ค์์ด ์๋ค๋ ๊ฒ์ ๋๋ค.
๋ค์ ๋งํด์, ์ด๋ฒ ํฌ์คํ ์์ ๋ค๋ฃฐ ์ฃผ์ ์ ๋ํด์ ์ ํํ ์ฌ์ ์๋ฅผ ํ๋ฉด, 'Broadcasting์ ๊ฐ๋ ๊ณผ ์๋ฆฌ๋ ์๊ฒ ์ผ๋, ์ด๋ ํ ๊ท์น์ด ์๋๊ฐ?'๋ฅผ ๋ค๋ฃจ์ด๋ณด๋ ค๊ณ ํฉ๋๋ค.
๐ Broadcasting Semantics
Broadcasting์ ๋ํ ๊ฐ๋ ์ ๋ค๋ฃจ์ง๋ ์์ง๋ง, ์ด ๊ฐ๋ ์ ๋ํด ํต์ฌ์ ์ผ๋ก ๊ฟฐ๋ซ๋ ๋ง์ด ์๊ธฐ์ ์ด๊ฒ๋ง ์ ์ด๋๊ฒ ์ต๋๋ค.
"Broadcasting์ด๋ ํน์ ํ ์ด๋ค ์กฐ๊ฑด์ด ๋ง์์ง๋ค๋ฉด, ๋ชจ์์ด ๋ค๋ฅธ ๋ฐฐ์ด๋ผ๋ฆฌ๋ ์ฐ์ฐ์ ์ํํ ์ ์๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ค."
์ด๋ฌํ Broadcasting์ด ์ด๋ค ์กฐ๊ฑด, ์ด๋ค ๊ท์น์ ์ํด์ ์ํ๋ ์ ์๋๊ฐ๋ฅผ Broadcasting Semantics๋ผ๊ณ ํฉ๋๋ค. ๊ณต์ ๋ฌธ์์์ ์ด๋ ๊ฒ ์ธ๊ธ์ ํ๊ณ ์๊ณ , ์ถ๊ฐ์ ์ผ๋ก Semantics๋ "์ด๋ค ์์๋ฅผ ์ด๋ ํ ์์น์ ๋์ด์ผ ํ๋๊ฐ๊ฐ ์๋๋ผ ์ด๋ค ์์๋ฅผ ์ด๋ ํ ์์น์ ๋๋ฉด ์ด๋ค ์๋ฏธ๋ฅผ ๊ฐ๋์ง๋ฅผ ๋งํ๋ค.[1]"๋ผ๋ ๋ป์ ์ฉ์ด์ ๋๋ค.
Broadcasing Semantics์ ๊ดํ ๋ด์ฉ์ PyTorch์ Documentation[2]์ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค. (ํด๋น ๋งํฌ์ In Brief: Tensor Broadcasting)
1๏ธโฃ ๋ง์ง๋ง ์ฐจ์์์ ์์ํ๋ ๋น๊ต
์ฒซ ๋ฒ์งธ ๊ท์น์ ๋๋ค. ํ ์๋ผ๋ฆฌ ์ฐ์ฐ์ ํ ๋๋ ๊ฐ ํ ์์์ ์ฐจ์์ ํฌ๊ธฐ๋ฅผ ์๋ก ๋น๊ตํ๋๋ฐ, ์ด๋ ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ๊ฐ ํ ์์ ๋ง์ง๋ง ์ฐจ์ ํฌ๊ธฐ์์ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์ฒซ ์ฐจ์์ ํฌ๊ธฐ๊น์ง ๋น๊ต๋ฅผ ํฉ๋๋ค.
์๋์ ์ฝ๋์ ํจ๊ป ์์๋ฅผ ๋ ๋ค๋ฉด, ์ฒ์์ผ๋ก ๋ด์ผ ํ ๊ฒ์ 2์ 2์ ๋๋ค. ๊ทธ๋ค์์ 3๊ณผ 3์ด๊ณ , ๊ทธ๋ค์์?
์์ต๋๋ค. matrix2
์ 0๋ฒ์งธ ์ฐจ์ ํฌ๊ธฐ๊ฐ 4์ด์ง๋ง, ์ด๊ฒ์ Broadcasting ๊ฐ๋ฅ ์ฌ๋ถ์ ์์ด์ ๊ณ ๋ คํ์ง ์์๋ ๋ ์ฌํญ์
๋๋ค. ๊ทธ๋์, ๋ง์ง๋ง๋ถํฐ ๋ณด๋ ๊ฑฐ์์.
(๋ฌผ๋ก , ๋ง์ง๋ง๋ถํฐ ๋ณผ ํ์๋ ์์ต๋๋ค. ๋ค ์ฐจ์๋ถํฐ ๋ง์ถฐ์ ๋ณผ ์ ์๋ค๋ฉด, ๊ตณ์ด ๋ฐ๋ ๋ฐฉํฅ๋ถํฐ ๊ณ ๋ คํ๋ค๋ ์๊ฐ์ ๋ฒ๋ ค๋ ๋ฉ๋๋ค. ์๋ฌ๊ฐ ๋ ๋๋ ๋ณด๋ฉด, ์์์๋ถํฐ ์ฐจ์์ ์ฝ๊ธฐ ๋๋ฌธ์ ๋๋ค.)
matrix1 = torch.ones(( 3, 2))
matrix2 = torch.ones((4, 3, 2))
matrix3 = matrix1 * matrix2
์์ ์์๋ฅผ ๊ฐ์ง๊ณ ์๊ฐํด ๋ณธ๋ค๋ฉด, 3x2 ํ๋ ฌ๊ณผ ๋ค๋ฅธ 4๊ฐ์ 3x2 ํ๋ ฌ์ ๊ฐ๊ฐ Element-wise Product๋ฅผ ํ๋ค๊ณ ๋ณผ ์ ์์ต๋๋ค. ์ด๋ฐ ์๋ฏธ์์ ๋ ๋ง์ ์ฐจ์์ ๊ฐ์ง ํ ์์ ์ ์ฐจ์๋ค์ ๋ณผ ํ์๊ฐ ์๋ ๊ฒ์ ๋๋ค.
2๏ธโฃ ๋น๊ตํ๋ ์ฐจ์๋ค์ ๊ทธ ํฌ๊ธฐ๊ฐ ๋ชจ๋ ๊ฐ์์ผ ํ๋ค.
์ ์์์ฒ๋ผ 2์ 2, 3๊ณผ 3์ฒ๋ผ ๋น๊ต๋ฅผ ํ๋ ์ฐจ์๋ค์ ํฌ๊ธฐ๋ ๋ชจ๋ ๊ฐ์์ผ Broadcasting์ ํ ์ ์๋ ์กฐ๊ฑด์ด ๋ฉ๋๋ค.
matrix1 = torch.ones((3, 2))
matrix2 = torch.ones((2, 2))
matrix3 = matrix1 * matrix2
์ ์ฝ๋์ ๊ฐ์ด ๋น๊ตํ๋ ์ฐจ์์ด ๋ค๋ฅด๋ค๋ฉด, ์๋์ ๊ฐ์ ์๋ฌ๋ฅผ ์ผ์ผํค๊ฒ ๋ฉ๋๋ค.
RuntimeError: The size of tensor a (3) must match the size of tensor b (2) at non-singleton dimension 0
0๋ฒ์งธ ์ฐจ์์์ 1๋ฒ ํ ์์ 2๋ฒ ํ ์์ ์ฌ์ด์ฆ(ํฌ๊ธฐ)๊ฐ ๋ค๋ฅด๋ ์ด๊ฒ์ ํ์ธํ๋ผ๋ ์๋ฏธ์ ๋๋ค.
3๏ธโฃ ํ์ง๋ง, ๋น๊ตํ๋ ์ฐจ์์ด ๋ค๋ฅด๋๋ผ๋ ๊ทธ ํฌ๊ธฐ๊ฐ 1์ด๋ฉด ๊ฐ๋ฅํ๋ค.
2๋ฒ์์๋ ๋น๊ตํ๋ ์ฐจ์๋ค์ด ๋ชจ๋ ๊ฐ์์ผ ๋๋ค๊ณ ํ์ง๋ง, ๋ค๋ฅธ ๊ฒฝ์ฐ๋ผ๋ ๊ทธ ํฌ๊ธฐ๊ฐ 1์ด๋ฉด Broadcasting์ด ๊ฐ๋ฅํฉ๋๋ค.
matrix1 = torch.ones((3, 2))
matrix2 = torch.ones((1, 2))
matrix2[:, 1] += 1
matrix3 = matrix1 + matrix2
์์ ๊ฐ์ด ํ์ด ๋ค๋ฅธ ๊ฒฝ์ฐ๋ผ๋ฉด, ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๊ฐ๋ฅํ๊ณ ์.
matrix1 = torch.ones((3, 2))
matrix2 = torch.ones((3, 1))
matrix2[1, :] += 1
matrix2[2, :] += 2
matrix3 = matrix1 + matrix2
์์ ๊ฐ์ด ์ด์ด ๋ค๋ฅธ ๊ฒฝ์ฐ๋ผ๋ฉด, ์๋์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ ์์๋ค๊ณผ ์ฐจ์์ ํฌ๊ธฐ๊ฐ 1์ธ ๊ฒฝ์ฐ์ ๊ฐ๋ฅํ ์ด์ ๋ ๋ณต์ฌํ๋ฏ์ด ๊ณ์ฐ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ด์ ๊ฐ์ด ํ๋์ ๋ฒกํฐ์์ ํ๋ ฌ๋ก ์ฐ์ฐ์ ํผ์ ธ๋๊ฐ๋ฏ์ด ์ํํ๊ธฐ ๋๋ฌธ์ Broadcasting์ด๋ผ ํฉ๋๋ค.
4๏ธโฃ ์ฐ์ฐํ๊ณ ์ ํ๋ ๊ฒ์ด ํ ์, ๋ฒกํฐ๊ฐ ์๋ ์ค์นผ๋ผ์ธ ๊ฒฝ์ฐ์๋ ๊ฐ๋ฅํ๋ค.
์ฌ์ค ์ด๊ฒ์ ์ ์ ์ผ๋ ค๊ณ ํ์ต๋๋ค. 1๋ฒ๊ณผ 3๋ฒ ์กฐ๊ฑด์ ํฉ์น ๊ฒ๊ณผ ๊ฒฐ๊ตญ์ ๊ฐ์ ์ด์ผ๊ธฐ์ด๊ธฐ ๋๋ฌธ์ ๋๋ค.
matrix1 = torch.ones((3, 2))
matrix2 = torch.ones((1))
matrix3 = matrix1 * matrix2
์ ์ฝ๋์์ ์ค์นผ๋ผ์ shape์ ๋ณด๋ฉด 1๋ฒ ์กฐ๊ฑด์ ๋ํด์ 1๊ณผ 2๋ง ๋น๊ตํ๊ฒ ๋๋๋ฐ, ๋น๊ตํ๋ ์ฐจ์์ด 1์ด๊ธฐ ๋๋ฌธ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ ๊ฒ์ ๋๋ค.
๊ทธ๋๋ ์ ์ด๋ ์ด์ ๋ ๊ณต์ ๋ฌธ์์ ๋์์์๊ธฐ ๋๋ฌธ์ด๊ณ , ์ด๊ฒ์ด ๊ฒฐ๊ตญ์๋ Broadcasting์ด๋ผ๋ ๊ฐ๋ ์ ์ดํดํ๋ ๋ฐ์ ๊ฐ์ฅ ๊ธฐ์ด์ ์ธ ์์์ด๊ธฐ ๋๋ฌธ์ ๋๋ค.
5๏ธโฃ ํ๋ ฌ ๊ณฑ์ ๋ง์ง๋ง ๋ ์ฐจ์์ด ํ๋ ฌ ๊ณฑ์ ์กฐ๊ฑด์ ๊ฐ์ถ๋ฉด ๋๋ค.
์ด์ฉ๋ฉด ์ด ๊ธ์ ์จ์ผ ํ๋ ์ด์ ์ ๋๋ค. ๋ฅ๋ฌ๋์์ element-wise product๋ฅผ ํ๋ ๊ฒฝ์ฐ๋ matrix multiplication๋ณด๋ค ๋น์ค์ด ๋ ์ ๊ณ , Broadcasting Semantics์ ๋ํด ๊ถ๊ธํ๊ฒ ๋์๋ ์ด์ ๋ ์ฌ๊ธฐ์ ์์๊ธฐ ๋๋ฌธ์ ๋๋ค.
๊ทธ๋ฆฌ๊ณ , ์ด ๋ด์ฉ์ ์ ๊ฐ ์ฐธ๊ณ ํ ๊ณต์ ๋ฌธ์๋ ๋ค๋ฅธ ํฌ์คํ ์์๋ ์์์ต๋๋ค. ๋๋ถ๋ถ element-wise๊น์ง๋ง Broadcasting์ ์ธ๊ธํ๊ณ ์์์ต๋๋ค.
๊ทธ๋์ 5๋ฒ ์กฐ๊ฑด์ ์ ๊ฐ ์คํ์ ํตํด ์ํํ ๋ด์ฉ์ ๊ธฐ๋ฐ์ผ๋ก ์์ฑํ์์ต๋๋ค. ์คํ์ ํตํด์ ์๊ฒ ๋ ๊ฒ์ ๋น์ฐํ ๋ด์ฉ์ผ์ง๋ ๋ชจ๋ฅด๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์์ต๋๋ค.
ํ๋ ฌ ๊ณฑ์ ๋ํด์๋ 1~4๋ฒ ์กฐ๊ฑด๊น์ง ๋ชจ๋ ๊ฐ์ ์กฐ๊ฑด์ ๋ค๋ฃจ๊ณ ์์ต๋๋ค. ํ์ง๋ง, ๋ฑ ํ๋์ ์กฐ๊ฑด๋ง ๋ ์ง์ผ์ง๋ฉด ํ๋ ฌ ๊ณฑ์ ์์ด์๋ Broadcasting Semantics๋ ์ฑ๋ฆฝํฉ๋๋ค.
๋ง์ง๋ง ๋ ์ฐจ์์ด ํ๋ ฌ ๊ณฑ์ ์กฐ๊ฑด์ ๊ฐ์ถ๋ฉด ๋ฉ๋๋ค. ์ฌ๊ธฐ์ ํต์ฌ์ ๋ง์ง๋ง ๋ ์ฐจ์์ ๋๋ค.
ํต์ฌ์ ๋ค๋ฃจ๊ธฐ ์ ์, ํ๋ ฌ ๊ณฑ์ ๋ํด์ ์ด์ผ๊ธฐ๋ฅผ ํด๋ด ์๋ค. ํ๋ ฌ ๊ณฑ์ ์กฐ๊ฑด์ ๋น์ฐํ ์ต์ํ๊ฒ ์ง๋ง ์ฒซ ๋ฒ์งธ ํ๋ ฌ์ ์ด๊ณผ ๋ ๋ฒ์งธ ํ๋ ฌ์ ํ์ ํฌ๊ธฐ๊ฐ ๊ฐ์ผ๋ฉด ํ๋ ฌ ๊ณฑ์ ์ํํ ์ ์์ต๋๋ค.
์ด๋ฌํ ์กฐ๊ฑด์ ํ ์์ ๊ฒฝ์ฐ๋ก ์๊ฐํ๋ค๋ฉด, ์ฒซ ๋ฒ์งธ ํ ์๊ฐ n๊ฐ์ ์ฐจ์์ ๊ฐ์ง๊ณ , ๋ ๋ฒ์งธ ํ ์๊ฐ m๊ฐ์ ์ฐจ์์ ๊ฐ์ง๋ค๊ณ ํ ๋, n์ ์ฐจ์์ ํฌ๊ธฐ์ m-1์ ์ฐจ์ ํฌ๊ธฐ๊ฐ ๊ฐ์์ผ ํ๋ค๋ ์๋ฏธ์ ๋๋ค.
์๋ ์ฝ๋๋ก ๋ดค์ ๋๋ ์ฒซ ๋ฒ์งธ ํ ์์์ 0๋ฒ์งธ ์ฐจ์์ด 3์ธ ๊ฒ์ 1~4๋ฒ ์กฐ๊ฑด์ ๋ชจ๋ ๊ณ ๋ คํ๊ธฐ ๋๋ฌธ์ ์ ํ ์๊ด์ด ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ , 2x5 ํ๋ ฌ๊ณผ 5x4 ํ๋ ฌ์ด ํ๋ ฌ๊ณฑ์ ํ ์ ์๋ ์กฐ๊ฑด์ด ๋๊ธฐ ๋๋ฌธ์ ์ด๋ Broadcasting์ด ๊ฐ๋ฅํฉ๋๋ค.
matrix1 = torch.ones((3, 2, 5))
matrix2 = torch.ones((5, 4))
matrix3 = matrix1 @ matrix2
๊ทธ๋ฌ๋ฉด, ๋ง์ง๋ง ๋ ์ฐจ์์ด์ด์ผ ํ๋ ์ด์ ๋ ๋ฌด์์ด๋? ๋ง์ง๋ง ๋ ์ฐจ์์ด ์๋ ๊ฒฝ์ฐ๋ ์๋์ ๊ฒฝ์ฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
matrix1 = torch.ones((3, 2, 5, 4))
matrix2 = torch.ones((3, 5, 2, 4))
matrix3 = matrix1 @ matrix2
์ ์ฝ๋๊ฐ ๊ทธ ๊ฒฝ์ฐ๊ฐ ๋๋ ๊ฒ์ธ๋ฐ ์ ์ฝ๋๋ ๋น์ฐํ๊ฒ ๋์ง ์์ต๋๋ค. ์๋ํ๋ฉด, ์ ์ด์ ์ฝ๋์ ๊ด์ ์์๋ 2๋ฒ ์กฐ๊ฑด์ ์๋ฐฐ๋ฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ , ์ํ์ ์ผ๋ก ์ด๋ฅผ ์ ๊ทผํด ๋ดค์ ๋, ๋ง์ฝ์ ์ด๊ฒ์ด 'ํ๋ ฌ ๊ณฑ์ ์กฐ๊ฑด์ฒ๋ผ ์ ๋์ง ์๋๋?'๋ฅผ ๋ฌผ์์ ๋๋ ์ด๊ฒ์ ํ๋ ฌ ๊ณฑ์ ์ ์์ ์๋ฐฐ๋๊ธฐ ๋๋ฌธ์ด๋ผ ๋งํ ์ ์์ต๋๋ค.
์๋ง, 2x5 ํ๋ ฌ๊ณผ 5x2 ํ๋ ฌ์ด ๊ณฑํด์ง๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํ์ ํ ๋ฐ, ํ๋ ฌ ๊ณฑ์ ๊ฒฐ๊ตญ ํ๋ ฌ ํฌ๊ธฐ์ ๋ํ ์กฐ๊ฑด์ ๊ณ ๋ คํ์ฌ ์์๋ฅผ ๊ณฑํ๊ณ ๋ํ๋ ์ฐ์ฐ์ ๋๋ค. ํ์ง๋ง, 2x5 ํ๋ ฌ, 5x2 ํ๋ ฌ์ด๋ผ ๋ณด๋ ๊ด์ ์ ์์๋ฅผ ๋ฒกํฐ๋ก ๋ดค๋ค๋ ๊ฒ์ธ๋ฐ ์ฌ๊ธฐ์ ์์ ์์ฒด์ ์๋ฏธ๋ ์ค์นผ๋ผ ๊ฐ ๊ทธ ์์ฒด์ผ ๋ฟ, ๋ฒกํฐ๋ ํ๋ ฌ ํน์ ๋ ๋์๊ฐ์ ํ ์๊ฐ ๋ ์๋ ์์ต๋๋ค. ๊ทธ๋์ ๋ง์ง๋ง ๋ ์ฐจ์์ด๋ผ๊ณ ์ธ๊ธํ ๊ฒ์ ๋๋ค.
์, ์ด๋ ๊ฒ 1~5๋ฒ ์กฐ๊ฑด๊น์ง ์์๋ดค์ต๋๋ค. 4๋ฒ ์กฐ๊ฑด์ ์ ์ธํ๋ฉด, ์๊ฐํด ๋ณผ ๊ฒ์ 4๊ฐ ์์ผ๋ ์ตํ๋๋ฉด ์ข์ ๊ฑฐ ๊ฐ์ต๋๋ค.
โ Result
์ค๋์ Broadcasting Semantics์ ๋ํด์ ์์๋ณด์์ต๋๋ค. ์ต๋ํ ์ด ๊ท์น๋ง์ ์ค๋ช ํ๊ธฐ ์ํด์ ๊ฐ๋ ์ ๋ํ ๋ด์ฉ์ ๋ฐฐ์ ๋ฅผ ํ์ต๋๋ค. ๊ฐ๋ + ๊ท์น์ ๋์์ ์ค๋ช ํ๊ธฐ์๋ ์ ๊ฐ ๋ค๋ฅธ ํฌ์คํ ์ ์ฐธ๊ณ ํ ๋, ์กฐ๊ธ ๋ณต์กํ๊ฒ๋ ๋๊ปด์ก๊ธฐ ๋๋ฌธ์ ๋๋ค.
๋ํ, Broadcasting์ ๋ฅ๋ฌ๋์์๋ ์์ฃผ ์ค์ํ ์ฐ์ฐ ์ค ํ๋์ ๋๋ค.
๊ทธ๋์, ์ค๋ ์๊ฒ ๋ ์ด๋ฌํ ๊ท์น์ ํ ๋๋ก ๋ชจ๋ธ์ ์ค๊ณํ๋ค๋ฉด ์๋ฌ์ ๋น๋์๋ฅผ ๋ง์ด ์ค์ผ ์ ์์ ๊ฒ์ผ๋ก ๊ธฐ๋ํฉ๋๋ค.
๐ Reference
https://jake-seo-dev.tistory.com/445
https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html