์ด์ ์ ์ฌ๋ฆฐ Barlow Twins Architecture๋ฅผ ๊ตฌํํ๋ฉด์ tensorflow.keras.Model์ train_step() ํจ์๋ฅผ ๊ฑด๋๋ฆด ์ผ์ด ์๊ฒผ๋๋ฐ ํด๋น ํจ์์์ Gradient Tape๋ฅผ ์ฌ์ฉํ๋ ์ ์ ๋ณด๊ณ ๊ณต๋ถํ๋ฉฐ ์๋์ ๋ธ๋ก๊ทธ๋ฅผ ํ์ฌํ์ต๋๋ค.
https://rfriend.tistory.com/556
[TensorFlow] Gradient Tape์ ์ด์ฉํ ์๋ ๋ฏธ๋ถ๊ณผ ์ค์ฐจ์ญ์ ํ
์๋๋ฏธ๋ถ(Automatic differentiation, Algorithmic differentiation, computational differentiation, auto-differentiation, ๋๋ ์ค์ฌ์ ๊ฐ๋จํ auto-diff) ์ ์ปดํจํฐ ํ๋ก๊ทธ๋จ์ ์ํด์ ๊ตฌ์ฒดํ๋ ํจ์์ ๋ฏธ๋ถ์ ์ฐ์ ์ ์ผ๋ก ๊ณ์ฐ
rfriend.tistory.com
์๋๋ฏธ๋ถ(Automatic differentiation, Algorithmic differentiation, Computational differentiation, auto-differentiation)์ ์ปดํจํฐ ํ๋ก๊ทธ๋จ์ ์ํด์ ๊ตฌ์ฒดํ๋ ํจ์์ ๋ฏธ๋ถ์ ์ฐ์ ์ ์ผ๋ก ๊ณ์ฐํ ๋ ์ฌ์ฉํ๋ ๊ธฐ์ ์ ์งํฉ์ ๋งํฉ๋๋ค. ์ปดํจํฐ ํ๋ก๊ทธ๋จ์ ์ํด์ ๊ตฌ์ ํ๋ ํจ์๋ ์๋ฌด๋ฆฌ ๋ณต์กํด๋ณด์ด๋๋ผ๋ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ ์ฐ์ฐ๊ณผ ๊ธฐ๋ณธ์ ์ธ ํจ์์ ์ฐ์์ ์ธ ์คํ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค๋ ์์ด๋์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค.
๋ณต์กํ ํจ์๋ ์ฐ์ ๋ฒ์น(Chain Rule)์ ์ด์ฉํจ์ผ๋ก์จ ํฉ์ฑํจ์๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ ๊ธฐ๋ณธํจ์์ ๋ฏธ๋ถ์ ๊ณฑ์ผ๋ก ๋ํ๋ด๊ณ ๋ฐ๋ณต์ ์ผ๋ก ๊ณ์ฐํจ์ผ๋ก์จ ์๋์ผ๋ก ๋ณต์กํ ํจ์๋ฅผ ์ ํํ๊ณ ํจ์จ์ ์ผ๋ก ๋ฏธ๋ถ์ด ๊ฐ๋ฅํฉ๋๋ค.
์๋๋ฏธ๋ถ(Automatic Differentiation)์ ๋ฅ๋ฌ๋์์ ์ค์ฐจ ์ญ์ ํ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ ๋ชจ๋ธ์ ํ์ตํ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค.
Tensorflow์์๋ Gradient Tapes๋ฅผ ์ด์ฉํ์ฌ ์ฆ์ ์คํ ๋ชจ๋(eager execution mode)์์ ์ฝ๊ฒ ์ค์ฐจ ์ญ์ ํ๋ฅผ ์ํํ ์ ์์ต๋๋ค.
ํด๋น ํฌ์คํธ์๋ ์๋์ 5๊ฐ์ง์ ๋ํ์ฌ ์๊ฐํฉ๋๋ค.
1. ์ฆ์ ์คํ ๋ชจ๋์์ ์๋๋ฏธ๋ถ์ ํ๊ธฐ ์ํด Gradient tapes๊ฐ ํ์ํ ์ด์
2. Tensorflow์์ Gradient Tapes๋ฅผ ์ด์ฉํ์ฌ ์๋ ๋ฏธ๋ถ์ ์ํํ๋ ๋ฐฉ๋ฒ
3. ์๊ทธ๋ชจ์ด๋(Sigmoid) ํจ์์ ์๋ ๋ฏธ๋ถ ์๊ฐํ
4. ํ ์ดํ๊ฐ ๋ณผ ๊ฒ์ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ (Controlling what the tape wathes)
5. Python ์กฐ๊ฑด์ ๋ถ๊ธฐ๋ฌธ์ ์ด์ฉํ ํ ์ดํ ๊ธฐ๋ก ํ๋ฆ ์กฐ์ (Control Flow)
๋ํ Tensorflow ํํ ๋ฆฌ์ผ์ ๋ด์ฉ์ ๋ณ์ญํ๊ณ ์ฝ๋๋ฅผ ๋๋ถ๋ถ ์ฌ์ฉํ์๋ค๊ณ ํฉ๋๋ค.
Tensorflow Tutorial URL: https://www.tensorflow.org/guide/autodiff?hl=en
๊ทธ๋๋์ธํธ ๋ฐ ์๋ ๋ฏธ๋ถ ์๊ฐ | TensorFlow Core
PaLM API ๋ฐ MakerSuite Explore Generative AI๋ฅผ ์ฌ์ฉ ํ์ฌ Google์ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ ์ฌ์ฉํด ๋ณด์ธ์. ๊ทธ๋๋์ธํธ ๋ฐ ์๋ ๋ฏธ๋ถ ์๊ฐ ์ปฌ๋ ์ ์ ์ฌ์ฉํด ์ ๋ฆฌํ๊ธฐ ๋ด ํ๊ฒฝ์ค์ ์ ๊ธฐ์ค์ผ๋ก ์ฝํ ์ธ ๋ฅผ ์ ์ฅํ๊ณ
www.tensorflow.org

