ํ์ด์ฌ ๋ง์คํฐํ๊ธฐ : Numpy
์๋ณธ ๊ฒ์๊ธ: https://velog.io/@euisuk-chung/ํ์ด์ฌ-์๊ฐํ-๋ง์คํฐํ๊ธฐ-Numpy
NumPy๋?
NumPy๋ Python์์ ๊ณผํ ์ฐ์ฐ์ ์ํ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํจํค์ง ์ค ํ๋์ ๋๋ค. NumPy๋ โNumeric Pythonโ์ ์ฝ์์ด๋ฉฐ ๋๊ท๋ชจ ๋ค์ฐจ์ ๋ฐฐ์ด๊ณผ ํ๋ ฌ ์ฐ์ฐ์ ํ์ํ ๋ค์ํ ํจ์์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. NumPy๋ ๋ฐ์ดํฐ ๋ถ์, ๋ฐ์ดํฐ ์ฒ๋ฆฌ, ์ ํ ๋์, ๋จธ์ ๋ฌ๋ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ๋๋ฆฌ ์ฌ์ฉ๋๊ณ ์์ต๋๋ค.
NumPy์ ์ค์น
NumPy๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋จผ์ NumPy ํจํค์ง๋ฅผ ์ค์นํด์ผ ํฉ๋๋ค. ์๋์ ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํ์ฌ NumPy๋ฅผ ์ค์นํ ์ ์์ต๋๋ค.
1
pip install numpy
NumPy ๋ฐฐ์ด ์์ฑ
NumPy์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ๋ฐฐ์ด์
๋๋ค. NumPy ๋ฐฐ์ด์ ๋์ผํ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ๋ค์ฐจ์ ๋ฐฐ์ด์
๋๋ค. NumPy ๋ฐฐ์ด์ ndarray
ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑํ ์ ์์ต๋๋ค. NumPy ๋ฐฐ์ด์ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
4
5
6
7
8
9
10
import numpy as np
# 1์ฐจ์ ๋ฐฐ์ด ์์ฑ
a = np.array([1, 2, 3])
# 2์ฐจ์ ๋ฐฐ์ด ์์ฑ
b = np.array([[1, 2, 3], [4, 5, 6]])
# 3์ฐจ์ ๋ฐฐ์ด ์์ฑ
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
NumPy ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ shape
์์ฑ์ ์ฌ์ฉํฉ๋๋ค. (์ถ๋ ฅ๊ฐ์ ์์ ์ฃผ์ ์ฐธ๊ณ )
1
2
3
print(a.shape) # (3,)
print(b.shape) # (2, 3)
print(c.shape) # (2, 2, 2)
NumPy ๋ฐฐ์ด ์ฐ์ฐ
NumPy ๋ฐฐ์ด์ ๋ค๋ฅธ ๋ฐฐ์ด ๋๋ ์ค์นผ๋ผ์์ ์ฐ์ฐ์ ์ง์ํฉ๋๋ค. NumPy ๋ฐฐ์ด์ ์ฐ์ฐ์ ๋ฐฐ์ด์ ์์๋ณ(element-wise)
๋ก ์ด๋ฃจ์ด์ง๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# ์์๋ณ ๋ง์
c = a + b # [5, 7, 9]
# ์์๋ณ ๊ณฑ์
d = a * b # [4, 10, 18]
# ์ค์นผ๋ผ์์ ์ฐ์ฐ
e = a + 1 # [2, 3, 4]
NumPy ๋ฐฐ์ด์ ์ฐ์ฐ์๋ ๋ค์ํ ํจ์์ ๋ฉ์๋๊ฐ ์์ต๋๋ค. ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ฐ์ sum
, mean
, min
, max
์
๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
a = np.array([1, 2, 3])
# ํฉ๊ณ
b = np.sum(a) # 6
# ํ๊ท
c = np.mean(a) # 2.0
# ์ต์๊ฐ
d = np.min(a) # 1
# ์ต๋๊ฐ
e = np.max(a) # 3
NumPy ๋ฐฐ์ด ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ
NumPy ๋ฐฐ์ด์ ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ์ Python ๋ฆฌ์คํธ์ ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ๊ณผ ๋งค์ฐ ์ ์ฌํฉ๋๋ค. NumPy ๋ฐฐ์ด์ ์ธ๋ฑ์ฑ๊ณผ ์ฌ๋ผ์ด์ฑ์ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์ผ๋ถ๋ฅผ ์ ํํ ์ ์์ต๋๋ค.
1
2
3
4
5
6
7
8
9
10
a = np.array([1, 2, 3, 4, 5])
# ์ธ๋ฑ์ฑ
b = a[0] # 1
c = a[2] # 3
# ์ฌ๋ผ์ด์ฑ
d = a[1:4] # [2, 3, 4]
e = a[:3] # [1, 2, 3]
f = a[3:] # [4, 5]
๋ค์ฐจ์ NumPy ๋ฐฐ์ด์์๋ ๊ฐ ์ฐจ์์ ์ธ๋ฑ์ค๋ฅผ ์ฝค๋ง๋ก ๊ตฌ๋ถํ์ฌ ์ธ๋ฑ์ฑํ ์ ์์ต๋๋ค.
1
2
3
4
5
6
7
8
9
10
a = np.array([[1, 2, 3], [4, 5, 6]])
# ์ธ๋ฑ์ฑ
b = a[0, 0] # 1
c = a[1, 2] # 6
# ์ฌ๋ผ์ด์ฑ
d = a[0, 1:3] # [2, 3]
e = a[:, 1] # [2, 5]
f = a[:, :2] # [[1, 2], [4, 5]]
NumPy ๋ฐฐ์ด ํํ ๋ณ๊ฒฝ
NumPy ๋ฐฐ์ด์ ํํ๋ฅผ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
4
5
6
7
a = np.array([[1, 2], [3, 4], [5, 6]])
# ๋ฐฐ์ด์ ํํ ๋ณ๊ฒฝ
b = a.reshape((2, 3)) # [[1, 2, 3], [4, 5, 6]]
# ๋ฐฐ์ด ์ ์น
c = a.T # [[1, 3, 5], [2, 4, 6]]
NumPy ๋ฐฐ์ด ๋ณํฉ๊ณผ ๋ถ๋ฆฌ
NumPy ๋ฐฐ์ด์ ๋ณํฉํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
4
5
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# ๋ฐฐ์ด ๋ณํฉ
c = np.concatenate((a, b)) # [1, 2, 3, 4, 5, 6]
๋ค์ฐจ์ NumPy ๋ฐฐ์ด์ ๋ณํฉํ๋ ๋ฐฉ๋ฒ์ concatenate()
ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. concatenate()
ํจ์๋ ๋ณํฉํ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ ๋ฌํ๋ฉฐ, ๋ ๊ฐ ์ด์์ ๋ฐฐ์ด์ ๋ณํฉํ ๊ฒฝ์ฐ์๋ ํํ ํํ๋ก ์ ๋ฌํฉ๋๋ค. axis
์ธ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ณํฉํ ๋ฐฉํฅ์ ์ง์ ํ ์ ์์ต๋๋ค. axis
์ธ์๋ฅผ ์ง์ ํ์ง ์์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ์ธ 0์ผ๋ก ์ค์ ๋ฉ๋๋ค.
1
2
3
4
5
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
# ๋ฐฐ์ด ๋ณํฉ
c = np.concatenate((a, b), axis=0) # [[1, 2], [3, 4], [5, 6]]
์์ ์์ ์์ concatenate()
ํจ์์ axis=0
์ ์ฒซ ๋ฒ์งธ ์ฐจ์์ ๋ฐ๋ผ ๋ฐฐ์ด์ ๋ณํฉํ๋ค๋ ์๋ฏธ์
๋๋ค. ๋ฐ๋ผ์ ์์ ์์ ์์๋ a
์ b
๋ฐฐ์ด์ด ์ฒซ ๋ฒ์งธ ์ฐจ์์ ๊ณต์ ํ๋ฏ๋ก axis=0
์ผ๋ก ์ค์ ํ์ฌ ๋ฐฐ์ด์ ๋ณํฉํ ์ ์์ต๋๋ค.
NumPy ๋ฐฐ์ด์ ๋ถ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
4
a = np.array([1, 2, 3, 4, 5, 6])
# ๋ฐฐ์ด ๋ถ๋ฆฌ
b, c = np.split(a, [3]) # [1, 2, 3], [4, 5, 6]
๋ค์ฐจ์ NumPy ๋ฐฐ์ด์ ๋ถ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ split()
ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. split()
ํจ์๋ ๋ถ๋ฆฌํ ๋ฐฐ์ด๊ณผ ๋ถ๋ฆฌํ ์ธ๋ฑ์ค๋ฅผ ์ ๋ฌํ๋ฉฐ, ๋ถ๋ฆฌํ ์ธ๋ฑ์ค๋ ๋ถ๋ฆฌ๋ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ฐจ์์ ๋ฐ๋ผ ์ง์ ํฉ๋๋ค. split()
ํจ์๋ ๋ถ๋ฆฌ๋ ๋ฐฐ์ด์ ํํ ํํ๋ก ๋ฐํํฉ๋๋ค.
1
2
3
4
a = np.array([[1, 2, 3], [4, 5, 6]])
# ๋ฐฐ์ด ๋ถ๋ฆฌ
b, c = np.split(a, [1], axis=0) # [[1, 2, 3]], [[4, 5, 6]]
์์ ์์ ์์ split()
ํจ์์ axis=0
์ ์ฒซ ๋ฒ์งธ ์ฐจ์์ ๋ฐ๋ผ ๋ฐฐ์ด์ ๋ถ๋ฆฌํ๋ค๋ ์๋ฏธ์
๋๋ค. ๋ฐ๋ผ์ ์์ ์์ ์์๋ a
๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ํ์ ๊ธฐ์ค์ผ๋ก ๋ฐฐ์ด์ ๋ถ๋ฆฌํ ์ ์์ต๋๋ค.
์ด์ ๋ง์ง๋ง์ผ๋ก NumPy ๋ฐฐ์ด์ ๋ค๋ฃฐ ๋ ์ ์ฉํ ๋ช ๊ฐ์ง ํจ์๋ฅผ ์๊ฐํ๊ฒ ์ต๋๋ค.
NumPy ์ฃผ์ ํจ์
NumPy๋ ๋ฐฐ์ด์ ๊ณ์ฐ๊ณผ ๊ด๋ จ๋ ๋ค์ํ ํจ์๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ด ์ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํจ์๋ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
np.zeros()
: ๋ชจ๋ ์์๊ฐ 0์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.np.ones()
: ๋ชจ๋ ์์๊ฐ 1์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.np.arange()
: ๋ฒ์ ๋ด์ ์ผ์ ๊ฐ๊ฒฉ์ ๊ฐ์ง ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.np.linspace()
: ๋ฒ์ ๋ด์์ ๊ท ๋ฑ ๊ฐ๊ฒฉ์ผ๋ก ์ํ๋ ๊ฐ์์ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.np.random.random()
: 0๋ถํฐ 1์ฌ์ด์ ๋์๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.np.random.randn()
: ํ๊ท ์ด 0์ด๊ณ ํ์คํธ์ฐจ๊ฐ 1์ธ ์ ๊ท ๋ถํฌ๋ฅผ ๋ฐ๋ฅด๋ ๋์๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
์ด ์ธ์๋ NumPy๋ ๋ค์ํ ์ํ ํจ์๋ฅผ ์ ๊ณตํฉ๋๋ค. ์๋ฅผ ๋ค์ด, np.sin()
, np.cos()
, np.exp()
, np.log()
๋ฑ์ด ์์ต๋๋ค. ์ด๋ฌํ ํจ์๋ค์ NumPy ๋ฐฐ์ด์์ ์ฌ์ฉ๋์ด ๋ฐฐ์ด์ ์์๋ค์ ๊ณ์ฐํฉ๋๋ค.
๊ฐ๊ฐ์ ๋ํด์ ์ข ๋ ์์ธํ๊ฒ ์ดํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
np.zeros()
np.zeros()
ํจ์๋ ๋ชจ๋ ์์๊ฐ 0์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ํฌ๊ธฐ๊ฐ 2x3์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.zeros((2, 3))
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
[[0. 0. 0.]
[0. 0. 0.]]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.zeros()
ํจ์๋ ๋ชจ๋ ์์๊ฐ 0์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
np.ones()
np.ones()
ํจ์๋ ๋ชจ๋ ์์๊ฐ 1์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ํฌ๊ธฐ๊ฐ 2x4์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.ones((2, 4))
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
[[1. 1. 1. 1.]
[1. 1. 1. 1.]]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.ones()
ํจ์๋ ๋ชจ๋ ์์๊ฐ 1์ธ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
np.arange()
np.arange()
ํจ์๋ ๋ฒ์ ๋ด์ ์ผ์ ๊ฐ๊ฒฉ์ ๊ฐ์ง ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ๋ฒ์์ ๊ฐ๊ฒฉ์ ์ง์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฒ์๊ฐ 1์์ 10๊น์ง์ด๊ณ ๊ฐ๊ฒฉ์ด 2์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.arange(1, 10, 2)
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
[1 3 5 7 9]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.arange()
ํจ์๋ ๋ฒ์ ๋ด์ ์ผ์ ๊ฐ๊ฒฉ์ ๊ฐ์ง ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
np.linspace()
np.linspace()
ํจ์๋ ๋ฒ์ ๋ด์์ ๊ท ๋ฑ ๊ฐ๊ฒฉ์ผ๋ก ์ํ๋ ๊ฐ์์ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ๋ฒ์์ ์ํ๋ ๊ฐ์๋ฅผ ์ง์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฒ์๊ฐ 0์์ 1๊น์ง์ด๊ณ ์ํ๋ ๊ฐ์๊ฐ 5๊ฐ์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.linspace(0, 1, 5)
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
[0. 0.25 0.5 0.75 1. ]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.linspace()
ํจ์๋ ๋ฒ์ ๋ด์์ ๊ท ๋ฑ ๊ฐ๊ฒฉ์ผ๋ก ์ํ๋ ๊ฐ์์ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
np.random.random()
np.random.random()
ํจ์๋ 0๊ณผ 1์ฌ์ด์ ๊ท ๋ฑ ๋ถํฌ์์ ๋์๋ฅผ ์์ฑํ์ฌ ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํฌ๊ธฐ๊ฐ 3x3์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.random.random((3, 3))
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
[[0.8139928 0.79544491 0.43146849]
[0.30136094 0.77515306 0.64259144]
[0.02956163 0.74888294 0.56169272]]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.random.random()
ํจ์๋ ์ง์ ๋ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ์์ฑํ๋ฉฐ, ๋ฐฐ์ด์ ๊ฐ ์์๋ 0๊ณผ 1 ์ฌ์ด์ ๋์๋ก ์ฑ์์ง๋๋ค.
np.random.randn()
np.random.randn()
ํจ์๋ ํ๊ท ์ด 0์ด๊ณ ํ์คํธ์ฐจ๊ฐ 1์ธ ์ ๊ท ๋ถํฌ๋ฅผ ๋ฐ๋ฅด๋ ๋์๋ฅผ ์์ฑํ์ฌ ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค. ํจ์์ ์ธ์๋ก๋ ์์ฑํ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํฌ๊ธฐ๊ฐ 2x4์ธ ๋ฐฐ์ด์ ์์ฑํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
1
2
3
4
import numpy as np
arr = np.random.randn(2, 4)
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
[[ 0.52346546 0.30785207 0.63301317 -0.03108197]
[ 1.37352221 -1.26632616 -1.15567608 -0.52687134]]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด np.random.randn()
ํจ์๋ ์ง์ ๋ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ์์ฑํ๋ฉฐ, ๋ฐฐ์ด์ ๊ฐ ์์๋ ํ๊ท ์ด 0์ด๊ณ ํ์คํธ์ฐจ๊ฐ 1์ธ ์ ๊ท ๋ถํฌ๋ฅผ ๋ฐ๋ฅด๋ ๋์๋ก ์ฑ์์ง๋๋ค.
NumPy ๊ธฐํ ํจ์
๊ทธ ์ธ์๋ Numpy์๋ ๋ง์ ์ ์ฉํ ํจ์๋ค์ด ๋ด์ฅ๋์ด ์๋๋ฐ ๋ํ์ ์ธ ๋ช๊ฐ์ง ํจ์๋ค์ ์๊ฐํด๋๋ฆฌ๋ ค๊ณ ํฉ๋๋ค.
Numpy ์ํ ํจ์
์์์ ์ด๋ฏธ ๋ง์ด ์ฐ์ด๋ ํจ์๋ก sum(), mean(), min(), max()๋ฅผ ์๊ฐํ ๋ฐ ์์ง๋ง, ํด๋น ํจ์๋ฅผ ๋ง๊ณ ๋ ๋ค์ํ ํจ์๋ค์ด ์กด์ฌํฉ๋๋ค.
sum()
,mean()
: ๋ฐฐ์ด ์ ์ฒด ํฉ, ํ๊ทcumsum()
,cumprod()
: ๋ฐฐ์ด ๋์ ํฉ, ๋์ ๊ณฑstd()
,var()
: ํ์คํธ์ฐจ, ๋ถ์ฐmin()
,max()
: ์ต์๊ฐ, ์ต๋๊ฐargmin()
,argmax()
: ์ต์ ์์์ ์์ธ ๊ฐ, ์ต๋ ์์์ ์์ธ ๊ฐ
Numpy ๋์ ํจ์
NumPy ๋ชจ๋์ ๋๋ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ค์ํ ๋ถํฌ์์ ๋์๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ์ ๋ชจ์ ์คํ์ ์ํํ๊ฑฐ๋ ์๋ฎฌ๋ ์ด์ ์ ๊ตฌํํ ์ ์์ต๋๋ค. numpy.random ๋ชจ๋์ ๊ฒฝ์ฐ๋ ๋ค์ํ ์ข ๋ฅ์ ํ๋ฅ ๋ถํฌ๋ก๋ถํฐ ํจ๊ณผ์ ์ผ๋ก ํ๋ณธ ๊ฐ์ ์์ฑํ๋๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
seed()
: ๋์ ๋ฐ์๊ธฐ์ seed๋ฅผ ์ง์ ํ๋ค.permutation()
: ์์์ ์์ด์ ๋ฐํํ๋ค.shuffle()
: ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ ์์๋ฅผ ๋ค์๋๋ค.rand()
: ๊ท ๋ฑ๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.randint()
: ์ฃผ์ด์ง ์ต์/์ต๋ ๋ฒ์ ์์์ ์์์ ๋์๋ฅผ ์ถ์ถํ๋ค.randn()
: ํ์คํธ์ฐจ๊ฐ 1์ด๊ณ ํ๊ท ๊ฐ์ด 0์ธ ์ ๊ท๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.binomial()
: ์ดํญ๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.normal()
: ์ ๊ท๋ถํฌ(๊ฐ์ฐ์์)์์ ํ๋ณธ์ ์ถ์ถํ๋ค.beta()
: ๋ฒ ํ๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.chisquare()
: ์นด์ด์ ๊ณฑ๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.gamma()
: ๊ฐ๋ง๋ถํฌ์์ ํ๋ณธ์ ์ถ์ถํ๋ค.uniform()
: ๊ท ๋ฑ(0,1)์์ ํ๋ณธ์ ์ถ์ถํ๋ค.
๐ค ์๋ ๊ทผ๋ฐ normal
ํจ์๋ randn
ํจ์๋ ๋๋ค ์ ๊ท๋ถํฌ ์๋๊ฐ์?
๐ฃ ๋ค! ๋ง์ต๋๋ค. ํ์ง๋ง, randn()
ํจ์์ normal()
ํจ์๋ ๋ชจ๋ ์ ๊ท๋ถํฌ์์ ๋์๋ฅผ ์์ฑํฉ๋๋ค. ํ์ง๋ง ๋ ํจ์์๋ ์ฝ๊ฐ์ ์ฐจ์ด์ ์ด ์์ต๋๋ค.
randn()
ํจ์๋ ํ์คํธ์ฐจ๊ฐ 1์ด๊ณ ํ๊ท ์ด 0์ธ ํ์ค์ ๊ท๋ถํฌ(standard normal distribution)์์ ๋์๋ฅผ ์์ฑํฉ๋๋ค. ์ฆ, ๋ค๋ฅธ ํ๋ผ๋ฏธํฐ๊ฐ ์ฃผ์ด์ง์ง ์์ ๊ฒฝ์ฐ,randn()
ํจ์๋normal(0, 1)
๊ณผ ๋์ผํ ์ญํ ์ ํฉ๋๋ค.- ๋ฐ๋ฉด์,
normal()
ํจ์๋ ํ๊ท ๊ฐ(mu)๊ณผ ํ์คํธ์ฐจ(sigma)๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด ํ๊ท ๊ฐ์ด 2์ด๊ณ ํ์คํธ์ฐจ๊ฐ 3์ธ ์ ๊ท๋ถํฌ์์ 2x2 ํฌ๊ธฐ์ ๋ฐฐ์ด์ ์์ฑํ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
1
2
3
4
import numpy as np
arr = np.random.normal(loc=2, scale=3, size=(2, 2))
print(arr)
์ ์ฝ๋์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
[[ 0.17468078 2.09660262]
[ 0.03441699 -1.12143515]]
์์ ์ถ๋ ฅ ๊ฒฐ๊ณผ์์ ๋ณด๋ฏ์ด, normal()
ํจ์๋ ํ๊ท ๊ฐ๊ณผ ํ์คํธ์ฐจ๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก
์ด์์ผ๋ก NumPy์ ๋ํ ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ ๋ฐฉ๋ฒ๊ณผ ํจ์์ ๋ํด ์์๋ณด์์ต๋๋ค. NumPy๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ๋ถ์, ๊ณผํ ๊ณ์ฐ, ๋จธ์ ๋ฌ๋ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ๋๋ฆฌ ์ฌ์ฉ๋๊ณ ์์ผ๋ฉฐ, ๋ค์ํ ๊ธฐ๋ฅ๊ณผ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ ๋ถ์ ๋ฐ ์ฒ๋ฆฌ์ ์ ์ฉํ ํจํค์ง ์ค ํ๋์ ๋๋ค.