๋ฐ์ํ
Numpy๊ฐ ๋ญ์์?
- Python ์์ ๊ณผํ์ ๊ณ์ฐ & ์์น๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํ ํต์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋๋ค. NumPy๋ ๊ณ ์ฑ๋ฅ์ ๋ค์ฐจ์ ๋ฐฐ์ด ๊ฐ์ฒด์ ์ด๋ฅผ ๋ค๋ฃฐ ๋๊ตฌ๋ฅผ ์ ๊ณตํฉ๋๋ค. ์์น ๊ณ์ฐ์ ์ํ ๋งค์ฐ ํจ๊ณผ์ ์ธ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๋ฉฐ, ์ด๋ ๋ฐ์ดํฐ ๋ถ์, ๋จธ์ ๋ฌ๋ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ฅ๋ฌ๋์ ๊ณต๋ถํ ๋, ๋ฐฐ์ด์ด๋ ํ๋ ฌ์ ์ฌ์ฉํ ๋๊ฐ ๋ง์๋ฐ, numpy๋ฅผ ์ด์ฉํ๋ฉด ์ด ๋ฐฐ์ด์ด๋, ํ๋ ฌ์ ๊ตฌํํ ๋ ๋งค์ฐ ํธ๋ฆฌํฉ๋๋ค.
- ์ถ๊ฐ ๋ง์์ผ๋ก, ์ฌ๊ธฐ์๋ถํฐ๋ Jupyter Notebook์ ์ด์ฉํ์ฌ ์ฝ๋๋ธ๋ญ์ ์์ฑํ์๊ธฐ ๋๋ฌธ์, python Idle๋ ๋ค๋ฅธ Tool๋ก ์ด์ฉํ์๋ ๋ถ๋ค๊ณผ ๋์ค๋ ํ์์ด ๋ค๋ฅผ์๋ ์์ต๋๋ค. ์ฐธ๊ณ ๋ฐ๋ผ์!
Numpy ์ด๋ป๊ฒ ๊ฐ์ ธ์์?
- numpy๋ ์ผ๋ฐ ํ์ด์ฌ ๋ด์ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์๋๊ฒ์ด ์๋๊ณ , ์ธ๋ถ์ ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ด๊ธฐ ๋๋ฌธ์ ๋ฐ์์ ๊ฐ์ ธ์์ผ ํฉ๋๋ค.
import numpy as np
- ํ์ด์ฌ์์๋ ์ธ๋ถ์ ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ถ๋ฌ์ค๋ ค๋ฉด import ๋ฌธ์ ์ด์ฉํด์ผ ํฉ๋๋ค. ์ด๋, "as np" ๋ผ๋ ๋ถ๋ถ์, importํ numpy ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ด๋ฆ์ np๋ก ํ๋ค๋ ๊ฒ์ ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด, numpy ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ์, np๋ก ์ ๋ ฅํ์ฌ ์ฌ์ฉํ ์ ์์ต๋๋ค.
Numpy ๋ฐฐ์ด
- Numpy ๋ฐฐ์ด(array)๋ฅผ ์ฌ์ฉํ ๋, np.array() ์ด๋ ๊ฒ method๋ฅผ ์ ์ธํ, ์ฌ์ฉํฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ด(array)๋ฅผ ๋ฆฌ์คํธ๋ก ๋ฐ์ numpy ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฌ์ฉํ๋ ๋ฐฐ์ด๋ก ๊ฐ์ return ๋ฐ์ต๋๋ค.
x = np.array([1.0, 3.0, 5.0, 7.0, 9.0])
print(x)
[1. 3. 5. 7. 9.]
type(x)
numpy.ndarray # numpy array๊ฐ ์ ๊ณตํ๋ ํน์ํํ์ array
Numpy์ ์ฐ์ฐ
- >Numpy ๋ฐฐ์ด๋ก ์ฐ์ฐ์ ์ํํ๋ ์์๋ค์ ๋ณด์ฌ๋๋ฆด๊ป์.
x = np.array([1.0, 3.0, 5.0, 7.0])
y = np.array([2.0, 4.0, 6.0, 8.0])
print(x + y)
print(x - y)
print(x * y)
print(x / y)
[ 3. 7. 11. 15.] # x + y
[-1. -1. -1. -1.] # x - y
[ 2. 12. 30. 56.] # x * y
[0.5 0.75 0.83333333 0.875] # x / y
- ์ฌ๊ธฐ์ ์ค์ํ๊ฒ์, x,y ๊ฐ array์ ์์์๊ฐ ๊ฐ์์ผ ํฉ๋๋ค. ์ฐ์ ์ฐ์ฐ์ ๊ฐ array์ ๋์ผํ ์์น์ ์๋ ์์๋ค ๋ผ๋ฆฌ ์ฐ์ฐ์ ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
- ์์์๊ฐ ๋ค๋ฅด๋ฉด? Error๊ฐ ๋์ ์ฐ์ฐ ์์ฒด๊ฐ ์ํ์ด ์๋๊ธฐ ๋๋ฌธ์ ์ค์ํฉ๋๋ค.
Numpy์ ๋ค์ฐจ์ ๋ฐฐ์ด
- ์์ ํ๋ numpy ๋ฐฐ์ด(array) ์ฐ์ฐ์, 1์ฐจ์ ๋ฐฐ์ด๋ก ํ์ง๋ง, ๋ค์ฐจ์. ์ฆ N์ฐจ์ ๋ฐฐ์ด๋ก๋ ์์ฑ ๋ฐ ์ฐ์ฐ์ ํ ์ ์์ต๋๋ค.
- ์๋ฅผ ๋ค์ด์ 2์ฐจ์ ๋ฐฐ์ด๋ก ํ๋ฒ ๋ณด์ฌ๋๋ฆด๊ป์.
x = np.array([[2, 4], [6, 8]])
print(x)
[[2 4]
[6 8]]
print(x.shape)
print(x.dtype)
(2, 2) # 2 x 2 ํ๋ ฌ
int64 # ํ๋ ฌ์ ๋ด๊ธด ์์์ ์๋ฃํ
- ์์ ์ฝ๋๋ฐ์ค์ ๋์์๋ฏ์ด, x๋ 2 x 2 ํ๋ ฌ์ ๊ฐ์ง๊ณ ์๊ณ , ํ๋ ฌ์ ๋ด๊ธด ์์์ ์๋ฃํ์ dtype์ ์ฌ์ฉํ๋ฉด, ์ ์ ์์ต๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ๋ค์ฐจ์ ํ๋ ฌ์ ์ฐ์ฐ๋ ๋ณด์ฌ๋๋ฆด๊ป์.
y = np.array([[1, 3], [5, 7]])
x + y
array([[ 3, 7],
[11, 15]])
x * y
array([[ 2, 12],
[30, 56]])
- ํ๋ ฌ๋ผ๋ฆฌ ์ฐจ์(๋ชจ์)์ด ๊ฐ์ผ๋ฉด, ์ฐ์ ์ฐ์ฐ๋ 1์ฐจ์์ด๋ ๋์ผํ๊ฒ ๊ฐ์ ์์น์ ์๋ ์์๋ผ๋ฆฌ ๊ณ์ฐ๋ฉ๋๋ค.
์ค์นผ๋ผ๊ณฑ
- ์ค์นผ๋ผ ๊ณฑ์ด ๋ฌด์์ด๋? ๊ฐ์๊ธฐ ๋์์ ๊ถ๊ธํ์ค์๋ ์๋๋ฐ, ํ๋ ฌ๊ณผ (์ผ๋ฐ ์)์ค์นผ๋ผ๋ฅผ ๊ณฑํ๋๊ฒ์ ๋งํฉ๋๋ค.
- ์์๋ฅผ ๋ณด์ฌ๋๋ฆฌ๋ฉด y์ ์๋ ํ๋ ฌ์ ์์๋ค๊ณผ ๊ณฑํ๋ ค๋ ์ค์นผ๋ผ i ์ ๊ฐ์ธ 6๊ณผ ๊ณฑํด๋ณผ๊ป์
i = 6
y * i
array([[ 6, 18],
[30, 42]])
- ๋์จ๋๋ก ๋ง ๊ทธ๋๋ array์ ์๋ y ํ๋ ฌ์ ์์ ๊ฐ์ 6์ ๊ฐ๊ฐ ๊ณฑํด์ฃผ๋ฉด ๋๋๊ฒ๋๋ค.
๋ ํ๋ ฌ์ ๊ณฑ
- ๋ง์ฝ์ ํ๋ ฌ X ๊ฐ 2 x 3 ํ๋ ฌ์ด๊ณ , ํ๋ ฌ Y ๊ฐ 3 x 2 ํ๋ ฌ์ด ์์ต๋๋ค. X ์ Y ํ๋ ฌ์ ํ๋ฒ ๊ณฑํด๋ณด๊ฒ ์ต๋๋ค.
- ๋ณด์ด๋๊ฒ๊ณผ ๊ฐ์ด 1ํ 1์ด ์๋ X์ 1์ด๊ณผ Y์ 1์ด์ด ๊ณฑํ ๊ฒฐ๊ณผ๊ฐ ๋ค์ด๊ฐ๋๋ค.
- ์ฒซ๋ฒ์งธ ๊ฐ๋ผ๋ฆฌ ๊ณฑํ๊ณ ๋๋ฒ์งธ ๊ฐ๋ผ๋ฆฌ ๊ณฑํ๊ณ ์ธ๋ฒ์งธ ๊ฐ๋ผ๋ฆฌ ๊ณฑํ ๋ค์์ ๋ชจ๋ ๋ํฉ๋๋ค.
- 1 x 2 + 3 x 6 + 5 x 0 = 20 -> 20์ด 1ํ 1์ด์ ๋ค์ด๊ฐ๋๋ค.
- 1 x 4 + 3 x 8 + 5 x 2 = 38 -> 38์ด 1ํ 2์ด์ ๋ค์ด๊ฐ๋๋ค.
- 7 x 2 + 9 x 6 + 1 x 0 = 68 -> 68์ด 2ํ 1์ด์ ๋ค์ด๊ฐ๋๋ค.
- 7 x 4 + 9 x 8 + 1 x 2 = 102 -> 102์ด 2ํ 2์ด์ ๋ค์ด๊ฐ๋๋ค.
- ์ด๋ ๊ฒ X x Y์ ํ๋ ฌ ๊ฐ์ผ๋ก๋ ์์ ๋ณด์ด๋๊ฒ์ฒ๋ผ 2 x 2 ํ๋ ฌ์ด ๋์ต๋๋ค.
- ์ฌ๊ธฐ์ ๋ณด์ด๋ฏ์ด, X ์ Y๋ฅผ ๊ณฑํ๋ฉด, X๊ฐ ํ์ ์ ๊ณต, Y๊ฐ ์ด์ ์ ๊ณตํฉ๋๋ค. ๊ทธ๋์ ๊ฒฐ๊ณผ ํ๋ ฌ์ ๊ฐ์๋ X์ ์ด(column)์ ์์ ๊ฐ๊ณ , Y์ ํ(row)์ ๊ฐ์์ ๊ฐ์ต๋๋ค. X๋ ์ด์ ๊ฐ์๊ฐ 2๊ฐ๊ณ Y๋ ํ์ ๊ฐ์๊ฐ 2๊ฐ ์ด๋ฏ๋ก ๊ฒฐ๊ตญ ํ๋ ฌ์ 2 x 2๋ก ๋์ต๋๋ค.
- ๊ทธ๋ฌ๋ฉด ์ฌ๊ธฐ์ ๋ณด์ด๋ฏ์ด, X์ ์ด์ ๊ฐ์์ Y์ ํ์ ๊ฐ์๊ฐ ๋ง์์ผ ๋ ํ๋ ฌ์ ๊ณฑ์ด ์ฑ๋ฆฝ์ด ๋ฉ๋๋ค.
ํ๋ ฌ๊ฐ์ ๊ณฑ์์ ๊ตํ๋ฒ์น์ด ์ฑ๋ฆฝ ์ํ ๋
- ํ๋ ฌ์ ๊ณฑ์ A์ ์ด(column)์ ์๊ฐ B์ ํ(row)์ ์์ ๊ฐ์์ผ ํ๋ ฌ์ ๊ณฑ์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ์ผ๋ฐ์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ 6x3 ๊ณฑ์ ๊ณผ 3x6 ๊ณฑ์ ์ ๋์ง๋ง, ํ๋ ฌ์ ๊ณฑ์ ์ ์๋ฉ๋๋ค.
- ์ด์ ๋, ์์ ์ค๋ช ํ๋ฏ์ด X์ ์ด์ ๊ฐ์์ Y์ ํ์ ๊ฐ์๊ฐ ๋ง์์ผ ๋ ํ๋ ฌ์ ๊ณฑ์ด ์ฑ๋ฆฝ์ด ๋ฉ๋๋ค. ๊ทธ๋์ XY๊ณฑ์ ์ ๊ฐ๋ฅํ์ง๋ง, YX๊ณฑ์ ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
Numpy๋ก ์์๋ณ ๊ณฑํ๊ธฐ (Example)
- 2๊ฐ์ ํ๋ ฌ A, B๋ฅผ ์ ์ํ, ํ๋ฒ ๊ณฑํด๋ณด๊ฒ ์ต๋๋ค.
import numpy as np
A = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
B = np.array([
[1, 2, 4],
[6, 8, 0],
[1, 2, 4]
])
A * B
array([[ 1, 4, 12],
[24, 40, 0],
[ 7, 16, 36]])
Numpy๋ก ํ๋ ฌ์ฐ์ฐ ์์
- 2A + -B x (C + 2D)
import numpy as np
A = np.array([
[1, -2, 3],
[4, 5, 6]
])
B = np.array([
[0, 2],
[-2, 4],
[4, 6]
])
C = np.array([
[4, -3],
[-2, 1]
])
D = np.array([
[-3, 6],
[6, 3]
])
result = 2 * A @ -B @ (C + 2 * D)
result
array([[ -176, -456],
[-1224, -1148]])
- ์ฌ๊ธฐ result์ ๋ํ๋์๋ ์์์ ๊ฐ ๊ธฐํธ์ ์๋ฏธ๋ ๊ฐ๊ฐ ์ด๋ ์ต๋๋ค.
- ์ซ์/ํ๋ ฌ ์ค์นผ๋ผ ๊ณฑ์ *
- ํ๋ ฌ ๋ง์ ์ +
- ํ๋ ฌ ๊ณฑ์ ์ @
Numpy๋ก ์ ์น, ๋จ์, ์ญํ๋ ฌ
- Numpy์์ ํ๋ ฌ A์ ์ ์นํ๋ ฌ AT๋ฅผ ๊ตฌํ ๋๋
A.T
- ํ๋ ฌ A์ ์ญํ๋ ฌ A-1๋ฅผ ๊ตฌํ ๋๋ ์๋์ฒ๋ผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.
np.linalg.pinv(A)
- Example
result = B.T @ (2*A.T) @ (3*np.linalg.pinv(C) + D.T)
result
array([[ -60., -36.],
[ 276., -348.]])
Numpy์ ์ฐจ์ ๋ฐฐ์ด ํ์ธํด๋ณด๊ธฐ (N์ฐจ์)
- Numpy๋ 1์ฐจ์ ๋ฐฐ์ด(1์ค๋ก ๋์ด์ ๋ฐฐ์ด)๋ฟ๋ง ์๋๋ผ ๋ค์ฐจ์์ ๋ฐฐ์ด๋ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ์๋์ ์์๋ฅผ ๋ณด๋ฉด 2์ฐจ์ ๋ฐฐ์ด์ ์ด๋ ๊ฒ ์์ฑํฉ๋๋ค.
>>> A = np.array([[1,2], [3,4]])
>>> print(A)
[[1 2]
[3 4]]
>>> A.shape
(2,2)
>>> A.dtype
dtype('int64')
- ํ๋ ฌ์ ์ฐจ์์ shape์ผ๋ก ํ์ธํ ์ ์์ผ๋ฉฐ, ํ๋ ฌ์ ๋ด๊ธด ์์์ ์๋ฃํ์ dtype์ผ๋ก ์์ ์์ต๋๋ค.
- ํ๋ ฌ์ ์ฐ์ ์ฐ์ฐ๋ ํ๋ฒ ๋ณด๊ฒ ์ต๋๋ค.
>>> B = np.array([[3, 0], [0, 6]])
>>> A + B
array([[4, 2],
[3, 10]])
>>> A * B
array([[3, 0],
[0, 24]])
- ํ์์ด ๊ฐ์ ํ๋ ฌ๋ผ๋ฆฌ๋ฉด ํ๋ ฌ์ ์ฐ์ ์ฐ์ฐ์ ๋์ํ๋ ์์๋ณ๋ก ๊ณ์ฐ๋ฉ๋๋ค. ๋ฐฐ์ด๋ ๋ง์ฐฌ๊ฐ์ง์ ๋๋ค.
- ํ๋ ฌ๊ณผ ์ค์นผ๋ผ๊ฐ์ ์ฐ์ ์ฐ์ฐ๋ ๊ฐ๋ฅํฉ๋๋ค. ์ด๋ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ธ๋ก๋์บ์คํธ ๊ธฐ๋ฅ์ด ์ ์ฉ๋ฉ๋๋ค. ๊ทผ๋ฐ, ๋ธ๋ก๋์บ์คํธ ๊ธฐ๋ฅ์ด ๋ฌด์์ผ๊น์? ํ๋ฒ ๊ณ์ ๋ณด๊ฒ ์ต๋๋ค.
>>> print(A)
[[1 2]
[3 4]]
>>> A * 10
array([[10, 20],
[30, 40]])
Tip. Numpy ๋ฐฐ์ด์ (np.array)๋ N์ฐจ์์ ๋ฐฐ์ด์ ์์ฑํ ์ ์์ต๋๋ค. 1~3์ฐจ์ ๋ฐฐ์ด๋ถํฐ N์ฐจ์์ ๋ฐฐ์ด์ฒ๋ผ ์ํ๋ N์ฐจ์์ ๋ฐฐ์ด์ ๋ฐ๋ค์ ์๋๊ฒ์ ๋๋ค. ์ํ์์ 1์ฐจ์ ๋ฐฐ์ด์ Vector(๋ฒกํฐ), 2์ฐจ์ ๋ฐฐ์ด์ Matrix(ํ๋ ฌ)์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ๊ทธ๋ฆฌ๊ณ Vector & Matrix๋ฅผ ์ผ๋ฐํ ํ๊ฒ์ Tensor๋ผ๊ณ ํฉ๋๋ค.
Broadcast (๋ธ๋ก๋์บ์คํธ)
- Numpy์์๋ ํ์์ด ๋ค๋ฅธ ๋ฐฐ์ด๋ผ๋ฆฌ๋ ๊ณ์ฐ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด์ 2 * 2 ํ๋ ฌ A์ Scaler๊ฐ 10์ ๊ณฑํ์ต๋๋ค. ์ด๋ 10์ด๋ผ๋ Scaler๊ฐ์ด 2 * 2 ํ๋ ฌ๋ก ํ๋๋ ํ ์ฐ์ฐ์ด ์ด๋ค์ง๋๋ค.
- ์ด๋ฌํ ๊ธฐ๋ฅ์ Broadcast (๋ธ๋ก๋์บ์คํธ)๋ผ๊ณ ํฉ๋๋ค.
# Broadcast Example
>>> A = np.array([[1, 2], [3, 4]])
>>> B = np.array([[10, 20]])
>>> A * B
array([[10, 40],
[30, 80]])
- ์์ Broadcast์ ์์๋ฅผ ๋ณด๋ฉด, 1์ฐจ์ ๋ฐฐ์ด์ธ B๊ฐ 2์ฐจ์ ๋ฐฐ์ด์ธ A์ ๋๊ฐ์ ํ์์ผ๋ก ๋ณํ๋ ํ ์์๋ณ ์ฐ์ฐ์ด ์งํ๋ฉ๋๋ค.
Numpy์ ์์ ์ ๊ทผ
- ์์์ Index๋ 0๋ถํฐ ์์ํฉ๋๋ค. Index๋ก ์์์ ์ ๊ทผํ๋ ์์๋ ์๋์ ์ฝ๋์ ๊ฐ์ต๋๋ค.
>>> X = np.array([[51, 55], [14, 19], [0, 4]])
>>> print(X)
[[51 55]
[14 19]
[0 4]
>>> X[0] # 0ํ
array([51, 55])
>>> X[0][1] #(0, 1) ์์น์ ์์
55
- for๋ฌธ์ผ๋ก๋ ๊ฐ ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค.
>>> for row in X:
... print(row)
...
[51 55]
[14 19]
[0 4]
- ์๋๋ฉด Index๋ฅผ array(๋ฐฐ์ด)๋ก ์ง์ ํด์ ํ๋ฒ์ ์ฌ๋ฌ ์์์ ์ ๊ทผํ ์๋ ์์ต๋๋ค.
- ์ด ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ฉด ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์๋ง ์ป์ ์ ์์ต๋๋ค.
>>> X = X.flatten() #x๋ฅผ 1์ฐจ์ ๋ฐฐ์ด๋ก ๋ณํธ๋(ํํํ)
>>> print(X)
[51 55 14 19 0 4]
>>> X[np.array([0, 2, 4])] # ์ธ๋ฑ์ค๊ฐ 0, 2, 4๋ฒ์งธ์ ์๋ ์์ ์ป๊ธฐ
array([51, 14, 0])
- ์๋์ ์ฝ๋๋ ๋ฐฐ์ด์์ X์์ 15 ์ด์์ธ ๊ฐ๋ง ๊ตฌํ ์ ์์ต๋๋ค.
>>> X > 15
array([True, True, False, True, False, False], dtype=bool)
>>> X[X>15]
array([51, 55, 19])
- Numpy ๋ฐฐ์ด์ ๋ถ๋ฑํธ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ๊ฒฐ๊ณผ๋ bool ๋ฐฐ์ด์ ๋๋ค. (์ฌ๊ธฐ์๋ X>15)
- ์ฌ๊ธฐ์๋ ์ด bool ๋ฐฐ์ด์ ์ฌ์ฉํด ๋ฐฐ์ด X์์ True์ ํด๋นํ๋ ์์, ์ฆ ๊ฐ์ด 15๋ณด๋ค ํฐ ์์๋ง ๊บผ๋ด๊ณ ์์ต๋๋ค.
- Ps. ๋ค์๊ธ์๋ Matplotlib ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฐํ์ฌ ์๊ฐํ๋ ๊ธ์ ๋ค๊ณ ์ค๊ฒ ์ต๋๋ค.
๋ฐ์ํ
'๐ฅ๏ธ Deep Learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[DL] Neural Networks (์ ๊ฒฝ๋ง) (0) | 2024.03.17 |
---|---|
[DL] Perceptron (ํผ์ ํธ๋ก ) (0) | 2024.03.12 |
[DL] Matplotlib ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฐํ์ฌ ์์๋ณด๊ธฐ (0) | 2024.03.05 |
[DL] Gradient Vanishing, Exploding - ๊ธฐ์ธ๊ธฐ ์์ค, ํญํ (0) | 2024.01.26 |
[DL] Preparations for Deep Learning - ์ค๋น์ฌํญ & Python ๊ธฐ๋ณธ๋ฌธ๋ฒ (0) | 2023.07.26 |