๋จผ์ numpy, tensorflow, matplotlib ๋ชจ๋์ importํฉ๋๋ค.

1. 1. ์ฆ์ ์คํ ๋ชจ๋์์ ์๋ ๋ฏธ๋ถ์ ํ๊ธฐ ์ํด Gradient Tapes๊ฐ ํ์ํ ์ด์
์๋ฅผ ๋ค์ด y=a*x๋ผ๋ ๋ฐฉ์ ์์์ a์ y๊ฐ ์์(constant)์ด๊ณ x๊ฐ ๋ณ์(variable)์ผ ๋, ์ด ๋ฐฉ์ ์์ ์ค์ฐจ ์ญ์ ํ๋ฒ์ ํตํ์ฌ ๋ณ์ x๋ฅผ ๊ตฌํ๊ณ ์ ํ๋ค๊ณ ํฉ์๋ค. ๊ทธ๋ฌ๋ฉด ๊ฐ๋จํ ์์คํจ์์ธ loss=abs(a*x-y)๋ฅผ ์ต์๋ก ํ๋ x๋ฅผ ๊ตฌํ๋ฉด ๋ฉ๋๋ค.
์๋ ์์ ๊ฒฝ์ฐ 8.0=2.0*x ๋ฐฉ์ ์ ํจ์๋ก๋ถํฐ ๋ณ์ x์ ๊ฐ์ ๊ตฌํ์๊ณ ํฉ์๋ค. x๋ฅผ 10.0์์ ์์ํด์ abs(a*x-y) ์์คํจ์ ๊ฐ์ ์ต์๋ก ํ๋ x๋ฅผ ๊ตฌํ๊ณ ์ ํ๋ค๋ฉด '์์คํจ์์ ๋ํ x์ ๋ฏธ๋ถ(the gradient of the loss with respect to x)'์ ๊ตฌํด์ x๊ฐ์ ๋ฏธ๋ถ๊ฐ๋งํผ ๋นผ์ ๊ฐฑ์ ํด์ค์ผ ํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ์๋์ Tensorflow 2.x ๋ฒ์ ์์์ Python ์ฆ์ ์คํ๋ชจ๋(eager mode)์์ ์์ค(Loss)์ '์ฆ์ ๊ณ์ฐ(eager execution)'ํด๋ฒ๋ ค์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด numpy=12.0์ธ Tensor์์ ์ ๋๋ค. ์ฌ๊ธฐ์ ์๋ ๋ฏธ๋ถ์ ํ๋ ค๊ณ ํ๋ฉด ๋ฌธ์ ๊ฐ ์๊น๋๋ค. ์๋ํ๋ฉด ์๋๋ฏธ๋ถ์ ํ๊ธฐ ์ํ ํจ์์ ๊ณ์ฐ ์์ ์ฐ์ฐ ๊ณผ์ ๊ณผ ์ ๋ ฅ ๊ฐ์ ๋ํ ์ ๋ณด๊ฐ ์ฆ์์คํ๋ชจ๋์์๋ ์๊ธฐ ๋๋ฌธ์ ๋๋ค. (์ ๋ ฅ ๊ฐ๊ณผ ์ฐ์ฐ ๊ณผ์ ์ ์ ์ฅ ์ํ๊ณ ์ฆ์์คํํด์ ๊ฒฐ๊ณผ๋ง ์ถ๋ ฅํ์์ต๋๋ค.)

