(Machine) 10. Numpy

8 분 소요 

들어가면서....
python 언어는 다이나믹 타이핑이라는 특징이 있다
* 다이나믹 타이핑 
  - 실행 시점에 데이터 타입을 결정하기 떄문에 
    다양한 데이터 타입이 들어갈 수 있음

1. 학습목표

  • numpy 의 여러 특징과 기능, 코드를 작성하는 방법 등을 배워보자!

2. NumPy

  • Numerical Python
  • 파이썬의 고성능 과학 계산용 패키지
  • materix와 vector와 같은 Array 연산의 사실상의 표준
  • 한글로 넘파이로 주로 통칭, 넘피/늄파 라고 부르기도 함

1) Numpy 특징

  • 일반 List에 비해 빠르고, 메모리 효율적
  • 반복문 없이 데이터 배열에 대한 처리를 지원함
  • 선형대수와 관련된 다양한 기능을 제공함
  • C, C++, 포트란 등의 언어와 통합가능

3. Numpy Array 기능들

import numpy as np

test_array = np.array(["1", "4", 5, 8], float)
print(test_array)
print(type(test_array[3])) # [64] 하나의 element가 차지하는 메모리 공간을 의미
  • numpy는 np.array 함수를 활용하여 배열을 생성함
  • numpy는 하나의 데이터 type만 배열에 넣을 수 있음
  • List와 가장 큰 차이점, Dynamic typing not supported
  • C의 Array를 사용하여 배열을 생성한다.

1) shape(행렬의 크기)

print(test_array = np.array([["1", "4", 5, 8]], int).shape)
### 출력값은 행렬의 크기를 나타내기 때문에 : 1x4가 된다

2) ndim(차원의 크기)

  • 1차원인지… 2차원인지.. 3차원인지…. 값을 리턴해줌
print(np.array([[["1", "4", 5, 8],["1", "4", 5, 8]]], int).ndim)
### 3차원 값이므로 3을 리턴해줌

3) size(데이터 총 갯수)

print(np.array([[["1", "4", 5, 8],["1", "4", 5, 8]]], int).size)
### 총 갯수 8을 리턴해줌

4) reshape

  • vector를 matrix으로 만들어 주기위해 사용한다..
  • 1차원 array를 다차원 array로 변환 
    test_array = np.array(["1", "4", 5, 8], np.float32)
print(np.array(test_array).reshape(-1,2).shape )
# -1을 행이 몇개인지 모를때 column을 2로 된 matrix으로 변환함
# 그래서 shape를 써서 출력하면 (2, 2) matrix을 얻을 수 있음

5) flatten

  • 다차원 array를 1차원 array로 변환 
    flatten_test = np.array([[["1", "4", 5, 8],["1", "4", 5, 8]],[["1", "4", 5, 8],["1", "4", 5, 8]]], int)
print(flatten_test.flatten())
### 출력결과
# [1 4 5 8 1 4 5 8 1 4 5 8 1 4 5 8]

6) indexing

  • List와 달리 이차원 배열에서 [0,0]과 같은 표기법을 제공함
  • Matrix일 경우 앞은 row 뒤는 column을 의미함
test_array = np.array([["1", "4", 5, 8],["1", "4", 5, 8]], int)
print(test_array[0][0]) # 결과는 1로 동일하다
print(test_array[0,0]) # 결과는 1로 동일하다

7) slicing

  • List와 달리 행과 열 부분을 나눠서 slicing이 가능함
  • Matrix의 부분 집합을 추출할 때 유용함
test_array = np.array([["1", "2", 3, 4, 5],["6", "7", 8, 9, 10]], int)
print(test_array[:, 2:])  # 전체 Row의 2열 이상
# ======== 출력값 =====
# [[ 3  4  5]
#  [ 8  9 10]]
print(test_array[1, 1:3]) # 1 Row의 1열 ~ 2열
# ======== 출력값 =====
# [7 8]
print(test_array[0, 0])   # 1 Row ~ 2 Row의 전체
# ======== 출력값 =====
# [7 8]
print(test_array[1:3])   # 1 Row ~ 2 Row의 전체
# ======== 출력값 =====
# [[ 6  7  8  9 10]]

8) arange

  • array의 범위를 지정하여, 값의 list를 생성하는 명령어
test_arr = np.arange(30).reshape(-1,5)
print(test_arr)
# ======== 출력값 =====
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]
#  [20 21 22 23 24]
#  [25 26 27 28 29]]

9) ones, zeros, empty

  • zeros = 0으로 가득찬 ndarray 생성
  • ones = 1로 가득찬 ndarray 생성
  • empty = shape만 주어지고 비어있는 ndarray 생성 (사용할일 없을꺼임..) 
    test_arr =np.zeros(shape=(10,), dtype=np.int8)
print(test_arr)
# ======== 출력값 =====
# [0 0 0 0 0 0 0 0 0 0]
test_arr = np.ones(shape=(10,), dtype=np.int8)
print(test_arr)
# ======== 출력값 =====
# [1 1 1 1 1 1 1 1 1 1]

