[Python] 7.numpy

데이터 분석이나 머신 러닝에서 사용하는 패키지

• 자료구조 패키지 : numpy.pandas - 데이터를 만들고 수집하고 가공하는 패키지
• 시각화 패키지 : matplotlib, seaborn, pandas, folium(지도, 단계구분도)
• 통계 : scipy
• 머신러닝 : sklearn
• 머신러닝, 딥러닝 : tensorflow, keras, pytorch
• numpy의 ndarray 가지고 하는 일들은 대부분 list로도 대체 가능

Python의 iterator 객체

• __iter__ 구현
• iterator : 순서대로 데이터 접근이 가능한 데이터의 모임
• __str__ : 객체를 문자열로 변환

ndarray 정보 확인

• print 함수를 이용해서 변수의 이름을 출력하면 데이터 전부를 출력
• 데이터의 자료형은 dtype 속성으로 확인 가능
• ndim 속성은 배열의 차원
• shape 속성은 각 차원의 크기를 저장한 정수 튜플
• size 속성은 원소 개수
• itemsize는 하나의 항목이 차지하는 메모리 크기
• nbytes는 전체가 차지하는 메모리 크기

numpy

• 실습 link
• 고성능 과학계산이나 선형대수를 위해서 제공되는 패키지

1. ndarray

• numpy가 제공하는 데이터의 모임(자료구조)
• 벡터 연산을 수행하기 때문에 요소 각각에 연산을 수행하는 경우 기존의 list나 tuple, set에 비해서 연산속도가 빨라서 머신러닝이나 딥러닝에서 사용
• 모두 동일한 자료형으로 만들어짐

1) 기본적인 생성

• ndarray((행의 수(...))) : 데이터의 개수를 직접 지정해서 생성, 권장하지 않음 (생성자)
• array(iterator) : 기존 데이터의 모임을 가지고 생성해서 리턴 (메소드)
  • 생성할 때 dtype 매개변수를 이용해서 데이터 각각의 자료형을 지정 가능
  • dtype을 설정하지 않으면 자료형을 유추해서 생성

2) 구조 파악을 위한 속성

• dtype : 각 요소의 자료형
• ndim : 배열의 차원
• shape : 각 차원의 크기를 tuple로 리턴
• size : 데이터 개수
• itemsize : 각 요소의 메모리 크기
• nbytes : 전체 메모리 크기

import numpy as np
# 2차원 배열
ar = np.array([[100, 200, 300], [400, 500, 600]])
print(ar)

# 서로 다른 자료형의 데이터가 모여 있으면 동일한 자료형으로 변경
ar = np.array([['100', 200, 300], [400, 500, 600]])
print(ar)

# dtype을 설정해서 정수 배열로 만들기
ar = np.array([['100', 200, 300], [400, 500, 600]], dtype=int)
print(ar)

print(ar.ndim)  # 전체 차원을 리턴 
### 결과값 : 2차원이다.

print(ar.shape)  # 각 차원의 데이터 개수를 튜플로 리턴 
### 결과값 : (2, 3) # 2행3열이다

2. 일정한 숫자 패턴을 이용한 생성

• arange(start, stop, step, dtype)
  • start 부터 stop 바로 앞까지 step 간격으로 생성하고 자료형은 dtype으로 설정
  • start는 생략가능한데 생략하면 0
  • step은 생략가능한데 생략하면 1
  • dtype은 생략하면 정수
• linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
  • start 부터 stop 까지는 num의 개수를 일정한 간격의 배열을 만들어서 리턴
  • axis 는 축 : 0과 1을 변경하면 축의 방향이 변경된다.
    • 0이 행이면 1은 열, 0이 열이면 1은 행1차원은 크게 의미없음
      2차원 일때 행이나 열제거 : drop(0, axis=1) -> 1행 삭제

# 일정한 숫자 패턴의 array 생성
ar = np.arange(0, 100, 1)
print(ar)

#linspace는 기본적으로 stop이 포함됨
#마지막 숫자를 제거하고자 하면 endpoint를 False로 설정
ar = np.linspace(0, 10, num=10)
print(ar)