2. 2. Tensorflow์์ Gradient Tapes๋ฅผ ์ด์ฉํ์ฌ ์๋๋ฏธ๋ถ ํ๋ ๋ฐฉ๋ฒ
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด Tensorflow๋ ์ค๊ฐ ์ฐ์ฐ ๊ณผ์ (ํจ์, ์ฐ์ฐ)์ ํ ์ดํ(Tape)์ ์ฐจ๊ณก์ฐจ๊ณก ๊ธฐ๋กํด์ฃผ๋ Gradient Tapes๋ฅผ ์ ๊ณตํฉ๋๋ค.
with tf.GradientTape() as tape: ๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฅํ tape๋ฅผ ์ง์ ํด์ฃผ๋ฉด, ์ดํ์ GradientTape() ๋ฌธ๋งฅ ์๋์ Tensorflow์ ์ฐ๊ด ์ฐ์ฐ ์ฝ๋๋ tape์ ์ ์ฅ์ด ๋ฉ๋๋ค. ์ด๋ ๊ฒ tape์ ์ ์ฅ๋ ์ฐ์ฐ ๊ณผ์ (ํจ์, ์ฐ์ฐ์)์ ๊ฐ์ ธ๋ค๊ฐ Tensorflow๋ dx=tape.gradient(loss,x)๋ก ํ์ง ๋ชจ๋ ์๋ ๋ฏธ๋ถ ๋ฐฉ๋ฒ(Reverse mode automatic differentiation) ๋ฐฉ๋ฒ์ผ๋ก ์์ค์ ๋ํ x์ ๋ฏธ๋ถ์ ๊ณ์ฐํฉ๋๋ค. ์ด๋ ๊ฒ ๊ณ์ฐ๋ ์์ค์ ๋ํ x์ ๋ฏธ๋ถ์ ์ญ์ ํ(backpropagation)ํ์ฌ x์ ๊ฐ์ ๊ฐฑ์ (update)ํ๋ ์์ ์ ๋ฐ๋ณตํจ์ผ๋ก์จ ๋ณ์ x์ ๋ต์ ์ฐพ์๊ฐ๋ ํ์ต์ ์งํํฉ๋๋ค.
์์ (1)๋ฒ์์ ์๊ฐํ 8.0=2.0*x์ ๋ฐฉ์ ์์์๋ ๋ณ์ x-4.0์ด ๋ฉ๋๋ค. Tensorflow์ GradientTape()์ tape.gradient()๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ๋ณด๊ฒ ์ต๋๋ค.