10) something_like

  • 기존 ndarray의 shape 크기 만큼 1,0 또는 empty array를 반환
test_matrix = np.arange(30).reshape(5,6)
test_matrix = np.ones_like(test_matrix)
print(test_matrix)
# ======== 출력값 =====
# [[1 1 1 1 1 1]
#  [1 1 1 1 1 1]
#  [1 1 1 1 1 1]
#  [1 1 1 1 1 1]
#  [1 1 1 1 1 1]]
test_matrix = np.arange(30).reshape(5,6)
test_matrix = np.zeros_like(test_matrix)
print(test_matrix)
# ======== 출력값 =====
# [[0 0 0 0 0 0]
#  [0 0 0 0 0 0]
#  [0 0 0 0 0 0]
#  [0 0 0 0 0 0]
#  [0 0 0 0 0 0]]

11) identity

  • 단위 행렬(i 행렬)을 생성함
test_matrix = np.identity(n=3, dtype=np.int8)
print(test_matrix)
# ======== 출력값 =====
# [[1 0 0]
#  [0 1 0]
#  [0 0 1]]
test_matrix = np.identity(6)
print(test_matrix)
# ======== 출력값 =====
# [[1. 0. 0. 0. 0. 0.]
#  [0. 1. 0. 0. 0. 0.]
#  [0. 0. 1. 0. 0. 0.]
#  [0. 0. 0. 1. 0. 0.]
#  [0. 0. 0. 0. 1. 0.]
#  [0. 0. 0. 0. 0. 1.]]

12) eye

  • 대각선이 1인 행렬, k값의 시작 index의 변경이 가능
  • 밑바닥 부터 구현하지 않는 이상 거의 쓸일이 없음.
test_matrix = np.eye(N=3, M=5, dtype=np.int8)
print(test_matrix)
# ======== 출력값 =====
# [[1 0 0 0 0]
#  [0 1 0 0 0]
#  [0 0 1 0 0]]
test_matrix = np.eye(3, 5, k=2)
print(test_matrix)
# ======== 출력값 =====
# [[0. 0. 1. 0. 0.]
#  [0. 0. 0. 1. 0.]
#  [0. 0. 0. 0. 1.]]

12) diag

  • 대각 행렬의 값을 추출할 때 사용
test_matrix = np.arange(9).reshape(3,3)
print(test_matrix)
print(np.diag(test_matrix))
# ======== 출력값 =====
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
##############
# [0 4 8]

13) random sampling

  • 데이터 분포에 따른 sampling으로 array를 생성
test_matrix = np.random.uniform(0, 10, 10).reshape(2, 5)
print(test_matrix)
# ======== 출력값 =====
# [[8.2468894  4.02519395 3.1556772  9.47197602 8.61174728]
#  [4.58297772 7.2660887  4.80443172 4.80697138 5.73681331]]

14) sum

  • ndarray의 element들 간의 합을 구함, list의 sum 기능과 동일
test_matrix = np.arange(1,11)
print(test_matrix.sum(dtype=np.float))
# ======== 출력값 =====
# 55.0

15) axis (*)

  • 모든 operation function을 실행할 때, 기준이 되는 dimension 축
  • axis 새로 추가될 sape가 0
test_matrix = np.arange(1,13).reshape(3,4)
print(test_matrix) # 기준값
print(test_matrix.sum(axis=1)) # Column을 기준으로 더해라
print(test_matrix.sum(axis=0)) # Row를 기준으로 더해라
# ======== 출력값 =====
# 기준값
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# axis=1 # (Column)을 기준으로 더한 결과값
# [10 26 42]
# axis=0 # Row를 기준으로 더해라
# [15 18 21 24]

16) mean & std

  • ndarray의 element들 간의 평균 또는 표준 편차를 반환
test_matrix = np.arange(1,13).reshape(3,4)
print(test_matrix.mean()) # mean = 평균
print(test_matrix.std()) # std = 표준 편차
# ======== 출력값 =====
# mean = 평균
# 6.5 

# std = 표준 편차
# 3.452052529534663

17) mean & std

  • ndarray의 element들 간의 평균 또는 표준 편차를 반환
test_matrix = np.arange(1,13).reshape(3,4)
print(test_matrix.mean()) # mean = 평균
print(test_matrix.std()) # std = 표준 편차
# ======== 출력값 =====
# mean = 평균
# 6.5 

# std = 표준 편차
# 3.452052529534663

18) concatenate

  • Numpy array를 합치는 함수
# vstack
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack((a,b)))
print('##############')
# hstack
a = np.array( [[1], [2], [3]] )
b = np.array( [[4], [5], [6]] )
print(np.hstack((a,b)))
print('##############')
a = np.array([[1, 2, 3]])
b = np.array([[4, 5, 6]])
print(np.concatenate((a,b), axis=0))
print('##############')
a = np.array([[1,2],[3,4]])
b = np.array([[5,6]])
print(np.concatenate((a,b.T), axis=1))