3. 특수 행렬을 이용한 array(배열) 생성

• zeros 나 ones라는 함수를 이용해서 0이나 1로 채워진 함수를 생성할 수 있음
• zeros_like나 ones_like 함수는 배열을 매개변수로 받아서 그 배열의 모든 요소를 0이나 1로 채워진 배열을 리턴
• empty 나 empty_like는 초기화하지 않은 값으로 배열을 새성

메모리는 0, 1 로 무조건 채워진다.
Java는 변수명을 기억하고 있다가 값을 만날때 메모리에 영역을 지정한다.
C언어는 변수명에 의미없는 값을 기억했다가 값을 만나면 지정한다

• eye함수는 단위행렬 - 대각선 방향으로 1이 채워진배열
  • 이 함수에 매개변수로 열의 개수나 k라는 매개변수를 이용해서 대각의 위치를 설정

100
010
001
k=1
010
001
000

• 행과 열 수가 같은 행렬(정방행열)을 매개변수로 받아서 대각 요소만 가지고 다시 배열을 만들어주는 diag도 있음
• 이런 함수들을 이용해서 직접 배열을 생성해야 하는 경우는 드물고 라이브러리들이 내부적으로 이러한 배열들을 생성

희소행렬 : 0이 대부분이고 1이 드문 행렬 (반대 : 밀집행렬)

1이 몇개 안되는 행렬
0 0 0 0 0 1
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
크기정보를 먼저 가지고 온다 4*6 [(0,4), (2,2), (3,3)]

• One Hot incoding

카테고리(범주형)
객실의 정보 
Class
1
2
3

1, 2, 3을 각각 하나의 컬럼으로 변경 
1 2 3 class 
1 0 0
0 1 0
0 0 1

# 단위 행렬 만들기 ( 대각선 방향의 요소만 1인 행렬) 
# 정방행렬 - 행과 열의 개수가 같은 행렬 
# 단위행렬 - 정방행렬이여야 한다. 

# 크기가 3인 단위 행렬 생성 
ar = np.eye(3)
print(ar)


# 1의 위치를 1개 증가
ar = np.eye(3, k=1)
print(ar)


# 대각 요소만 뽑아서 1차원 배열을 생성 
ar = np.diag(ar) 
print(ar)

4. 희소 행렬(Sparse Matrix)

• 0이 아주 많고 다른 데이터가 드문 행렬
• 반대되는 행렬은 밀집행렬(Dense Matrix) - 배열을 Dense List 라고 하기도 합니다.
• scipy 패키지의 sparse 모듈을 이용해서 생성
  • csr_matrix 라는 함수에 ndarray를 대입하면 됩니다.
• 밀집행렬로 변환하고자 할 때는 toarray()를 호출하면 됩니다.
• 넷플릭스 와 같은 곳에서 고객이 본 영화를 행렬로 만든다면 고객은 거의 모든 영화를 보지 않았을 가능성이 크다.
  • 밀집행렬로 만들게 되면 메모리 부담이 크다.
  • 이런 경우는 고객이 본 영화의 대한 부분만 저장하면 부담이 적습니다.
  • 이런 경우에는 희소행렬을 이용합니다.

# 희소행렬과 밀집행렬 변환 
# scipy 의 sparse 모듈 가져오기 
from scipy import sparse

# 5 * 5 단위 행렬 생성 
ar = np.eye(5) 
print(ar) 


# 희소행렬로 변환 - 0이 아닌 값의 위치와 값을 저장 
sp = sparse.csr_matrix(ar)
print(sp)


# 밀집행렬로 변환 - 원래대로 돌리기 
ar = sp.toarray()
print(ar)

5.ndarray의 자료형

• 생성할 때 dtype 매개변수로 설정 가능
• dtype 속성으로 확인 가능
• 생성한 후 astype 함수를 호출해서 자료형을 변경할 수 있음
  • 정수 자료형 : int8, 16, 32, 64, uint8, uint16, uint32, uint64 (uint 는 음수가 없는 자료형)
  • 실수 자료형 : float16, 32, 64, 128
  • 복소수 자료형: complex64, 128, 256
  • boolean : bool
  • object : 기본 자료형 이외의 클래스로부터 만들어진 인스턴스
  • string_ : 문자열
  • unicode_ :유니코드