์ฒ์์ x=10.0์์ train_func๋ฅผ 4ํ ๋ฐ๋ณตํ๋ x=4.0์ผ๋ก ๋ต์ ์ ์ฐพ์๊ฐ์ต๋๋ค.
๋ผ๋ ํจ์์์ (Target) y์ ๋ํ (Source) x์ ๋ฏธ๋ถ (derivative of target y with respect to source x)์ Tensorflow์ GradientTape.gradient() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๊ณ์ฐํด๋ณด๊ฒ ์ต๋๋ค. ์ฐ๋ฆฌ๋ ์ด๋ฏธ ๋ผ๋ ๊ฒ์ ์๊ณ ์์ต๋๋ค.
์ฌ์ฉ ํ์: GradientTape.gradient(target, source)

์์ ๊ฐ๋จํ ์์ ์์๋ ์ค์นผ๋ผ(Scalar)๋ฅผ ์ฌ์ฉํ๋ค๋ฉด, tf.GradientTape()๋ ์ด๋ค ํํ์ ํ ์์ ๋ํด์๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. GradientTape.gradient(target, sources)์์ sources์๋ ์ฌ๋ฌ ๊ฐ ๋ณ์๋ฅผ ๋ฆฌ์คํธ๋ ์ฌ์ ํ(Dictionary)์ ํํ๋ก ์ ๋ ฅํด์ค ์ ์์ต๋๋ค.

Targetr์ ๋ํ Source์ ๋ฏธ๋ถ ๊ฒฐ๊ณผ๋ Source์ ํ์(shape)์ ๋ฐ๋ฆ ๋๋ค. ๊ฐ๋ น, ์์ ์์์๋ ์์คํจ์(Loss)์ ๋ํ ๊ฐ์ค์น(w)์ ๋ฏธ๋ถ(derivative of loss with respect to weight)์ ๊ฒฐ๊ณผ๋ Source์ ํด๋นํ๋ ๊ฐ์ค์น(w)์ ํ์์ ๋ฐ๋ผ์ (4, 2)๊ฐ ๋ฉ๋๋ค. (ํด๋น ์์น์ ๊ฐ์ค์น์ ๋ํด์ ํธ๋ฏธ๋ถํ ๊ฒฐ๊ณผ)

2.1. 3. ์๊ทธ๋ชจ์ด๋ ํจ์์ ์๋ ๋ฏธ๋ถ ์๊ฐํ(Auto-diff plot Sigmoid function)
๋ฅ๋ฌ๋์์ ํ์ฑํ ํจ์ ์ค์ ํ๋๋ก ์ฌ์ฉ๋๋ S ๊ณก์ ๋ชจ์์ ์๊ทธ๋ชจ์ด๋ ํจ์(Sigmoid function)์ ์๋์ ๊ฐ์ต๋๋ค.
์ด ์๊ทธ๋ชจ์ด๋ ํจ์๋ฅผ x์ ๋ํด์ ๋ฏธ๋ถํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
์๊ทธ๋ชจ์ด๋ ํจ์์ ์๊ทธ๋ชจ์ด๋ ํจ์์ ๋ฏธ๋ถ ๊ฐ์ x๊ฐ -10.0์์ 10.0 ์ฌ์ด์ 200๊ฐ์ ๊ด์ธก์น์ ๋ํด Tensorflow์ tf.GradientTape()์ GradientTape=tape.gradient(Sigmoid_func, x)๋ก ๊ณ์ฐํด์ ํ๋์ ๊ทธ๋ํ์ ๊ฒน์ณ์ ์๊ฐํ๋ฅผ ํด๋ณด๊ฒ ์ต๋๋ค.

