์ต๊ทผ AI์ ๋ฅ๋ฌ๋์ด ๋น ๋ฅด๊ฒ ํ์ฐ๋๋ฉด์ ์ด๋ฅผ ๊ตฌํํ๊ธฐ ์ํ ํ๋ ์์ํฌ์ ์ค์์ฑ๋ ํจ๊ป ์ปค์ง๊ณ ์๋ค. ํนํ ์ต๊ทผ์๋ keras ๋ tensorflow์กฐํฉ๋ณด๋จ PyTorch๋ฅผ ์ฃผ๋ก ์ฌ์ฉํ๋ค๊ณ ํ๋ค.
์ฒซ์งธ, ํ์ด์ฌ ๋ฌธ๋ฒ.
PyTorch ์ฝ๋๋ ์ผ๋ฐ์ ์ธ ํ์ด์ฌ ์ฝ๋์ ๊ฑฐ์ ๋์ผํ ํ๋ฆ์ ๊ฐ์ง๋ค. ๋๋ถ์ ์ฝ๋๋ฅผ ์ฝ๊ณ ์ดํดํ๊ธฐ๊ฐ ์ฝ๊ณ , ๋๋ฒ๊น
๋ ํธ๋ฆฌํ๋ค.
๋์งธ, ์ฆ์ ์คํ(Eager Execution) ๋ฐฉ์์ ์ฌ์ฉํ๋ค. ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ๋ฐ๋ก ์คํ๋๊ณ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํ ์ ์๋ค.
์
์งธ, GPU ์ฐ์ฐ์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
๋ณต์กํ ์ค์ ์์ด๋ GPU๋ฅผ ํ์ฉํด ๋๊ท๋ชจ ๋ชจ๋ธ์ ๋น ๋ฅด๊ฒ ํ์ตํ ์ ์๋ค.
PyTorch์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ๊ฐ๋ ์ Tensor๋ค.
Tensor๋ ์๋ค์ํผ ์ซ์ ๋ฐฐ์ด์ด๋ค.
NumPy ๋ฐฐ์ด๊ณผ ๋งค์ฐ ๋น์ทํ์ง๋ง,tensor๋ GPU์์ ์ฐ์ฐํ ์ ์๋ค๋ ์ ์ด ๊ฐ์ฅ ํฐ ์ฐจ์ด๋ค.
๋ฅ๋ฌ๋์์ ์
๋ ฅ ๋ฐ์ดํฐ, ๊ฐ์ค์น, ์ถ๋ ฅ๊ฐ์
๋ชจ๋ Tensor ํํ๋ก ์ฒ๋ฆฌ๋๋ค.
๊ทธ๋ ๋ค๋ฉด tensor๊ฐ ๋ฌด์จ ์ฅ์ ์ด ์๊ธธ๋ pytorch๊ฐ tensor๋ฅผ ์ฐ๋ ๊ฒ์ด ์ฐจ๋ณ์ ์ด ๋๋๊ฒ์ผ๊น?
Tensor์ ์ง์ง ๊ฐ์ ์ ๋ฐ๋ก
๊ฐ์ ์ฝ๋๋ก CPU์ GPU๋ฅผ ๋ชจ๋ ์ฌ์ฉํ ์ ์๋ค๋ ์ ์ด๋ค.
๋๋ฌธ์, ์ด๊ฒ PyTorch๊ฐ ์ค๋ฌด์ ์ฐ๊ตฌ์์ ๊ฐํ ์ด์ ๋ค.
๋ฅ๋ฌ๋ ํ์ต์ ํต์ฌ์ด ์์ธก๊ฐ๊ณผ ์ ๋ต์ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๊ณ ๊ทธ ์์ค์ด ๋ชจ๋ธ์ ๊ฐ ํ๋ผ๋ฏธํฐ์ ์ผ๋ง๋ ์ํฅ์ ์ฃผ๋์ง์ด๋ค. ์ด๊ฑธ ํ๊ธฐ ์ํด์๋ ์คํฐ๋์์ ํญ์ ๊ฐ์กฐํ๋ฏ์ด, ๋ฏธ๋ถ ๊ณ์ฐ์ด ํ์ํ๋ค.
PyTorch๋ ์ด ๊ณผ์ ์ ์๋์ผ๋ก ์ํํ๋ค.
PyTorch๋ ๋ชจ๋ ๋ฏธ๋ถ์ ์ง์ ๊ตฌํํ์ง ์๊ณ , Autograd๋ผ๋ ๊ธฐ๋ฅ์ ํตํด
๋ฏธ๋ถ ๊ณผ์ ์ ์๋์ผ๋ก ์ฒ๋ฆฌํด์ค๋ค.
์ฆ, ๊ฐ๋ฐ์๋ ๋ชจ๋ธ ๊ตฌ์กฐ๋ฅผ ์ ์ํ๊ณ ์์ค ํจ์๋ง ์ง์ ํ๋ฉด
PyTorch๊ฐ ์ญ์ ํ(backpropagation)์ ํ์ํ ๋ฏธ๋ถ์ ์๋์ผ๋ก ๊ณ์ฐํ๋ค.
์ด ๊ธฐ๋ฅ ๋๋ถ์
๋ฅ๋ฌ๋ ๋ชจ๋ธ ๊ตฌํ์ด ํจ์ฌ ๋จ์ํด์ง๋ค.
๋ฅ๋ฌ๋์์๋ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๋ถ๋ฌ์ค๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํ๋ค. ํนํ ์ ์ฒ๋ฆฌ๋ฅผ ํ๋ค๋ณด๋ฉด ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๋ถ๋ฌ์ค๋๊ฒ ์ค์ํ๋ค๋ ๊ฒ์ ์ฒด๊ฐํ๊ฒ ๋๋ค.
Dataset์ ๋ฐ์ดํฐ์ ์ ๋ต(label)์ ํ๋๋ก ๋ฌถ๋ ์ญํ ์ ํ๋ค.
DataLoader๋ ๋ฐ์ดํฐ๋ฅผ ๋ฏธ๋๋ฐฐ์น ๋จ์๋ก ๋ถ๋ฌ์ค๊ณ , ์๊ณ , ๋ณ๋ ฌ ์ฒ๋ฆฌํด์ค๋ค.
์ด ๋ ๊ตฌ์กฐ ๋๋ถ์
๋๊ท๋ชจ ๋ฐ์ดํฐ์
๋ ํจ์จ์ ์ผ๋ก ํ์ต์ ์ฌ์ฉํ ์ ์๋ค.
PyTorch์์๋ torch.nn ๋ชจ๋์ ์ฌ์ฉํ๋ค.
layer, ํ์ฑํ ํจ์, ์์ค ํจ์ ๋ฑ์ด ์ด๋ฏธ ๊ตฌํ๋์ด ์์ด ๋ฐ๋ก ์ ์ํ ํ์๊ฐ ์๋ค.
์์์ pytorch์ ํน์ง๋ง ๋ณด๋ฉด
โTensorFlow๋ ๋ค ๋๋ ๊ฑฐ ์๋๊ฐโ๋ผ๋ ์๋ฌธ์ด ๋ ๋ค.
์ค์ ๋ก TensorFlow ์ญ์ Tensor, ์๋ ๋ฏธ๋ถ, Dataset ๊ตฌ์กฐ๋ฅผ ๋ชจ๋ ์ ๊ณตํ๋ค๊ณ ํ๋ค.
ํ์ง๋ง PyTorch์ TensorFlow์ ์ฐจ์ด๋
๊ธฐ๋ฅ์ ์ ๋ฌด๊ฐ ์๋๋ผ, ์ฌ์ฉ ๋ฐฉ์์ด๋ค.
PyTorch๋ ์์ ๋งํ๋ฏ์ด ๊ธฐ๋ณธ์ ์ผ๋ก ์ฆ์ ์คํ(Eager Execution) ๋ฐฉ์์ ์ฌ์ฉํ๋ค.
์ฆ, ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ๊ทธ ์ฆ์ ์คํ๋๊ณ ๊ฒฐ๊ณผ์ ์ค๋ฅ๋ฅผ ๋ฐ๋ก ํ์ธํ ์ ์๋ค.
์กฐ๊ธ ๋ ํ์ด์ฌ ์นํ์ ์ด๋ผ๊ณ ํ ์ ์๋ค.
๋ฐ๋ฉด TensorFlow๋ ์ ํต์ ์ผ๋ก ๊ทธ๋ํ ๊ธฐ๋ฐ ์คํ ๋ฐฉ์์ ์ฌ์ฉํด ์๋ค.
๋จผ์ ์ ์ฒด ๊ณ์ฐ ๊ตฌ์กฐ๋ฅผ ์ ์ํ๊ณ , ๊ทธ ๋ค์์ ์คํํ๋ ๋ฐฉ์์ด๋ค.
๊ทธ๋ํ ๊ธฐ๋ฐ ๊ตฌ์กฐ๋ฅผ ๊ฐํ๊ฒ ๋ฐ์ํ๋ค๋ ๊ฒ์ด๋ค.
์ด ์ฐจ์ด๋ก ์ธํด PyTorch๋ ๋๋ฒ๊น
์ด ์ฝ๊ณ
TensorFlow๋ ๊ตฌ์กฐ๋ฅผ ๋ช
ํํ ์ค๊ณํด์ผ ํ๋ค.
PyTorch์ ์๋ ๋ฏธ๋ถ์ โ์ฐ์ฐ์ ํ๋ฉด ๋ฏธ๋ถ์ด ๋ฐ๋ผ์จ๋คโ๋ ๋๋์ ๊ฐ๊น๋ค.
์ฐ์ฐ์ ์์ฑํ๊ณ backward()๋ฅผ ํธ์ถํ๋ฉด ๋ฏธ๋ถ๊ฐ์ด ๋ฐ๋ก ํ๋ผ๋ฏธํฐ์ ์ ์ฅ๋๋ค.
๊ฐ๋ฐ์๋ ๋ฏธ๋ถ ๊ทธ๋ํ๋ฅผ ๊ฑฐ์ ์์ํ์ง ์์๋ ๋๋ค.
TensorFlow์ ์๋ ๋ฏธ๋ถ์
GradientTape์ ๊ฐ์ ๊ตฌ์กฐ๋ฅผ ํตํด ์๋๋ฏธ๋ถ์ ๊ด๋ฆฌํ๋ค.
๋ด๋ถ ๋์์ ๋ ๋ช
ํํ ์ ์ดํ ์ ์๋ ์ฅ์ ์ด ์์ง๋ง
์ด๋ณด์ ์
์ฅ์์๋ ์ ์๋ฅผ ํด์ผ์ง ์ธ ์ ์๋ค๋ผ๋ ์ฅ๋ฒฝ์ด์๊ธธ ์๋ ์๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก ์๋ ๋ฏธ๋ถ์ ์์ฐ์ค๋ฝ๊ฒ ์ฐ๋ ๋๋์ PyTorch์ ๋ ๊ฐ๊น๋ค.
PyTorch์์๋ ์ ๊ฒฝ๋ง ๋ชจ๋ธ์ ์ผ๋ฐ์ ์ธ ํ์ด์ฌ ํด๋์ค์ฒ๋ผ ์ ์ํ๋ค.
์กฐ๊ฑด๋ฌธ, ๋ฐ๋ณต๋ฌธ, ๋์ ๊ตฌ์กฐ๋ฅผ ์์ ๋กญ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
๊ทธ๋์ ์ฐ๊ตฌ์ฉ, ๋ชจ๋ธ ๊ตฌ์กฐ๊ฐ ์์ฃผ ๋ฐ๋๋ ์คํ, ๋ ผ๋ฌธ ๊ตฌํ ์ ๋งค์ฐ ์ ํฉํ๋ค. ์ด๊ฒ์ด ์์ฆ pytorch๊ฐ ์์ฃผ ์ฐ์ด๋ ์ด์ ๋ผ๊ณ ๋ณผ ์ ์๋ค.