6. 행렬 변환

1) reshape()

• 행렬의 차원이나 크기를 변경할 때 사용, 차원을 변경할 때는 튜플로 각 차원의 개수를 설정하면 된다.
• -1을 대입하면 1차원 배열로 만들어 진다.

2) flattern

• 다차원 배열을 1차원 배열로 변환해주는 함수

3) reshape 는 배열을 변경하는 것이고 flattern은 새로운 배열을 만들어서 리턴해주는 함수

# 행렬의 차원 변환
# 0 ~ 9 까지 10개의 요소로 된 1차원 배열 생성
ar = np.arange(0, 10)
print(ar)

# 행 2개 열 5개 배열로 변환 
# 행 수와 열 수를 잘맞춰서 변환 
sp = ar.reshape(2, 5)
print(sp)

7. 배열의 요소 선택

1) 1차원 배열의 경우는 list와 유사

• 배열명[인덱스]를 이용하면 인덱스 번째 데이터 리턴
• 인덱스에 음수를 대입하면 뒤에서부터
• 배열명[시작위치:종료위치] 를 이용하면 시작위치부터 종료위치 앞까지 데이터를 리턴
  • 시작위치를 생략하면 0, 종료 위치를 생략하면 -1( len(배열) 처럼 마지막 인덱스 뒤)
  • : 만 입력하면 전체

2) 다차원 배열

• [인덱스][인덱스] 형태 처럼 인덱스를 설정해도 되고 [인덱스, 인덱스]로 설정해도 된다.
• 인덱스를 생략하면 전체가 된다 . [][인덱스] 하면 행 전체 , [인덱스][] 하면 열 전체

3) 인덱싱을 이용해서 가져온 데이터들은 링크가 전달

• 복제를 하고자 하면 copy()를 호출

R : 분석의 목적, 데이터작업이 전부 copy
그 외의 언어 : 프로그램 개발 목적 , 데이터작업이 복제도 있고 원본에 작업도 함, Python의 분석 라이브러리는 전부 copy(대표적 pandas) 원본을 바꾸고 싶으면 옵션을 설정해야됨.

# 인덱싱과 copy
ar = np.array([100, 200, 300, 400])

# 0 ~ 1번까지 요소를 br에 링크를 전달 
br = ar[0:2]
print(br)

# 데이터를 복사해서 전달
cr = ar[0:2].copy()
print(cr)

#원본을 변경하면 br은 변경되지만 cr은 변경안됨. 
#원본 데이터 변경
ar[0] = 10000
print(br)
print(cr)

8. Fancy Indexing

• list를 이용해서 인덱싱
• Fancy Indexing 은 copy를 생성
  • 배열명[[인덱스 나열]]의 형태
• 2차원의 경우에는 ix_ 함수를 이용해서 Fancy Indexing 이 가능
  • 배열명.ix_(행의 list, 열의 list) 데이터 프레임에서도 사용

#쓰레기 값을 가지고 배열을 생성
ar = np.empty((10, 3))
print(ar)


print()
# 행들을 선택 - 0, 1, 3, 5를 선택 - copy
br = ar[[0, 1, 3, 5]]
print(br)


# 현재는 같은 값을 가지고 있음
print(ar[0,0])
print(br[0,0])


# copy가 되었으므로 ar의 데이터가 변경되더라도 br이 데이터는 영향을 받지 않음
ar[0,0] = 90
print(ar[0,0])
print(br[0,0])


# 3, 5 행과 0, 2 열의 데이터를 추출 
cr = ar[[3, 5], [0,2]]  # 3,0 과 5,2만 추출
print(cr)


dr = ar[np.ix_([3, 5],[0, 2])] # 3,5행 0,2열 선택 
print(dr)

9.행과 열 전치 (Transpose)