์์ ์ฝ๋์์ ์ฃผ์ํ ์ญํ ์ tape.watch(x)๊ฐ ํฉ๋๋ค.
์ด๊ฒ์ GradientTape ๋ด์์ ํน์ ๋ณ์์ ์ฐ์ฐ์ "๊ฐ์"ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๊ทธ๋์ ํด๋น ๋ณ์์ ๋ํ ๋ชจ๋ ์ค๊ฐ ์ฐ์ฐ์ ๋ ์ฝ๋ฉํ๊ณ , ๋์ค์ ๊ทธ๋๋์ธํธ๋ฅผ ๊ณ์ฐํ ๋ ์ฌ์ฉํ ์ ์๊ฒ ๋ฉ๋๋ค.
๋ฐ๋ผ์ ์ฃผ์ด์ง ์ฝ๋์๋ 'x'๋ฅผ tape.watch(x)๋ก ๊ฐ์ํ๊ณ ์์ผ๋ฉฐ, ์ดํ์ 'y=tf.nn.sigmoid(x)'์ ๊ฐ์ ์ฐ์ฐ์ ์ํํ๋ฉด์ ์ค๊ฐ ์ฐ์ฐ์ ๊ธฐ๋กํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ tape.gradient(y, x)๋ฅผ ํธ์ถํ์ฌ 'y'์ ๋ํ 'x'์ ๊ทธ๋๋์ธํธ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
2.2. 4. ํ ์ดํ๊ฐ "๋ณผ(์ ์ฅ)"๊ฒ์ ์กฐ์ ํ๋ ๋ฐฉ๋ฒ(Controlling what the tape "watches")
Tensorflow๊ฐ ์ค์ฐจ์ญ์ ํ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ์ต(training by backpropagation algorithm)ํ ๋ ์ฌ์ฉํ๋ ์๋๋ฏธ๋ถ์ 'ํ์ต ๊ฐ๋ฅํ ๋ณ์ (trainable tf.Variable)'์ ๋์์ผ๋ก ํฉ๋๋ค.
๋ฐ๋ผ์ ๋ง์ฝ (1) ๋ณ์๊ฐ ์๋ ์์ ('tf.Tensor')๋ผ๋ฉด Tensorflow๊ฐ ์ ๋ณด๋ (not watched), ์ฆ ๊ธฐ๋กํ์ง ์๋ (not recorded)๊ฒ์ด ๊ธฐ๋ณธ ์ค์ ์ด๋ฏ๋ก ์๋ ๋ฏธ๋ถ์ ํ ์ ์์ผ๋ฉฐ, (2) ๋ณ์(tf.Variable)๋๋ผ๋ 'ํ์ต ๊ฐ๋ฅํ์ง ์์ผ๋ฉด (not trainable)' ์๋ ๋ฏธ๋ถ์ ํ ์ ์์ต๋๋ค.

y์ ๋ํ tf.Tensor์ธ x์ ๋ฏธ๋ถ์ ๊ตฌํ๊ธฐ ์ํด์๋ GradientTape.watch(x)๋ฅผ ํธ์ถํด์ tf.Tensor์ธ x๋ฅผ ํ ์ดํ์ ๊ธฐ๋กํด์ฃผ๋ฉด ๋ฉ๋๋ค.

๋ํ Tensorflow์ ํ ์ดํ์ ๊ธฐ๋ก๋๋ 'ํ์ต ๊ฐ๋ฅํ ๋ณ์'๋ GradientTape.watched_variables() ๋ฉ์๋๋ก ํ์ธ์ด ๊ฐ๋ฅํฉ๋๋ค.

