[AI] Numpy 정리

데이터를 처리할때 유용하게 사용되는 Numpy에 대해 강의 내용을 토대로 정리해보려한다.

Numpy란?

Numpy는 파이썬 프로그래밍 언어를 위한 오픈 소스 수치 계산 라이브러리이며, 고성능의 다차원 배열 및 행렬 연산을 지원한다. Numpy는 데이터 분석, 과학적인 연구, 기계 학습, 인공 지능 등 다양한 분야에서 널리 사용된다.

Numpy 주요기능

import numpy as np 

numpy를 불러올때 일반적으로 np로 줄여서 사용한다.

ndarray

list1 = [1, 2, 3]
array1 = np.array(list1) # 1차원 ndarray

array2 = np.array([[1,2,3],
                  [2,3,4]]) # 2차원 ndarray

np.array 함수를 통해 리스트를 numpy의 ndarray 형태로 만들 수 있다.

ndim

print('array1: {:0}차원, array2: {:1}차원, array3: {:2}차원'.format(array1.ndim,array2.ndim,array3.ndim))

array1: 1차원, array2: 2차원, array3:  2차원

numpy배열에 ndim을 통해 차원을 확인할 수 있다.

ndarray 확장 변환

list2 = [1, 2, 'test']
array2 = np.array(list2)
print(array2, array2.dtype)

list3 = [1, 2, 3.0]
array3 = np.array(list3)
print(array3, array3.dtype)

['1' '2' 'test'] <U11
[1. 2. 3.] float64

출력값에서 알 수 있듯이 ndarray에 다른 타입이 들어올 경우 타입 데이터가 더 큰 쪽으로 확장 변환이 된다.

arange, zeros, ones

sequence_array = np.arange(10)
print(sequence_array)
print(sequence_array.dtype, sequence_array.shape)

[0 1 2 3 4 5 6 7 8 9]
int32 (10,)

numpy에 arrange 함수를 통해 원하는 범위의 ndarray를 간편하게 생성할 수 있다.

#(3, 2) shape을 가지는 모든 원소가 0, dtype은 int32 인 ndarray 생성.  
zero_array = np.zeros((3, 2), dtype='int32')
print(zero_array)
print(zero_array.dtype, zero_array.shape)

#(3, 2) shape을 가지는 모든 원소가 1인 ndarray 생성. ,
one_array = np.ones((3, 2))
print(one_array)
print(one_array.dtype, one_array.shape)

[[0 0]
 [0 0]
 [0 0]]
int32 (3, 2)
[[1. 1.]
 [1. 1.]
 [1. 1.]]
float64 (3, 2)

numpy에 zeros, ones 함수를 통해 0, 1값을 가진 ndarray를 간편하게 생성할 수 있다.

reshape

array1 = np.arange(10)
print('array1:\n', array1)

# (2, 5) shape으로 변환
array2 = array1.reshape(2, 5)
print('array2:\n',array2)

#(5, 2) shape으로 변환. 
array3 = array1.reshape(5,2)
print('array3:\n',array3)

array1:
 [0 1 2 3 4 5 6 7 8 9]
array2:
 [[0 1 2 3 4]
 [5 6 7 8 9]]
array3:
 [[0 1]
 [2 3]
 [4 5]
 [6 7]
 [8 9]]

numpy에 reshape 함수를 통해 ndarray의 차원과 크기를 변경할 수 있다.

ndarray의 데이터 세트 선택하기 - indexing

단일 인덱싱

# 1에서 부터 9 까지의 1차원 ndarray 생성 
array1 = np.arange(start=1, stop=10)
print('array1:',array1)
# index는 0 부터 시작하므로 array1[2]는 3번째 index 위치의 데이터 값을 의미
value = array1[2]
print('value:',value)
print(type(value))

array1: [1 2 3 4 5 6 7 8 9]
value: 3
<class 'numpy.int32'>

슬라이싱 인덱싱

array1 = np.arange(start=1, stop=10)
print('array1:', array1)
array3 = array1[0:3]
print('array3:', array3)
print(type(array3))

array1: [1 2 3 4 5 6 7 8 9]
array3: [1 2 3]
<class 'numpy.ndarray'>`

불린 인덱싱

array1d = np.arange(start=1, stop=10)
print(array1d)
# [ ] 안에 array1d > 5 Boolean indexing을 적용 
array3 = array1d[array1d > 5]
print('array1d > 5 불린 인덱싱 결과 값 :', array3)

[1 2 3 4 5 6 7 8 9]
array1d > 5 불린 인덱싱 결과 값 : [6 7 8 9]

행렬 정렬 - sort()와 argsort()

sort 정렬

org_array = np.array([ 3, 1, 9, 5]) 
print('원본 배열:', org_array)
# np.sort( )로 정렬 
sort_array1 = np.sort(org_array)         
print ('np.sort( ) 호출 후 반환된 정렬 배열:', sort_array1) 
print('np.sort( ) 호출 후 원본 배열:', org_array)
# ndarray.sort( )로 정렬
sort_array2 = org_array.sort()
print('org_array.sort( ) 호출 후 반환된 배열:', sort_array2)
print('org_array.sort( ) 호출 후 원본 배열:', org_array)

원본 배열: [3 1 9 5]
np.sort( ) 호출 후 반환된 정렬 배열: [1 3 5 9]
np.sort( ) 호출 후 원본 배열: [3 1 9 5]
org_array.sort( ) 호출 후 반환된 배열: None
org_array.sort( ) 호출 후 원본 배열: [1 3 5 9]

np.sort(array)와 array.sort()의 차이점은 전자는 배열을 반환해주지만 후자는 반환값이 None이다 즉 원본 배열을 변화시킨다.

sort_array1_desc = np.sort(org_array)[::-1]
print ('내림차순으로 정렬:', sort_array1_desc) 

내림차순으로 정렬: [9 5 3 1]

np.sort(array)[::-1]를 통해 내림차순으로 정렬할 수 있다.

argsort() 정렬

org_array = np.array([ 3, 1, 9, 5]) 
sort_indices = np.argsort(org_array)
print(type(sort_indices))
print('행렬 정렬 시 원본 배열의 인덱스:', sort_indices)

<class 'numpy.ndarray'>
행렬 정렬 시 원본 배열의 인덱스: [1 0 3 2]

argsort정렬은 sort정렬과는 달리 정렬된 위치 인덱스를 반환해준다.

선형대수 연산 - 행렬 내적과 전치 행렬 구하기

행렬 내적

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([[7, 8],
              [9, 10],
              [11, 12]])

dot_product = np.dot(A, B)
print('행렬 내적 결과:\n', dot_product)

행렬 내적 결과:
 [[ 58  64]
 [139 154]]

numpy에 dot함수를 통해 행렬 간의 내적을 구할 수 있다.

전치 행렬

A = np.array([[1, 2],
              [3, 4]])
transpose_mat = np.transpose(A)
print('A의 전치 행렬:\n', transpose_mat)

A의 전치 행렬:
 [[1 3]
 [2 4]]

numpy의 transpose함수를 통해 행렬의 전치행렬을 구할 수 있다.

느낀점

Numpy는 데이터를 처리할때 유용하게 쓰이고 Pandas의 기본 틀이 Numpy로 구성이 되어있기 때문에 매우 중요하다고 생각한다. 앞으로 자주 사용해보면서 numpy에 대해 익숙해져야겠다.