• 행과 열의 위치 변경하기
• 2차원의 경우는 T라는 속성으로 변경
• Transpose() 라는 함수를 이용할 수 있는데 이 함수는 매개변수로 축의 순서를 list로 전달받습니다.
  • 2차원의 경우는 생략하면 행과 열을 변경
  • 3차원의 경우는 행, 열, 면의 순서를 연속적으로 설정할 수 있다.

# 행과 열의 순서 변경
ar = np.arange(0, 16) 
print(ar)


# 2차원 배열로 변환
br = ar.reshape(4, 4) 
print(br)
# 행렬 변환 - 2차원은 T나 transpose 가 동일 (3차원일때 차이가 있음) 
print(br.T)
print(br.transpose())


# 3차원으로 변환
cr = ar.reshape((2, 2, 4))
print(cr) 
# 4, 2, 2 로 변경 
print(cr.transpose())
# 2, 4, 2 로 변경  
print(cr.transpose(0, 2, 1))

10. python에서 함수 생성

1) 일반적인 함수 생성

# 매개변수 없을 수 있음
def 함수이름(매개변수 이름 나열) : 
    함수 내용
    return 데이터 # 생략 가능 

2) 람다 함수

• 1줄 짜리 이름없는 함수
• lambda 매개변수 : 함수내용

11. 배열의 모든 요소에게 함수를 적용한 후 그 결과를 리턴받기

1) for를 이용해서 배열의 모든 데이터를 순회하면서 적용

• 각각의 요소를 리턴받아서 다시 array를 생성해야 함.

2) numpy의 vectorize를 이용

• numpy.vectorize(함수내용)을 호출해서 벡터화된 함수를 만들고 이 함수에 배열을 대입하면 함수를 수행한 결과를 가지고 배열을 생성해서 리턴
• 이 방법은 for를 이용해서 구현했기 때문에 속도가 빠르지는 않음

3) 함수는 매개변수가 1개이고 반드시 리턴을 해야 한다.

• 매개변수는 배열의 각 요소가 대입되고 리턴을 받을 것을 가지고 새로 배열을 만들어야 하기 때문입니다.

Static 한 영역에 저장
Java : 클래스, Literal
Python :함수, 클래스, Literal

# 배열이 모든 요소에게 함수를 적용해서 새로운 배열 만들기 
ar = np.arange(0, 5) 
print(ar)
print()

'''
#위의 배열에 전부 5를 더한 결과를 가지고 새로운 배열을 생성 
def plus5(x) :
    return x + 5 
# 벡터화된 함수를 생성
vec_func = np.vectorize(plus5)
'''

# 람다 함수 이용 
vec_func = np.vectorize(lambda x: x + 5)

#벡터화된 함수를 적용
result = vec_func(ar)
print(result)

12. 연산자 오버로딩

• 파이썬이 제공하는 연산자를 클래스 안에서 다시 정의해서 사용하는 것
• __함수이름__ 을 재정의 하면 연산자를 사용할 수 있도록 해줍니다.
  • 대표적인 예가 __add__(a,b) 메소드를 재정의하면 +연산을 사용할 수 있다.
  • __sub__ 메소드를 재정의 하면 -연산을 사용할 수 있습니다.
  • __iter__ 메소드를 재정의하면 for를 사용할 수 있습니다.
• dir로 확인한 속성이나 메소드 중에서 __ 로 시작하는 것들은 이름을 직접 호추하는 것이 아니고 다른 방식으로 호출해야 합니다.
  • python에서 __로 시작하는 것은 객체지향언어의 private에 해당합니다.

13. ndarray의 연산

1) 동일한 차원을 갖는 array의 연산

• 산술연산, 비교연산(>, >=, <, <=, ==, !=), 할당연산(+=, -=, *=, /=)을 수행할 수 있음
• 위치가 동일한 데이터끼리 연산을 해서 연산을 수행한 배열과동일한 차원의 동일한 크기의 배열을 리턴
• numpy.logical_and(a, b) : a 배열의 원소와 b 배열의 원소가 모두 True이면 True, 그렇지 않으면 False
• numpy.logical_or(a, b) : a 배열의 원소와 b 배열의 원소가 모두 False 이면 False, 그렇지 않으면 True
• numpy.logical_xor(a, b) : a 배열의 원소와 b 배열의 원소가 같으면 False 다르면 True
• 차원도 같아야 하지만 데이터의 개수도 같아야 한다.

