파이썬 머신러닝 완벽가이드 - 1.3 - numpy

넘파이(Numerical Python)

• 파이썬에서 선형대수 기반의 프로그램을 쉽게 만들 수 있도록 지원하는 대표적인 패키지
• 루프를 사용하지 않고 대량 데이터의 배열 연산을 가능하게 하므로 빠른 배열 연산 속도를 보장한다.
• C/C++ 같은 저수준 언어 기반의 호환 API를 제공한다.
• 배열 기반의 연산은 물론 다양한 핸들링 기능을 제공한다.

 

numpy import

import numpy as np

• as np를 추가해 약어로 모듈을 표현해주는 것이 관례다.
• 넘파이 기반 데이터 타입은 ndarray다.
• ndarray를 이용해 넘파이에서 다차원(Multi-dimension)배열을 쉽게 생성하고 다양한 연산을 수행할 수 있다.

 

넘파이 1,2,3차원 axis

[그림1] 넘파이 1,2,3차원 Axis 출처 : http://taewan.kim/post/numpy_cheat_sheet/

 

 

arrary()함수

• 파이썬의 리스트와 같은 다양한 인자를 입력 받아 ndarray로 변환하는 기능을 수행한다.

# array 함수
# ndarray로 변환하는 기능 수행

array1 = np.array([1,2,3])
print('array1 type : ', type(array1))
print('array1 array 형태 : ', array1.shape)

array2 = np.array([[1,2,3],
                  [4,5,6]])
print('array2 type : ', type(array2))
print('array2 array 형태 : ',array2.shape)

array3 = np.array([[1,2,3]])
print('array3 type : ', type(array3))
print('array3 arrary 형태 : ', array3.shape)

[그림2] array함수 이용한 type 형태 보기

• np.array()사용시 class type이 numpy.ndarray로 나오는 것을 확인
• shape의 경우 차원과 크기를 튜플 () 형식으로 나타내 준다.

 

 

차원 ndarray.ndim을 이용해 확인

# ndim 함수 사용해 arrary 차원 확인

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

[그림3] ndarray.ndim을 이용해 차원 확인

• array()함수의 인자로는 파이썬 리스트 객체가 주로 사용된다.
• ndarray내의 데이터값은 숫자 값, 문자열 값, 불 값 등이 모두 가능하다.
  • int(8,16,32bit)
  • unsigned int(8,16,32bit)
  • float(16,32,64,128bit)
  • 이보다 큰 숫자 값이나 정밀도를 위해 complex 타입도 제공
• ndarray내의 데이터 타입은 그 연산의 특성상 같은 데이터 타입만 가능하다.
  • int와 float이 같이 있을 수는 없다.

# 데이터 타입
list1 = [1,2,3]
print(type(list1))
array1 = np.array(list1)
print(type(array1)) # 리스트 형을 넣어도 numpy.ndarray로 변경
print(array1, array1.dtype)

 

[그림3] 데이터 타입 확인

 

 

# 리스트 안에 문자열이 있을 경우
list2 = [1,2,'test']
array2 = np.array(list2)
print(array2, array2.dtype)

[그림4] 유니코드 문자로 변경

 

astype메서드

# astype 메서드로 데이터값 타입 변경
array_int = np.array([1,2,3])
array_float = array_int.astype('float64') # float64형으로 변경
print(array_float, array_float.dtype)

[그림5] astype메서드로 데이터형 변환

 

arange()함수

• 파이썬 표준 함수인 range()와 유사한 기능을 한다.
• array를 range()로 표현하는 것
• 0부터 함수 인자 값 -1까지의 값을 순차적으로 ndarray의 데이터값으로 변환해준다.

# arange() 함수

sequence_array = np.arange(10)
print(sequence_array)
print(sequence_array.dtype, sequence_array.shape) # 데이터 타입, 형태

[그림6] arange함수

ones, zeros

# zeros, ones

# 3행 2열
zero_array = np.zeros((3,2), dtype='int32')
print(zero_array)
print(zero_array.dtype, zero_array.shape)

# ones
one_array = np.ones((3,2))
print(one_array)
print(one_array.dtype, one_array.shape)

[그림7]  ones, zeros

• dtype을 지정하지 않으면 자동으로 float64로 설정

 

reshape()

• ndarray를 특정 차원 및 크기로 변환

# reshape()

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

array2 = array1.reshape(2,5)
print('arr2 : \n', array2)

array3 = array1.reshape(5,2)
print('arr3 : \n', array3)

[그림8] reshape()

# reshape -1 활용

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

array2 = array1.reshape(2, -1)
print('arr2 : \n', array2.shape)

array3 = array1.reshape(5, -1)
print('arr3 : \n', array3.shape)

[그림9] -1활용

 

 

tolist() 메서드 

• ndarray -> tolist() -> 리스트 자료형

# reshape 차원 변경

array1 = np.arange(8)
array3d =array1.reshape((2,2,2)) # 2*2*2 = 8
print('array3d : \n', array3d.tolist())

array5 = array3d.reshape(-1,1)
print('array5 : \n', array5.tolist())
print('array5.shape : \n',array5.dtype)

array6 = array1.reshape(-1,1)
print('array6 : \n',array6.tolist())
print('array6 shape : \n',array6.shape)

 

[그림10] tolist() 메서드

 

인덱싱(indexing)

1. 특정한 데이터만 추출 : 원하는 위치의 인덱스 값을 지정하면 해당 위치의 데이터가 반환
2. 슬라이싱(slicing) : 슬라이싱은 연속된 인덱스상의 ndarray를 추출하는 방식.
   • ':' 기호 사이에 시작 인덱스와 종료 인덱스를 표시하면 시작 인덱스에서 종료 인덱스-1 위치에 있는 데이터의 ndarray를 반환한다.
