Numpy 기초 개념

Numpy Array

• NumPy는 Python에서 수치 데이터를 다루기 위한 강력한 라이브러리이다.
• numpy array: numpy가 제공하는 homogeneous multi-dimensional array 데이터 타입

numpy array 생성하기

import numpy as np
# 1D 배열 생성
array_1d = np.array([1, 2, 3])
print(array_1d)
# 2D 배열 생성
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(array_2d)
# 0으로 채워진 3x3 배열 생성
zeros_array = np.zeros((3, 3))
print(zeros_array)
# 1로 채워진 2x2 배열 생성, element type을 float32로 지정
ones_array = np.ones( (2,2), dtype = np.float32 )
#대표적 dtype: int32, int64, float32, float64 등
print(ones_array)
# 임의의 값으로 채워진 3x3 배열 생성
random_array = np.random.random((3, 3))
print(random_array)
# arange를 통한 생성
e = np.arange(1,5, 0.1)
print(e)

결과:
[1 2 3]
[[1 2 3]
 [4 5 6]]
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[1. 1.]
 [1. 1.]]
[[0.04869459 0.83700269 0.30834401]
 [0.20215803 0.04685619 0.80459713]
 [0.41606462 0.54409761 0.06405381]]
[1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.  2.1 2.2 2.3 2.4 2.5 2.6 2.7
 2.8 2.9 3.  3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 4.  4.1 4.2 4.3 4.4 4.5
 4.6 4.7 4.8 4.9]

ndarrary attributes

import numpy as np
a = np.arange(15)
print(a)
print(a.shape)
a = a.reshape(3,5)
print(a)
print(a.ndim)
print(a.dtype)
print(a.itemsize) #배열의 각 요소의 크기를 바이트 단위로 반환
print(a.size) #요소 개수 출력
print(type(a))

결과:
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
(15,)
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
2
int64
8
15
<class 'numpy.ndarray'>

연산

• numpy array의 연산자는 원소단위(elementwise) 연산자임, 벡터화 연산 처리
• 벡터화 연산: (파이썬 level에서) for 루프가 아닌, CPU의 SIMD 벡터 명령어를 통해서 최적화 하여 처리하는 방식이다. 대부분 원소단위 연산자는 벡터화 연산이 가능하다.
• numpy array 두 가지 곱셈 방식(* vs dot←내적)
• dot 연산 ← 코사인 유사도 계산할때를 위해 사용한다. →1차원 배열 계산이면 내적값이 나온다. (스칼라값) → 다차원 배열이었다면 행렬의 곱셈이다. (elementwise 곱셈이 아니라)
  

C = A*B

D = np.dot(A,B)

1차원 배열, 2차원 배열에서의 연산

import numpy as np
# 1차원 배열
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 원소별 곱셈 (Elementwise multiplication)
result_mul = a * b
print(f"a * b : {result_mul}")
# 벡터 내적 (Dot product)
result_dot = np.dot(a, b)
print(f"np.dot(a, b) : {result_dot }")

# 2차원 배열
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
# 원소별 곱셈 (Element-wise multiplication)
result_mul = a * b
print(f"a * b : {result_mul}")
# 행렬 곱셈 (Dot product)
result_dot = np.dot(a, b)
print(f"np.dot(a, b) : {result_dot }")

결과:
a * b : [ 4 10 18]
np.dot(a, b) : 32
a * b : [[ 5 12]
 [21 32]]
np.dot(a, b) : [[19 22]
 [43 50]]

1차원/2차원 배열 혼합에서 *연산 vs dot 연산

import numpy as np
# a는 2차원, b는 1차원 배열
a = np.array([[1, 2], [3, 4]])
b = np.array( [5, 6] )

# 원소별 곱셈 (Elementwise multiplication)
result_mul = a * b
print(f"a * b : {result_mul}")
# b 벡터가 브로드캐스팅 규칙에 의해서 (2,2) 로 확장된 후, 곱셈이 이루어짐.
# (2,) -> (1,2) -> (2,2) 로 확장됨.

# 행렬 곱셈 (Dot product)
result_dot = np.dot(a, b)
print(f"np.dot(a, b) : {result_dot }")
# (2,2) 와 (2,1)의 행렬곱셈

결과:
a * b : [[ 5 12]
				 [15 24]]
np.dot(a, b) : [17 39]

• 원소별 곱셈에서는 두 배열의 shape이 다를 때, 작은 배열의 차원을 자동으로 확장해 연산 가능한 형태로 맞춰준다. → 브로드캐스팅
• dot 연산은 브로드캐스팅이 아니라 수학적 내적 규칙을 따르는 것이다.

dot연산의 입력 배열에 따른 결과값 차이

• 두 입력 배열이 모두 1차원 → 스칼라 값
• 2차원과 1차원 배열 연산 → 행렬과 벡터의 곱
• 둘다 2차원 배열 → 일반적인 행렬의 곱

ML/DL에서 자주 사용하는 numpy 연산들(1)

#Reshape 연산
array_1d = np.array([1, 2, 3, 4, 5, 6])
reshaped_array = array_1d.reshape(2, 3)
print(reshaped_array)
# 출력:
# [[1 2 3]
# [4 5 6]]

#Flatten 연산
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array_2d.flatten()
print(flattened_array)
# 출력: [1 2 3 4 5 6]

#Transpose 연산
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
transposed_array = array_2d.T
print(transposed_array)
# 출력:
# [[1 4]
# [2 5]
# [3 6]]

ML/DL에서 자주 사용하는 numpy 연산들(2)

#Concatenate 연산 (axis을 기준으로 결합하는 연산)
# 두 개의 2x3 배열 생성
array1 = np.array([[1, 2, 3], [4, 5, 6]])
array2 = np.array([[7, 8, 9], [10, 11, 12]])
# 행 방향으로 concatenate (axis=0)
concatenated_array = np.concatenate((array1, array2), axis=0)
print(concatenated_array)
# 출력: [[ 1  2  3]
				[ 4  5  6]
				[ 7  8  9]
				[10 11 12]]
# 열 방향으로 concatenate (axis=1)
concatenated_array = np.concatenate((array1, array2), axis=1)
print(concatenated_array)
# 출력: [[ 1  2  3  7  8  9]
				[ 4  5  6 10 11 12]]

#Expand_dims 연산 (지정한 위치에 차원을 추가하는 연산)
#axis=0은 행벡터, axis=1은 열벡터
array_1d = np.array([1, 2, 3])
expanded_array = np.expand_dims(array_1d, axis=0)
print(expanded_array)
# 출력: [[1 2 3]]

#Squeeze 연산
# 3D 배열
array_3d = np.array([[[1, 2, 3]]])
# squeeze 연산 적용: 크기가 1인 축을 제거
squeezed_array = np.squeeze(array_3d)
print(squeezed_array)
# 출력: [1 2 3]

ML/DL에서 자주 사용하는 numpy 연산들(3)

#argmax, argmin 연산 (가장 큰 값, 작은 값 인덱스 탐색)
array = np.array([0.1, 0.3, 0.4, 0.2])
index_of_max = np.argmax(array)
print(index_of_max)
# 출력: 2 (가장 큰 값인 0.4의 인덱스)

#argsort 연산 (정렬했을 때의 인덱스 반환)
array = np.array([0.1, 0.3, 0.4, 0.2])
sorted_indices = np.argsort(array)
print(sorted_indices)
# 출력: [0 3 1 2]

#dot 연산
# 2D 배열
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
dot_product = np.dot(A, B)
print(dot_product)
# 출력: [[19 22]
#		[43 50]]