ํŒŒ์ด์ฌ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ : Numpy

Posted by Euisuk's Dev Log on May 8, 2023

ํŒŒ์ด์ฌ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ : 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๋Š” ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์™€ ๋ถ„์„, ๊ณผํ•™ ๊ณ„์‚ฐ, ๋จธ์‹  ๋Ÿฌ๋‹ ๋“ฑ ๋‹ค์–‘ํ•œ ๋ถ„์•ผ์—์„œ ๋„๋ฆฌ ์‚ฌ์šฉ๋˜๊ณ  ์žˆ์œผ๋ฉฐ, ๋‹ค์–‘ํ•œ ๊ธฐ๋Šฅ๊ณผ ๋ฉ”์†Œ๋“œ๋ฅผ ์ œ๊ณตํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฐ์ดํ„ฐ ๋ถ„์„ ๋ฐ ์ฒ˜๋ฆฌ์— ์œ ์šฉํ•œ ํŒจํ‚ค์ง€ ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค.



-->