티스토리 뷰

카테고리 없음

데이터 엔지어링 001

LHOIKTN 2023. 6. 25. 17:39

numpy

  • numpy는 기본적으로 C언어로 구현되어 있다. → 속도가 빠르다.
  • 수치 연산에 관련된 아주 방대한 라이브러리 존재. (scipy라는 라이브러리도 있다)
  • 일반적인 파이썬 리스트를 이용한 데이터 핸들링보다 훨씬 빠르다.
  • 배열 병렬 연산에 특화되어 있다.

numpy 모듈 불러오기

import numpy as np

numpy로 배열 만들기

numpy로 만들어진 배열을 ndarray 라고 한다.

py_list = [1,2,3]
arr = np,array(py_list)

arr
// array([1, 2, 3])

type(arr)
// numpy.ndarray

배열의 종류

1. 스칼라(scalar)

  • 0차원 데이터
  • 측정한 하나의 값
height = 186.7
age = 30
weight = 88

2. 벡터(vector)

  • 1차원 배열
  • 스칼라가 모여있는 것
  • 벡터 내에 N개의 데이터가 있으면 N차원 벡터 라고 한다.

열벡터

column_arr = np.array([1,2,3])
// array([1, 2, 3])

행벡터

row_arr = np.array([[1],
                [2],
                [3]])

# array([[1],
#        [2],
#        [3]])

3. 행렬(matrix)

  • 2차원 배열
  • 1차원 배열인 벡터가 여러 개 모여있는 것
  • 데이터 분석 및 처리에서는 항상 2차원 배열(행렬)을 기준으로 한다.
person_info = [[180.1, 33, 80.5],
               [175.1, 32, 77.3]]

4. 텐서

  • 3차원 이상의 배열을 의미
  • 3차원 배열은 2차원 배열이 모여있는 것
  • 4차원 배열은 3차원 배열이 모여있는 것
  • N차원 배열을 텐서라고 한다.
  • 텐서의 개념을 활용하면 모든 배열의 모양을 말할 수 있다.
  • 0 Rank Tensor : 스칼라
  • 1 Rank Tensor : 벡터
  • 2 Rank Tensor : 행렬
  • 3 Rank Tensor : 3 Rank Tensor

numpy 함수 알아보기

 

np.arange

  • 기본적인 파이썬의 range 함수와 매우 흡사
arr = np.arange(10) # 0 ~ 9 까지 들어 있는 정수의 배열을 생성
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

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

np.arange(1, 10, 2) # 1 부터 9까지 2씩 띄워가면서 원소를 채워줍니다.
# array([1, 3, 5, 7, 9])

np.zeros(shape)

# 5개의 0이 들어있는 배열
np.zeros(5)

##############################
array([0., 0., 0., 0., 0.]) 

# 원하는 형식으로 배열을 생성
np.zeros((2, 3))
#######################################
array([[0., 0., 0.],
       [0., 0., 0.]])
np.zeros((3, 4, 5))

##################################
 array([[[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.],
         [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.]]])

 

np.ones(shape)

np.ones(5)
# array([1., 1., 1., 1., 1.]) 

np.ones((2, 3))
# array([[1., 1., 1.],
#        [1., 1., 1.]])

# 만약에 5로 채워진 배열을 만들고 싶다면...?
np.ones((2, 3)) * 5
#array([[5., 5., 5.],
#       [5., 5., 5.]])

 

np.full(shape, num)

# 특정 숫자로 채워진 배열을 만들 때 full
np.full((2, 3), 5)

############################
array([[5, 5, 5],
       [5, 5, 5]])

np.full((2, 3), 3.14)

##############################
array([[3.14, 3.14, 3.14],
       [3.14, 3.14, 3.14]])

np.random.randn(N)

  • N개의 정규분포 랜덤값 생성
np.random.randn(16)

###########################################################################
array([-0.99471617, -2.5460969 , -0.93841335, -0.97775006, -0.83618148,
       -0.3366164 ,  1.47386321, -0.18287223,  0.49704633, -0.59333779,
       -1.30948533,  0.12778982,  0.23872239, -2.86885498, -1.39139527,
       -1.46216902])

그리기

x = np.random.randn(100000)

import matplotlib.pyplot as plt

plt.hist(x, bins=100)
plt.show()

np.random.uniform

  • 균등분포 랜덤 값을 생성
  • 최소 한계정, 최대 한계점을 함께 입력
np.random.uniform(1.0, 3.0, size=(4, 5))