# 동일한 자원의 동일한 크기의 배열 연산 
# 각 요소마다 연산해서 동일한 크기의 배열로 리턴 

ar = np.arange(0, 5)
br = np.linspace(100, 105, num=5, endpoint=False) # 100부터 105 까지 5개로 분할하는데 마지막 숫자는 미포함 
print(ar)
print(br) 

result = ar + br    # 덧셈 , 숫자배열
print(result) 

result = ar > br    # 크기비교 , bool 배열 
print(result)

result = np.logical_xor(ar, br) # 논리연산 - 0 이 아닌 숫자는 True
print(result)

2) 차원이 다른 크기의 연산 - broadcast 연산

• 배열과 acala data(1개)은 배열의 모든 요소와 scala data 와 연산을 해서 그 결과를 배열의 차원과 크기가 동일한 배열로 리턴
• 차원이 다른 배열의 연산은 적은 차원의 배열을 큰 차원의 배열에 전부 연산해서 큰 차원의 배열로 리턴 - 차원은 다르지만 연산을 하는 배열끼리의 크기는 같아야 한다.

[10, 20, 30] + 4 = [14, 24, 34]

# 차원이 다른 배열의 연산 - Broadcast 
ar = np.array([100, 200, 500])
# 배열의 각 요소에서 100을 뺀 후 배열로 리턴 
result = ar - 100
print(result)

br = np.arange(0, 6) 
cr = br.reshape(2, 3) 
print(cr) 

result = ar + cr
print(result)

# 배열 크기가 달라서 계산 불가
br = br.reshape(3, 2) 
result = ar + dr
print(result) 

14. boolean indexing

• 인덱스 자리에 bool의 배열을 대입하면 True에 해당하는 인덱스의 데이터만 리턴

# boolean 색인
ar = np.array([100, 200, 301, 28])
print(ar % 2 == 0)
# 배열의 인덱스 자리에 bool 배열을 대입하면 True인 데이터만 리턴 
print(ar[ar % 2 == 0])

15. 난수(random)

• seed : 난수표 번호 - 함수들에서는 random_state 라는 옵션으로 사용
• 복원추출 : 뽑아낸 데이터를 다시 집어넣고 다시 추출 (주사위)
• 비복원 추출 : 뽑아낸 데이터를 다시 집어놓지 않고 남은 데이터에서 추출 (로또)
• numpy.random 모듈이 난수를 추출하는 모듈
• seed 라는 함수를 이용해서 seed 설정

Seed(머신러닝) = random_State(통계)
머신러닝, 딥러닝, - 샘플데이터 추출 
랜덤의 원리
* 난수표 하나를 선택해서 데이터를 순서대로 가져옵니다. 
* 난수표 번호를 Seed라고 한다.  
* seed 번호가 같으면 순서대로 나온다. (같은숫자가 나올수 없다) 
    * `seed(1)` -> 7 6 4 반복

* seed를 바꿔가면서 뽑아내야 완전한 랜검이 된다. 
    * seed(1) -> 7 6 4 , seed(2) -> 3 5 7  이런식

C : seed  무조건 46
java : seed 기본적으로 난수표가 변경됨

• permutation() : 정수를 대입하면 0부터 정수 이전까지의 배열을 랜덤하게 생성해서 리턴
  • 배열을 대입하면 배열의 데이터를 랜덤하게 배치해서 리턴
  • 비슷한 용도의 함수로 shuffle() 이 있음
• rand() : 균등 본포에서 표본 추출 - seed를 정해서 순서대로 리턴

0 , 1, 2, 각 33.33% 나올 확률 - 균등 분포 , 균일분포

• randint() : 범위를 설정해서 범위 내의 정수 중에서 리턴, size를 이용해서 개수 지정 가능
• normal() : 정규 분포에서 표본 추출 - size를 이용해서 개수 지정 가능
• binomial(n, p, size) : n은 데이터의 분포(10 -> 0부터 10까지), p는 확률