# ======== 출력값 =====
# [[1 2 3]
#  [4 5 6]]
# ##############
# [[1 4]
#  [2 5]
#  [3 6]]
# ##############
# [[1 2 3]
#  [4 5 6]]
# ##############
# [[1 2 5]
#  [3 4 6]]

4. Operations arrays

  • Numpy는 array간의 기본적인 사칙 연산을 지원한다.
  • 단, 두 shape은 동일해야한다.
  • 같은 자리에 있는 것 끼리 연산을 한다.
  • shape가 다른 경우에는 .dot을 사용하여 matrix의 기본연산을 사용한다.
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(3, 2)
print(a.dot(b))
# ======== 출력값 =====
# [[ 58  64]
#  [139 154]]

5. Transpose

  • transpose 또는 T attribute 사용
  • 전치행렬을 구할 수 있음..
a = np.arange(1, 7).reshape(2, 3)
print(a.transpose())
# ======== 출력값 =====
# [[1 4]
#  [2 5]
#  [3 6]]

6. broadcasting (*)

  • Shape가 다른 배열 간 연산을 지원하는 기능
  • scala의 계산을 생각하면 된다.
a = np.array([[1,2,3],[4,5,6]], float)
scalar = 10
print(a * scalar)
# ======== 출력값 =====
# [[10. 20. 30.]
#  [40. 50. 60.]]

7. any & all

a = np.arange(10)
print(a)
print(a>5)
print(np.any(a>5))
print(np.all(a>5))
# ======== 출력값 =====
# [0 1 2 3 4 5 6 7 8 9]
#### a > 5 경과값 broadcasting 과 같음
# [False False False False False False  True  True  True  True]
#### any결과
# True
#### all결과
# False

8. np.Where (*)

  • 조건에 만족하는 인덱스 값을 리턴해준다
  • 3항식으로 사용 할 수도 있다.
a = np.array([1,3,0], float)
print(a)
print(np.where(a > 0, 3, 2)) # 0보다 크면 면 3을 반환 아니면 2를 반환 
# ======== 출력값 =====
# [1. 3. 0.]
# [3 3 2]

print(np.where(a>0))  # 0보다큰 값을 가진 인덱스를 반환
# ======== 출력값 =====
# (array([0, 1], dtype=int64),)

9. argmax & argmin (*)

  • array내 최대값 또는 최소값의 index를 반환함
  • axis 기반의 반환도 사용할 수 있음
a = np.arange(10)
print(np.argmax(a)) # 최대값 인덱스를 리턴함
# ======== 출력값 =====
# 9
print(np.argmin(a)) # 최소값 인덱스를 리턴함
# ======== 출력값 =====
# 0

10. boolean index

  • numpy 배열은 특정 조건에 따른 값을 배열 형태로 추출 할 수 있음
  • Comparison operation 함수들도 모두 사용가능
test_array = np.array([1, 4, 0, 2, 3, 8, 9, 7], float)

condition = test_array > 3
print(condition) # 조건에 따른 true false 리턴함

result = test_array[condition]
print(result) # true 값인 인덱스의 실제값을 뽑아낼수 있다...

# ======== 출력값 =====
#---- 조건에 맞건 true 아니면 false
# [False  True False False False  True  True  True]

#---- true 값인 인덱스의 실제값
# [4. 8. 9. 7.]


condition.astype(np.int) # true,false를 1,0으로 바꿔준다.
# ======== 출력값 =====
# [0 1 0 0 0 1 1 1]

11. fancy index

  • numpy는 array를 index value 로 사용해서 값을 추출하는 방법
  • 어떤 추천 시스템에서 많이 사용함
a = np.array([2, 4, 6, 8], float)
b = np.array([0, 0, 1, 3, 2, 1], int) # 반드시 integer로 선언해야함
print(a[b]) # bracket index, b 배열의 값을 index로 하여 a의 값들을 추출함
# ======== 출력값 =====
# [2. 2. 4. 8. 6. 4.]
print(a.take(b)) # bracket index와 같은 효과임
# ======== 출력값 =====
# [2. 2. 4. 8. 6. 4.]

12. numpy object - npy

  • Numpy object(pickle) 형태로 데이터를 저장하고 불러옴
  • Binary 파일 형태로 저장함
a_int = np.array(
        [[  1900.,  30000.,   4000.,  48300.],
       [  1901.,  47200.,   6100.,  48200.],
       [  1902.,  70200.,   9800.,  41500.],
       [  1903.,  77400.,  35200.,  38200.],
       [  1904.,  36300.,  59400.,  40600.],
       [  1905.,  20600.,  41700.,  39800.],
       [  1906.,  18100.,  19000.,  38600.],
       [  1907.,  21400.,  13000.,  42300.],
       [  1908.,  22000.,   8300.,  44500.],
       [  1909.,  25400.,   9100.,  42100.]], int)
print(a_int.astype(int))
np.savetxt('int_data.csv',a_int,fmt="%2d", delimiter=",",header="문서제목") ## csv형태 저장
## npy 형태 저장
np.save("npy_test", arr=a_int)
npy_array = np.load(file="npy_test.npy")
print(npy_array)

댓글남기기