A A
[DL] Numpy & ํ–‰๋ ฌ์— ๋ฐํ•˜์—ฌ ์•Œ์•„๋ณด๊ธฐ

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์™€ ๋˜‘๊ฐ™์€ ํ˜•์ƒ์œผ๋กœ ๋ณ€ํ˜•๋œ ํ›„ ์›์†Œ๋ณ„ ์—ฐ์‚ฐ์ด ์ง„ํ–‰๋ฉ๋‹ˆ๋‹ค.

Broadcast Example


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 ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์— ๋ฐํ•˜์—ฌ ์†Œ๊ฐœํ•˜๋Š” ๊ธ€์„ ๋“ค๊ณ  ์˜ค๊ฒ ์Šต๋‹ˆ๋‹ค.