ex) p 를 0.5로 주면 반반, 0.6이면 큰쪽(5

9)이 나올 확률, 0.4이면 낮은 쪽(0

4)이 낮은 확률
참 거짓, 0 1 -> 베르노이 분포, 구간의 의미 (이항분포)
각 0과 1의 값이 여러개 이다. - 0 은 0

4 ,1은 5

9

python 의 random > numpy의 random > 머신러닝, 딥러닝, pandas 
래핑을 하게 되면 편리하고 빠르게, 포기해야하는 부분 ( 변화, 속도 등) 이 있다. 
래핑을 벗기게 되면 원리를 알고 어렵지만 변화에 둔감하고 속도 빠르고
sklearn , scipy 

# 난수 생성
# 배열 생성
ar = np.arange(0, 48)
np.random.shuffle(ar)   # 배열의 데이터 순서를 랜덤하게 배치
print(ar)

print(np.random.normal(size=5))  # 5개의 랜덤한 숫자를 추출

# seed 고정한 상태로 5개의 랜덤한 숫자를 추출 - 동일한값 출력 
np.random.seed(seed=100)  # seed 고정 
print(np.random.normal(size=5))
print(np.random.normal(size=5))

16. numpy의 함수

• pandas 의 Series 나 Dataframe 에서 그대로 사용 가능

1) 기본 통계 함수

• sum(합계), mean(평균), median(중앙값), max(최대값), min(최소값), var(분산), std(표준편차), percentile(데이터와 백분율을 입력받아서 백분율에 해당하는 데이터를 리턴)
  • 잔차 : 평균과의 차이 - 잔차의 합은 +와 -가 존재하기 때문에 값이 상쇄되서 데이터의 분포를 이해하는데 어려움이 있어서 제곱한 분산을 사용
  • 분산 : 평균과의 차이를 제곱 -> 숫자가 너무커져서 편향이 너무 심함 .
  • 표준편차 : 분산의 제곱근 (루트)
  • 표준 편차를 계산할 때 데이터 개수로 나누지 않고 데이터 개수 -1로 나눕니다. ( 데이터개수가 적을때는 차이가 있을수도있다)
  • 2차원 이상의 배열일 때 axis 옵션을 이용하면 행이나 열단위로 통계 함수를 적용 가능

# 기본 통계 함수 
ar = np.arange(1, 10)
ar = ar.reshape(3, 3)
print(ar) 

print(np.sum(ar))   # 모든 데이터를 더한 결과
# axis 옵션은 차후로도 동일한 용도로 사용되므로 기억 
print(np.sum(ar, axis=0))  # 열 단위 합계 
print(np.sum(ar, axis=1))  # 행 단위 함계

2) 배열 통계

• argmin, argmax : 최소값과 최대값의 인덱스를 리턴(위치)
• prod : 곱
• nansum, nanprod : None 을 0과 1로 간주해서 합과 곱을 구해서 리턴
  • None 과의 연산은 무조건 None
• cumsum, sumprod : 누적합과 누적곱
• diff : 앞요소와의 차이를 배열로 리턴

3) None 을 numpy.nan 으로 표기

4) 논리함수

• numpy.isnan() : nan 포함 여부 리턴
• 여기까지는 단항(Unary - 데이터가 1개만 있으면 수행되는) 함수

17. numpy의 이항 함수

• 데이터가 2개 있어야 수행되는 함수
  • add, subtract, multiply, divide, floor_divide(몫만 가져오기)
  • power(첫번째 배열의 데이터에 두번째 배열의 데이터만큼 제곱)
  • maximum, fmax(NaN 데이터 무시), minimum, fmin
  • mod
  • copysign(첫번째 배열의 데이터 부호를 두번째 배열의 데이터 부호로 변경)
  • greater, greater_equal, less, less_equal, equal, not_equal
  • logical_and, logical_or, logical_택
• where(boolean 배열, True일 때 선택할 데이터, False일 때 선택할 데이터)

# 2개의 배열에서 데이터 골라서 새로운 배열 만들기
ar = np.array([100, 200, 300, 400])
br = np.array([101, 201, 301, 401])
cond = np.array([True, False, False, True])