3. 팬시 인덱싱(Fancy Indexing) : 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 데이터의 ndarray를 반환한다.
4. 불린 인덱싱(Boolean Indexing) : 특정 조건에 해당하는지 여부인 True/False 값 인덱싱 집합을 기반으로 True에 해당하는 인덱스 위치에 있는 데이터의 ndarray를 반환한다.

 

# 인덱싱(indexing)


# 2차원의 3x3 narray로 변환

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3) # 3행 3열
print(array2d)

print('(row=0, col=0) index 값 : ',array2d[0,0])
print('(row=0, col=1) index 값 : ',array2d[0,1])
print('(row=1, col=0) index 값 : ',array2d[1,0])
print('(row=1, col=1) index 값 : ',array2d[1,1])

[그림11] 인덱싱 

 

슬라이싱

1. ':'기호 앞에 시작 인덱스를 생략하면 자동으로 맨 처음 인덱스인 0으로 간주
2. ':'기호 뒤에 종료 인덱스를 생략하면 자동으로 맨 마지막 인덱스로 간주
3. ':'기호 앞/뒤에 시작/종료 인덱스를 생략하면 자동으로 맨 처음/맨 마지막 인덱스로 간주

 

 

1차원 데이터 슬라이싱

array1 = np.arange(start=1, stop=10)# 1~9
array4 = array1[:3]
print(array4)

array5 = array1[3:]
print(array5)

array6 = array1[:]
print(array1)

[그림12] 1차원 데이터 슬라이싱

 

 

2차원 데이터 슬라이싱

# 2차원 데이터 슬라이싱

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)
print('array2d : \n',array2d)

print('array2d[0:2, 0:2]\n', array2d[0:2, 0:2])
print('array2d[1:3, 0:3]\n', array2d[1:3, 0:3])
print('array2d[1:3, :]\n', array2d[1:3, :])
print('array2d[:, :]\n', array2d[:, :])
print('array2d[:2, 1:]\n', array2d[:2, 1:])
print('array2d[:2, 0]\n', array2d[:2, 0])

[그림13] 2차원 데이터 슬라이싱

 

팬시 인덱싱(Fancy Indexing)

• 리스트나 ndarray로 인덱스 집합을 지정하면 해당 위치의 인덱스에 해당하는 ndarray를 반환하는 인덱싱 방식

# 팬시 인덱싱

array1d = np.arange(start=1, stop=10)
array2d = array1d.reshape(3,3)

print('array2d : \n',array2d.tolist())
array3 = array2d[[0,1], 2]
print('array2d[[0,1], 2] => ', array3.tolist())

array4 = array2d[[0,1], 0:2]
print('array2d[[0,1], 0:2] => ', array4.tolist())

array5 = array2d[[0,1]]
print('array2d[[0,1]] => ', array5.tolist())

[그림14] 팬시 인덱싱

 

 

불린 인덱싱(Boolean Indexing)

• 조건 필터링과 검색을 동시에 할 수 있기 때문에 매우 자주 사용되는 인덱싱 방식

 

 

# 불린 인덱싱

array1d = np.arange(start=1, stop=10)

array2 = array1d[array1d > 6]

print('array1d > 5 불린 인덱싱 값 : ', array2)

[그림15] 불린 인덱싱

 

행렬의 정렬

• np.sort()
• ndarray.sort()
• argsort() - 정렬된 행렬의 인덱스 반환

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

# np.sort(), ndarray.sort()
# argsort()

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

sort_array2 = org_array.sort()
print('org_array.sort() 호출 후 반환된 행렬 : ',sort_array2)
print('org_array.sort() 호출 후 원본 행렬 : ',org_array)

[그림16] 행렬의 정렬

 

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

# 로우,칼럼 방향으로 정렬
array2d = np.array([[8, 12],
                   [7, 1]])

sort_array2d_axis0 = np.sort(array2d, axis = 0)
print('로우 방향으로 정렬 : \n', sort_array2d_axis0)

sort_array2d_axis1 = np.sort(array2d, axis = 1)
print('칼럼 방향으로 정렬 : \n', sort_array2d_axis1)

[그림17] 내림차순, 로우, 칼럼 방향 정렬 

 

인덱스 값 반환

# 정렬된 행렬의 인덱스를 반환

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


# 내림차순
sort_indices_desc = np.argsort(org_array)[::-1]
print('행렬 내림차순 정렬 시 원본 행렬의 인덱스 : ',sort_indices_desc)

[그림18] 인덱스 값 반환, 내림차순 반환

 

 

행렬 내적(행렬 곱)

• 행렬 내적은 행열 곱이며, 두 행렬 A와 B의 내적은 np.dot()을 이용해 계산이 가능하다.
• np.dot()

# 행렬 내적 행렬 곱 np.dot()

A = np.array([[1,2,3],
              [4,5,6]])

B = np.array([[7,8],
             [9,10],
             [11,12]])

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

[그림19] 행렬 내적

 

 

전치 행렬

• 원 행렬에서 행과 열 위치를 교환한 원소로 구성한 행렬을 그 행렬의 전치 행렬이라고 한다.
• np.transpose(A)

# 전치 행렬

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

[그림20] 전치 행렬

 

 

complex타입

• complex(real, imag) 값을 가진 복소수를 만들거나 문자열에서 복소수를 만들 수 있다.

 

 

 

출처 : http://www.yes24.com/Product/Goods/87044746

파이썬 머신러닝 완벽 가이드