########################################################################
array([[2.36256643, 1.29496106, 2.6964742 , 2.44625807, 1.61071047],
       [2.45418872, 2.66573745, 2.59598674, 1.07183629, 2.64780542],
       [2.59824284, 1.81175439, 1.14180827, 1.61811422, 2.89209302],
       [1.03707339, 2.34775546, 2.07488437, 2.30207742, 2.39603982]])
x = np.random.uniform(1.0, 3.0, size=100000)

plt.hist(x)
plt.show()

 

 

 

 

axios 이해하기

axis: 차원 축의 인덱스

arr = np.arange(5)

##################### 
array([0, 1, 2, 3, 4])
# 1차원 배열의 axis는 1개.
np.max(arr, axis=0)

########################
4
# 랜덤을 고정. 언제나 같은 랜덤 값이 나올 수 있게
np.random.seed(42)

arr = np.random.randint(1, 6, size=(2, 3))

#############################################
array([[4, 5, 3],
       [5, 5, 2]])
np.max(arr, axis=0)

############################################
array([5, 5, 3]) 

np.max(arr, axis=1)

###############################################
 array([5, 5])
np.random.seed(42)

arr = np.random.randint(1, 100, size=(3, 4))

###################################################
array([[52, 93, 15, 72],
       [61, 21, 83, 87],
       [75, 75, 88, 24]])

axis 1번 방향의 최솟값???

np.min(arr, axis=1)

######################
array([15, 21, 24])
np.random.seed(42)

arr = np.random.randint(1, 100, size=(3, 4, 3))

####################################################
array([[[52, 93, 15],
        [72, 61, 21],
        [83, 87, 75],
        [75, 88, 24]],

       [[ 3, 22, 53],
        [ 2, 88, 30],
        [38,  2, 64],
        [60, 21, 33]],

       [[76, 58, 22],
        [89, 49, 91],
        [59, 42, 92],
        [60, 80, 15]]])

axis 2번 방향에서 최솟값??

np.min(arr, axis=2)

##################################
array([[15, 21, 75, 24],
       [ 3,  2,  2, 21],
       [22, 49, 42, 15]])

배열의 인덱싱과 슬라이싱

Fancy indexing

  • 접근하고 싶은 데이터의 인덱스를 리스트에 넣어서 접근하는 방법
arr = np.arange(10, 70, 10)

################################
array([10, 20, 30, 40, 50, 60])

arr[[1, 4]]

################################
array([20, 50])

 

Slicing

arr = np.arange(1, 10)

###################################
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[3 : 7]

##########################
array([4, 5, 6, 7])
arr = np.arange(1, 37).reshape(3, 4, 3)

##############################################

array([[[ 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, 30],
        [31, 32, 33],
        [34, 35, 36]]])
arr[::2, 2:, 1:]

########################
array([[[ 8,  9],
        [11, 12]],

       [[32, 33],
        [35, 36]]])

 

위 과정을 하나씩 살펴보면

::2 axios 2 arr[0] 이랑 arr[2] 만 X:Y:Z → X부터 Y까지 Z씩 더하면서..

array([[[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9],
        [10, 11, 12]],

       [[25, 26, 27],
        [28, 29, 30],
        [31, 32, 33],
        [34, 35, 36]]])

2: axios 1 에서 2번쨰 인덱스부터 끝까지.

array([[[ 7,  8,  9],
        [10, 11, 12]],

       [[31, 32, 33],
        [34, 35, 36]]])

1: axios 0 에서 1번 인덱스부터 끝까지

array([[[8,  9],
        [11, 12]],

       [[32, 33],
        [35, 36]]])

 

배열의 차원과 형상

형상

arr = np.arange(12).reshape(3, 4)
arr.shape # 배열의 형상을 확인

#############
(3, 4)

차원

arr.ndim

############
2

reshape

  • 배열의 형상을 재구성
x = np.arange(20)

#############################
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19])
  • 안쪽에 있는 숫자를 전부 곱했을 때 원소의 개수(size)와 같아야 한다.
x.reshape(2, 5, 2)

##################################################################################
array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5],
        [ 6,  7],
        [ 8,  9]],

       [[10, 11],
        [12, 13],
        [14, 15],
        [16, 17],
        [18, 19]]])
  • -1을 사용하면 남은 숫자를 자동으로 계산

x.reshape(2, -1, 2)

#####################################
array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5],
        [ 6,  7],
        [ 8,  9]],

       [[10, 11],
        [12, 13],
        [14, 15],
        [16, 17],
        [18, 19]]])
728x90
저작자표시
공지사항
최근에 올라온 글
최근에 달린 댓글
Total
Today
Yesterday
링크
TAG more
«   2025/02   »
일 월 화 수 목 금 토
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
글 보관함