result = np.where(cond, ar, br) #cond 값이 True면 ar에서, False 이면 br에서 추출 
print(result)

18. 집합관련 함수

• unique(): 중복을 제거
• intersect1d(): 교집합
• union1d(): 합집합
• in1d(): 데이터의 존재 여부를 boolean 배열로 리턴
• setdiff1d(): 차집합
• setxor1d(): 한쪽에만 있는 데이터의 집합

19. 배열을 분할해주는 함수

• split
• axis 옵션을 이용해서 행방향으로 분리할지 열방향으로 분리할 지 설정할 수 있음
• 첫번째 파라미터는 배열이고 두번째 파라미터의 개수인데 정수대신에 list를 사용하면 list에 있는 숫자 대로 데이터를 분할합니다.

20. 데이터 정렬

• sort
• kind 옵션에 정렬방법을 설정 (정렬 알고리즘)
• numpy.sort에 배열을 대입하면 정렬한 데이터를 리턴
  • 배열.sort를 하게되면 배열 자체를 정렬합니다.

#데이터 정렬
ar = np.array([40, 200, 10, 100, 500,80])
result = np.sort(ar) 
print(result)

br = ar.reshape(2, 3)
print(br)
br.sort(axis=1)
print(br)

21. 선형 대수 함수

1) numpy.diag

• 2차원 배열(행렬)을 넘겨주면 대각원소를 가지고 1차원 배열을 만들어주고 1차원 배열을 넘겨면 1차원 배열을 대각선 요소로 하고 나머지는 0으로 채운 배열을 리턴해주는 함수
  • 1차원 배열을 넘겨줄 때는 k라는 옵션에 대각선을 채우는 위치를 설정

2) diagonal

• 2차원 배열을 받아서 대각원소만 꺼내서 1차원 배열을 만드는 함수이고 offset을 이용해서 꺼내는 위치를 수정

3) trace

• 대각선 원소의 합이고 offset을 이용해서 꺼내는 위치를 수정

1~ 3 대각선 식

4) dot

• 행렬의 곱셈

5) linalg.inv

• 역행렬

6) linalg.det

• 행렬식

7) linalg.eig

• 고유값과 고유벡터 계산
• 변수의 갯수를 줄일때 이용

• 행렬의 곱: 행렬의 행과 열의 개수가 다른 행렬의 열과 행 개수와 같아야 성립

• 역행렬: 행렬의 곱이 단위 행렬인 정방행렬

import numpy
mat = numpy.array([[1, 2],
[3, 4]])
#역행렬
print(numpy.linalg.inv(mat))
#행렬과 역행렬의 행렬의 곱
print(numpy.dot(mat,numpy.linalg.inv(mat) ))


[[-2. 1. ]
[ 1.5 -0.5]]

[[1.00000000e+00 1.11022302e-16]
[0.00000000e+00 1.00000000e+00]]
> 실수가 나오면 문제가 발생할 소지가 있다 ( 실수 계산이 잘안되는것 )

• 행렬식: 연립 선형방정식의 성질을 결정하기 위해 정의

차원축소 : 데이터의 상관관계로 인하여 과적합이 나올수가 있으니 데이터를 줄여서 1개로 만드는 것
고유 값 : 행렬에 어떤 연산을 했을때 성질이 바뀌지 않는 값
고유값과 고유벡터

• 차원축소2) 상관관계가 있는 컬럼 합치기
• 1) 컬럼의 개수 줄이기 영향이 적은 컬럼 제거

배열의 결합

1. hstack

• 행의 수가 같은 배열을 열 방향으로 결합해주는 함수 (많이쓰임)

2. vstack

• 열의 수가 같은 배열을 행 방향으로 결합해주는 함수 (많이쓰임)

3. dstack

• 행과 열의 수가 같은 배열을 가지고 위치가 같은 요소들을 가지고 하나의 배열로 묶어서 차원이 1개 늘어난 배열을 만들어주는 함수

4. stack

• dstack과 비슷하지만 원하는 방향으로 새로운 배열을 만들어서 차원을 늘려주는 함수