ํด๋น ์ฝ๋๋ ์์ ์ฝ๋๋ฅผ ํ์ธ ํ ๊ฒ์ ์๋๋๋ค. ๋ง์ฝ ์์ ์ฝ๋๋ฅผ ํ์ธํ๋ ค๊ณ ํ๋ฉด ์๋ฌด ๊ฐ๋ ๋์ค์ง ์์ ๊ฒ์ ๋๋ค.
๊ทธ ์ด์ ๋ x๋ฅผ tf.constant๋ก ์ ์ธํ ๋ถ๋ถ์ ์์ต๋๋ค. constant๋ ์์๋ก์จ ๋ณํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
๋ฐ๋๋ก, ๋ชจ๋ ๋ณ์ (tf.Variable)๋ฅผ ํ ์ดํ์ ๊ธฐ๋กํ๋ Tensorflow์ ๊ธฐ๋ณธ์ค์ ์ ๋นํ์ฑํํ๋ ค๋ฉด watch_accessed_variables=False๋ก ๋งค๊ฐ๋ณ์๋ฅผ ์ค์ ํด์ฃผ๋ฉด ๋ฉ๋๋ค.
์๋์ ์์์์๋ x0, x1 ๋ ๊ฐ์ tf.Variable ๋ชจ๋๋ฅผ watch_accessed_variables=False๋ก ๋นํ์ฑํํด๋๊ณ , GradientTape.watch(x1)๋ก x1๋ณ์๋ง ํ ์ดํ์ ๊ธฐ๋กํด์ ์๋ ๋ฏธ๋ถ์ ํฉ๋๋ค.

2.3. 5. Python ์กฐ๊ฑด์ ์ ์ฌ์ฉํ ํ ์ดํ ๊ธฐ๋ก ํ๋ฆ์ ์กฐ์
Python์ ์กฐ๊ฑด์ ์ ์ด์ฉํ ๋ถ๊ธฐ๋ฌธ์ ์ด์ฉํ๋ฉด Tensorflo์ tf.GradientTape() ๋งฅ๋ฝ ์๋์์ ํ ์ดํ์ ๊ธฐ๋กํ๋ ์ฐ์ฐ ๊ณผ์ ์ ํ๋ฆ์ ์กฐ๊ฑด์ ์ ํด๋นํ๋ ๊ฒ๋ง ์ทจ์ฌ์ ํ์์ ๊ธฐ๋กํ ์ ์์ต๋๋ค.
์๋์ ์์์์๋ if x > 0.0์ผ ๋๋ result=v0, ๊ทธ๋ ์ง ์์ ๋(else)๋ result=v1**2๋ก result์ ์ฐ์ฐ์ ๋ค๋ฅด๊ฒ ํด์ ํ ์ดํ์ ๊ธฐ๋กํ๊ณ , GradientTape.gradient()๋ก ์๋๋ฏธ๋ถํ ๋๋ ์์ if else ์์ True์ ํด๋น๋์ด ์ค์ ์ฐ์ฐ์ด ์ผ์ด๋ฌ๋ ๋ฏธ๋ถ์ ์ฐ๊ฒฐํด์ ๊ณ์ฐํ๋ผ๋ ์ฝ๋๋ฅผ ์์ฑํ์ต๋๋ค.
๋ํ x=tf.constant(1.0)์ผ๋ก์จ if x > 0.0 ์กฐ๊ฑด์ ์ ๋ง์กฑ(True)์์ผฐ์ผ๋ฏ๋ก result=v0 ์ฐ์ฐ์ด ์คํ๋๊ณ ๋ค์ tape.gradient()์์ ์๋๋ฏธ๋ถ์ด ๋์์ผ๋ฉฐ, else ์กฐ๊ฑด์ ์๋์ ์ฐ์ฐ์ ์คํ๋์ง ์์์ผ๋ฏ๋ก ๋ค์ tape.gradient()์ ์๋๋ฏธ๋ถ์ ํด๋น๋์ง ์์์ต๋๋ค.

'๐ฅ๏ธ Computer Vision' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
TIF ํ์ผ์ด๋? (0) | 2023.06.25 |
---|