[혼공머신] 내용 정리

 

인공지능 (artificial intelligence)

· 사람처럼 학습하고 추론할 수 있는 지능을 가진 컴퓨터 시스템을 만드는 기술

  ㆍ 인공일반지능 (artificial general intelligence) | 강인공지능 (String AI) : 사람과 구분하기 어려운 지능을 가진 컴퓨터 시스템

   ㆍ 약인공지능 (Week AI) : 현실에서 우리가 마주하고 있는 인공지능

머신러닝 (machine learning)

· 자동으로 데이터에서 규칙을 학습하는 알고리즘을 연구하는 분야

·  시간과 환경이 변화하면서 데이터도 바뀌기 때문에 주기적으로 새로운 훈련 데이터로 모델 다시 훈련

  ㆍ 사이킷런 (scikit-learn) : 대표 머신러닝 라이브러리, 파이썬 API

  지도 학습 (supervise learning)

· 훈련하기 위한 데이터와 정답 필요

· 새로운 데이터를 예측하는 데 활용

  ㆍ 입력 (input) : 데이터

  ㆍ 타깃 (target) : 정답

  ㆍ 훈련 데이터 (training data)

     - 입력과 타깃

     - 알고리즘의 성능을 제대로 평가하기 위해 훈련 데이터와 평가에 사용할 데이터가 각각 달라야 함

     - 평가를 위해 또 다른 데이터를 준비하거나 이미 준비된 데이터 중에서 일부를 떼어 내어 활용

  ㆍ 훈련 세트 (train set)

     - 훈련에 사용되는 데이터

     - 훈련 세트가 클수록 좋음

  ㆍ 테스트 세트 (test set)

     - 평가에 사용하는 데이터

     - 보통 전체 데이터에서 20~30% 사용

# 훈련 세트와 테스트 세트 나누기
from sklearn.model_selection import train_test_split

train_input, test_input, train_target, test_target = train_test_split(x, y)

train_test_split() : 훈련 데이터를 훈련 세트와 테스트 세트로 나누는 함수
random_state= : 초깃값 설정 매개변수
test_size= : 테스트 세트 비율 설정 매개변수, 기본값(0.25%)
stratify=타깃 : 샘플링 편향을 막기 위해 타깃 클래스 비율에 맞게 데이터를 나누는 매개변수
shuffle= : 데이터를 나누기 전 무작위로 섞을지 여부 지정 매개변수, 기본값(True)

 

  비지도 학습 (unsupervised learning)

· 타깃 없이 입력 데이터만 사용

· 데이터를 잘 파악하거나 변형하는 데 도움

  강화학습 (reinforcement learning)

· 알고리즘이 행동한 결과로 얻은 보상을 사용해 학습

 

딥러닝 (deep learning)

· 머신러닝 알고리즘 중 인공 신경망(artificial neural network)을 기반으로 한 방법들 통칭

  ㆍ 텐서플로 (TensorFlow) : 구글 딥러닝 라이브러리, 파이썬 API

  ㆍ 파이토치 (PyTorch) : 페이스북 딥러닝 라이브러리, 파이썬 API

 

---

 

특성 (feature) : 데이터의 특징

샘플 (sample) : 하나의 타깃에 대한 여러 특성들

훈련 (training) : 모델에 데이터를 전달하여 규칙을 학습하는 과정

모델 (model) : 알고리즘이 구현된 객체, 알고리즘 자체

스케일 (scale) : 특성 값의 범위

특성 공학 (feature engineering) : 기존의 특성을 사용해 새로운 특성을 뽑아내는 작업

 

---

  샘플링 편향 (sampling bias)

· 훈련 세트와 테스트 세트에 샘플이 골고루 섞여 있지 않고 샘플링이 한쪽으로 치우침

 

  과대적합 (overfitting)

· 훈련 세트에서 점수가 높았지만 테스트 세트의 점수가 매우 낮은 경우

· 샘플 개수보다 특성이 많은 경우

· 규제를 적용하여 해결

 

  과소적합 (underfitting)

· 훈련 세트보다 테스트 세트의 점수가 높거나 두 점수가 모두 낮은 경우

· 훈련 세트와 테스트 세트의 크기가 매우 작은 경우 (테스트 세트가 훈련 세트의 특징을 따르지 못할 수 있음)

· 모델이 단순하여 훈련 세트에 적절히 훈련되지 않은 경우

· 모델을 복잡하게 만들어 해결

 

  규제 (regularization)

· 머신러닝 모델이 훈련 세트에 과대적합 되지 않도록 만드는 것

· 선형 회귀 모델의 경우 특성에 곱해지는 계수(or 기울기) 크기를 작게 만드는 것

· 규제를 공정하게 적용하기 위해 스케일 조정 필요

---

데이터 전처리 (data preprocessing)

· 특성값을 일정한 기준으로 맞추는 작업

· 머신러닝 모델에 훈련 데이터를 주입하기 전에 가공하는 단계

· 훈련 세트를 기준으로 테스트 세트 전처리 진행

  표준점수 (standard score) | z점수

   ㆍ 공식 : 개별값 - 평균값 / 표준편차

   ㆍ 스케일을 바꾸는 대표적인 방법 중 하나

   ㆍ 각 특성값이 평균에서 표준편차의 몇 배만큼 떨어져 있는지 나타냄

   ㆍ 분산 : 데이터에서 평균을 뺀 값을 모두 제곱한 다음 더한 후 전체 개수로 나눔

   ㆍ 표준편차 : 분산의 제곱근, 데이터가 분산된 정도

 

---

 

분류 (classification)

·여러 개의 클래스 (Class) 중 하나를 구별해 내는 문제

 

  ㆍ 이진 분류 (binary classification)

     - 2개의 클래스 중 하나를 고르는 문제

     - 찾으려는 대상을 1, 아닌 것은 0

 

  ㆍ 다중 분류 (multi-class classification)

     - 타깃 데이터에 2개 이상의 클래스가 포함된 문제

     - 타깃값을 숫자로 변환하지 않고 모델에 전달하면 알파벳 순으로 숫자가 매겨짐

 

  평가지표

· 정확도(accuracy)

  ㆍ 정확한 답을 몇 개 맞혔는지 백분율로 나타낸 값

  ㆍ 사이킷런은 0~1로 출력

model.score(test_input, test_target)

 

회귀 (regression)

· 임의의 어떤 숫자를 예측하는 문제

· 타깃값도 임의의 수치

 

  평가지표

· 결정계수(R², coefficient of determination)

  ㆍ 계산식 : 1 - (타깃 - 예측)²의 합 / (타깃 - 평균)²의 합

  ㆍ 0에 가까울수록 평균에 가깝고, 1에 가까울수록 잘 예측한 것, 음수일 경우 완전히 반대로 예측한 것

model.score(test_input, test_target)

 

· MAE (평균 절댓값 오차, Mean Absolute Error)

  ㆍ 계산식 : |(예측값 - 실제값)| / n

  ㆍ 특이값이 많은 경우 주로 사용

  ㆍ 값이 낮을수록 좋음

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(타깃, 예측값) : 순서 중요

 

---

모델(model)

  모델 파라미터 (model parameter)

  ㆍ 머신러닝 알고리즘이 찾은 값

  ㆍ 모델 기반 학습 : 머신러닝 알고리즘의 훈련 과정을 통해 최적의 모델 파라미터를 찾는 것

  ㆍ 사례 기반 학습 : 모델 파라미터 없이 훈련 세트를 저장하는 것이 전부인 것

 

하이퍼 파라미터 (hyperparameter)

  ㆍ 사람이 알려줘야 하는 파라미터

  ㆍ 머신러닝 라이브러리에서  클래스와 메서드의 매개변수로 표현

  ㆍ 대표적으로 릿지와 라쏘의 규제 강조 alpha 파라미터가 있음

 

활성화 함수 (activation function)

  ㆍ 시그모이드 함수 (sigmoid function) | 로지스틱 함수 (logistic function)

     - S(x) = 1 / 1+ e^-z  == 1 / (1 + np.exp(-z))

     - z(하나의 선형 방정식 출력값)을 0~1 사이의 값으로 변환

     - z가 무한하게 큰 음수일 경우 함수가 0에 가까워지고, 무한하게 큰 양수일 경우 1에 가까워짐

     - 이진 분류에서 사용

     - 0.5보다 크면 양성, 작으면 음성 클래스로 판단

     - 정확히 0.5일 경우 라이브러리마다 다를 수 있지만 사이킷런은 음성으로 판단

출처 : 위키백과

 

  ㆍ 소프트맥스 함수 (softmax function)

     - z(여러 개의 선형 방정식 출력값)을 0~1 사이로 압축하고 전체 합이 1이 되도록 함

     - 여러 개의 z값(z1~zn)을 지수 함수를 사용하여 (e^z1~e^zn) 모두 더하고(e_sum)
       e^z1~e^zn을 각각 e_sum으로 나눈 값(s1~sn)이 클래스별 확률, s1~sn을 모두 더하면 1 (확률의 합)

     - 다중 분류에서 사용

     - 정규화된 지수 함수

 

---

 

손실 함수 (loss function)

  ㆍ머신러닝 알고리즘의 오차를 나타냄 ☞ 값이 작을수록 좋음

  ㆍ샘플 하나에 대한 손실 정의

  ㆍ확률적 경사 하강법이 최적화할 대상으로 미분이 가능해야 함 (연속성)

  ㆍ대부분의 문제에 잘 맞는 손실함수가 이미 정의되어 있음

     - 이진 분류 : 로지스틱 (logistic loss function) | 이진 크로스엔트로피 (binary cross-entropy loss function)

          - 타깃 = 1, -log(예측 확률)

          - 타깃 = 0, -log(1 - 예측 확률)

          - 확률이 각 타깃과 멀어질 수록 손실은 큰 양수로 나타남

     - 다중 분류 : 크로스엔트로피 (cross-entropy loss function)

     - 회귀 : 평균 제곱 오차 (mean squared error)

          - (타깃 - 예측)² / 평균

  ㆍ힌지 손실 (hinge loss) : 서포트 벡터 머신 (support vector machine) 머신러닝 알고리즘을 위한 손실 함수

 

  ㆍ비용 함수 (cost function)

     - 손실 함수의 다른 말

     - 훈련 세트에 있는 모든 샘플에 대한 손실 함수의 합

     - 손실 함수와 구분하지 않고 섞어서 사용

 

 

  최적화 알고리즘 (Optimization Algorithm)

 

1. 점진적 학습 | 온라인 학습

ㆍ 앞서 훈련한 모델을 버리지 않고 새로운 데이터에 대해서만 조금씩 더 훈련하는 방법

 

  ㆍ 확률적 경사 하강법 (Stochastic Gradient Descent)

     - 대표적인 점진적 학습 알고리즘

     - 랜덤으로 한 개의 샘플을 골라 손실 함수의 경사를 따라 최적의 모델을 찾는 알고리즘

     - 모든 샘플을 다 사용했을 때도 경사가 남아있을 경,우 훈련 세트에 샘플을 모두 채우고 다시 사용

     - 신경망 모델에서 사용

 

     - 에포크 (epoch) : 확률적 경사 하강법에서 훈련 세트를 한 번 모두 사용하는 과정
           - 과소적합 : 에포크 횟수가 적을 때, 모델이 훈련 세트를 덜 학습한 경우

           - 과대적합 : 에포크 횟수가 많을 때, 모델이 훈련 세트를 완전히 학습한 경우

 

     - 조기 종료 (early stopping) : 과대적합이 시작하기 전에 훈련을 멈추는 것
                                 

 

  ㆍ 미니배치 경사 하강법 (minibatch gradient descent)

     - 여러 개의 샘플을 사용해 경사 하강법을 수행하는 방식 (보통 2의 배수)

     - 신경망 모델에서 사용

 

  ㆍ 배치 경사 하강법 (batch gradient descent)

     - 한 번 경사로를 따라 이동하기 위해 전체 샘플을 사용하는 방식

     - 가장 안정적인 방법이지만, 데이터의 양이 많을 경우 사용하기 어려움

   

from sklearn.linear_model import SGDClassifier

sc = SGDClassifier()

# 매개변수
loss= # 손실 함수 종류, 기본값('hinge')
      # 'hinge' : 힌지 손실, 서포트 벡터 머신을 위함
      # 'log' : 로지스틱 손실 함수
      #         다중 분류에서 지정 시 클래스마다 이진 분류 모델 생성 (OvR 방식)
      #         OvR (One versus Rest) : 하나의 클래스를 양성으로, 나머지는 음성으로
      
max_iter= # 에포크 횟수
          # ConvergenceWarning : 모델이 충분이 수렴하지 않음 ☞ max_iter 값 늘리기
tol= # 반복을 멈출 향상될 최솟값, 기본값(0.001)
     # None : 자동으로 멈추지 않고 무조건 max_iter 만큼 반복
n_iter_no_change= # 지정한 에포크 동안 손실이 tol만큼 줄어들지 않으면 알고리즘 중단, 기본값(5)
     
penalty= # 규제 종류 지정, 기본값('l2')
alpha= # 규제 강도 지정, 기본값(0.0001)
random_state= # 초깃값 설정


sc.fit(2차원 x, 1차원 y) # 훈련
sc.partial_fit(2차원 x, 1차원 y) # 호출할 때마다 1 에포크씩 이어서 훈련
└ classes= # fit()을 사용하지 않은 상태에서 사용할 경우, 전체 훈련 세트 클래스의 레이블 전달 필요
          #  레이블을 전달할 때 사용하는 매개변수

sc.score(2차원 x, 1차원 y) # 정확도 점수 출력

# ---

from sklearn.linear_model import SGDRegressor

sr = SGDRegressor()

# 매개변수
loss= # 손실 함수 지정, 기본값('squared_loss') → 제곱 오차

# 이외 SGDClassifier와 동일

 

---

 

  k-최근접 이웃 (k-Nearest Neighbors)

  ㆍ 지도학습의 한 종류

  ㆍ 분류와 회귀 모두 가능

     - 분류 : 예측하려는 샘플에 가까운 샘플 k개를 선택 후 다수의 클래스를 샘플의 클래스로 예측

     - 회귀 : 예측하려는 샘플에 가까운 샘플 k개를 선택 후 타깃값의 평균을 샘플의 타깃값으로 예측

  ㆍ 어떤 데이터에 대한 답을 구할 때 주위 다른 데이터를 보고 다수를 차지하는 것을 정답으로 함

  ㆍ 가까운 직선거리 데이터를 살피기 위해 모든 데이터를 가지고 있어 데이터가 많은 경우 사용하기 어려움

  ㆍ 거리 기반이기 때문에 데이터 전처리를 통해 특성값의 스케일을 조정해야 함

  ㆍ 모델 복잡도 증가 : 이웃의 개수(k) 줄이기

  ㆍ 사례 기반 학습

from sklearn.neighbors import KNeighborsClassifier : 분류
from sklearn.neighbors import KNeighborsRegressor : 회귀

kn = KNeighborsClassifier(n_neighbors=) : 분류 클래스 객체 만들기
knt = KNeighborsRegressor() : 회귀 클래스 객체 만들기


# 매개변수
n_neighbors= : 참고 데이터 수 지정, 기본값(5)
   - 모델.n_neighbors= : 모델 생성 후 k값 변경
p= 거리 재는 방법 지정, 맨해튼 거리(1_기본값), 유클리디안 거리(2)
n_jobs= : 사용할 CPU 코어 지정, 모든 CPU 코어(-1), 기본값(1)


kn.fit(2차원 배열 x, 1차원 배열 y) : 모델 훈련
kn.score(2차원 배열 x, 1차원 배열 y) : 모델 평가
kn.predict(2차원 배열 x) : 새로운 데이터의 정답 예측
  - 다중 분류 시 문자열 타깃값으로 출력
kn.predict_proba(2차원 배열 x) : 클래스별 확률값


kn._fit_X : 모델에 전달한 특성
kn._y : 모델에 전달한 정답
kn.kneighbors(2차원 배열 샘플) : 주어진 샘플에서 가장 가까운 이웃의 거리와 인덱스 반환
  - n_neighbors= : 반환할 이웃 개수 지정 매개변수
  - 기본값(객체 생성 시 설정한 참고 데이터 수)
  - return_distance= : 거리 반환 여부 지정 매개변수, 기본값(True)
kn.classes_ : 정렬된 타깃값

 

  선형 회귀 (linear regression)

 ㆍ y = ax + b

  ㆍ 대표적인 회귀 알고리즘

  ㆍ 특성과 타깃 사이의 관계를 잘 나타내는 선형 방정식을 찾음

     - 해당 관계는 계수 | 가중치에 저장

  ㆍ 특성이 하나인 경우 어떤 직선을 학습하는 알고리즘

  ㆍ 비교적 간단하고 성능이 뛰어남

  ㆍ 반복적인 알고리즘 사용

  ㆍ 모델 기반 학습

 

  ㆍ 다항 회귀 (polynomial regression)

     - y = ax² + bx + c

     - 다항식을 사용한 선형 회귀

     - np.column_stack()을 이용하여 x², x 이어 붙이기

     - 결정계수 구할 때 input에 poly 데이터 사용

 

  ㆍ 다중 회귀 (multiple regression)

     -  z = a * (Weight) + b * (Length) + c * (Diagonal) + d * (Height) + e * (Width) + f

     - 여러 개의 특성을 사용한 선형 회귀

     - 특성이 2개인 경우 평면을 학습

 

     - PolynomialFeatures 변환기를 이용하여 고차항 변환

       - 특성이 많은 고차원에서 복잡한 모델 표현

       - 특성의 개수를 크게 늘릴수록 모델은 강력해져 훈련 세트에 대해 완벽하게 학습하므로 과대적합 발생

 

     - 결정계수 구할 때 input에 poly 데이터 사용

 

   ㆍ 릿지 (ridge)

     - 선형 회귀 모델에 규제 추가

     - 규제 기준 : 계수를 제곱한 값 (L2 규제)

     - 일반적으로 릿지 선호

     - 계수의 크기를 줄여 과대적합 완화

        - 0으로 만들 수는 없음

     - 규제를 공정하게 적용하기 위해 스케일 조정 필요

 

     - alpha 매개변수를 통해 규제 양 조절

        - 최적의 alpha : 훈련 세트와 테스트 세트의 점수가 가장 가까운 지점

        - 적절한 alpha 값을 찾기 위해 alpha 값에 대한 결정계수 그래프 그려보기 (alpha = 하이퍼파라미터)

        - alpha가 커지면 규제도 커짐

 

   ㆍ 라쏘 (lasso)

     - 선형 회귀 모델에 규제 추가

     - 규제 기준 : 계수의 절댓값 (L1 규제)

     - 계수의 크기를 줄여 과대 적합 완화

        - 계수를 0으로 만들 수 있음 → 유용한 특성을 골라내는 용도로 사용

     - 규제를 공정하게 적용하기 위해 스케일 조정 필요

     - 좌표 하강법 (coordinate descent) : 최적의 모델을 찾기 위해 좌표축을 따라 최적화 수행

 

     - alpha 매개변수를 통해 규제 양 조절

        - 최적의 alpha : 훈련 세트와 테스트 세트의 점수가 가장 가까운 지점

        - 적절한 alpha 값을 찾기 위해 alpha 값에 대한 결정계수 그래프 그려보기 (alpha = 하이퍼파라미터)

 

     - ConvergenceWarning : 최적 계수 찾기 위한 반복 계산 수행 시 반복 횟수가 부족할 경우 발생하는 경고

        - max_iter=10000 매개변수 지정으로 반복 횟수 조정

from sklearn.linear_model import LinearRegression

lr = LinearRegression()

# 매개변수
fit_intercept= # 절편 학습 여부, 기본값(True)
C= # 규제 제어, 작을 수록 규제가 커짐, 기본값(1)
max_iter= # 알고리즘 수행 반복 횟수 지정, 기본값(100) 

# 결정계수
lr.score(train_input, train_target)
lr.score(test_input, test_target)


lr.coef_ : 기울기(=계수 coefficient, 가중치 weight)
lr.intercept_ : 절편



# --- 다항 회귀 ---

# 제곱항 만들고 일차항 붙이기
train_poly = np.column_stack((train_input**2, train_input))
test_poly = np.column_stack((test_input**2, test_input))

# 2차 방정식 그래프 예시
point = np.arange(15, 50) # 15에서 49까지 정수 배열
plt.plot(point, lr.coef_[0]*point**2, lr.coef_[1]*point, lr.intercept_)

# 결정계수
lr.score(train_poly, train_target)
lr.score(test_poly, test_target)



# --- 릿지/라쏘 ---
# 모델명만 변경하면 같음

from sklearn.linear_model import Ridge, Lasso

ridge = Ridge()
ridge.fit(train_scaled, train_target)

# 매개변수
alpha= # 규제 강도 조절, 클수록 강도 높음, 기본값(1) => ridge, lasso
solver= # 최적의 모델을 찾기 위한 방법 지정, 기본값('auto')
        # 'sag' : 확률적 평균 경사하강법 => 특성과 샘플 수가 많을 때
        # 'saga' : 'sag'의 개선 버전
        # => ridge
random_state= # ridge : solver가 'sag' or 'saga'일 때 시드값 지정
              # lasso : 시드값 지정
max_iter= # 알고리즘 수행 반복 횟수 지정, 기본값(1000) => lasso


# 결정계수
ridge.score(train_scaled, train_target)
ridge.score(test_scaled, test_target)


# 최적의 alpha값 찾기
train_score = [] # alpha 값 변경 시 score 결과 저장할 리스트
test_score = []

alpha_list = [0.001, 0.01, 0.1, 1, 10, 100]
for alpha in alpha_list:

	lasso = Lasso(alpha=alpha, max_iter=10000)
    
    lasso.fit(train_scaled, train_target)
    
    train_score.append(lasso.score(train_scaled, train_target))
    test_score.append(lasso.score(test_scaled, test_target))

plt.plot(np.log10(alpha_list), train_score) # alpha 값을 0.001부터 10배씩 늘렸기 때문에
plt.plot(np.log10(alpht_list), test_score)  # 그래프를 그리면 왼쪽이 촘촘
                                            # 동일한 간격으로 나타내기 위해 로그함수 이용해 지수 표현
plt.xlabel('alpha')
plt.ylabel('R²')

plt.show()

 

 

  로지스틱 회귀 (logistic regression)

  ㆍ z = a * (Weight) + b * (Length) + c * (Diagonal) + d * (Height) + e * (Width) + f

     - a, b, c, d, e : 가중치 or 계수

     - z는 어떤 값도 가능하지만 확률이 되려면 0~1(0~100%) 사이 값이 되어야 함

     - 다중 회귀 선형 방정식과 같음

  ㆍ 선형 방정식을 사용한 분류 알고리즘

 

  ㆍ 선형 회귀와 차이점

     - 시그모이드 함수나 소프트맥스 함수를 사용하여 클래스 확률 출력

     - 계산한 값을 그대로 출력하지 않고 값을 0~1 사이로 압축 (0~100%의 확률로 볼 수 있음)

 

  ㆍ 이진 분류

     - 하나의 선형 방정식 훈련

     - 방정식의 출력값을 시그모이드 함수에 통과 시켜 0~1 사이의 값(확률)을 만듦
       => 양성 클래스에 대한 확률

     - 음성 클래스에 대한 확률 : 1 - 양성 클래스에 대한 확률

 

  ㆍ 다중 분류

      - 클래스의 개수만큼 방정식 훈련

     - 각 방정식의 출력값을 소프트맥스 함수에 통과 시켜 전체 클래스에 대한 합이 항상 1이 되도록 만듦
       => 각 클래스에 대한 확률

  

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression()

# 매개변수
solver= # 알고리즘 선택, 기본값('lbfgs')
        # 'sag' : 확률적 평균 경사 하강법 알고리즘, 특성과 샘플 수가 많을 때 성능이 빠르고 좋음
        # 'saga' : sag의 개선 버전
penalty= # 규제 방식 선택, 기본값('l2')=릿지, 'l1'=라쏘
c= # 규제 강도 제어, 기본값(1.0), 값이 작을 수록 규제가 강해짐


lr.fit(2차원 x, 1차원 y) # 훈련
lr.predict(2차원 x) # 예측
lr.predict_proba(2차원 x) # 예측 확률 반환
                         # 이진 분류 : 샘플마다 음성 클래스와 양성 클래스에 대한 확률 반환
                         # 다중 분류 : 샘플마다 모든 클래스의 확률 반환
lr.decision_function(2차원 x) # 모델이 학습한 선형 방정식 출력 반환
                             # 이진 분류 : 양성 클래스의 확률 반환, 0보다 크면 양성, 작거나 같으면 음성
                             # 다중 분류 : 각 클래스마다 선형 방정식을 계산, 가장 큰 값이 예측 클래스


lr.coef_ # 계수
lr.intercept_ # 절편
# => 다중 분류는 클래스마다 z값을 하나씩 계산

 

---

패키지 / 라이브러리

· 기능을 구현한 함수를 특정 기능별로 묶어둔 것

· 임포트 (import) : 따로 만들어둔 파이썬 패키지(클래스와 함수의 묶음)를 사용하기 위해 불러오는 명령어

 

 사이킷런 (scikit-learn)

  ㆍ 대표 머신러닝 라이브러리

  ㆍ 파이썬 API

  ㆍ 입력 데이터는 2차원 리스트이어야 함

  ㆍ 사이킷런의 모델은 자동으로 특성에 추가된 절편항 무시

 

  ㆍ 변환기 (transformer)

     - 특성을 만들거나 전처리하기 위해 제공하는 클래스

     - fit(), transform(), fit_transform() 메서드 제공

     - 훈련 세트를 기준으로 변환하기 때문에 테스트 세트는 transform만 사용

 

     - PolynomialFeatures : 주어진 특성을 조합하여 새로운 특성 만듦

     - StandardScaler : 특성을 표준화로 변환

 

  ㆍ추정기 (estimator)

     - 선형 회귀 같은 사이킷런의 모델 클래스

# --- 변환기 ---
from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures()

# 매개변수
include_bias= # 절편 추가 여부, 기본값(True) => 혼돈 피하기 위해 명시적 지정
degree= # 고차항의 최대 차수 지정, 기본값(2)
interaction_only= # 거듭제곱 항 제외 여부, 기본값(False)

poly.fit(훈련 세트 중 입력 데이터) # 새롭게 만들 특성 조합 찾음, 입력 데이터만 전달
train_input = poly.transform(train_input) # 데이터 변환
test_input = poly.transform(test_input) # 훈련 세트를 기준으로 변환, 테스트 세트는 transform만 진행

poly.get_feature_names_out() # 특성이 만들어진 조합 출력

# ---

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()

ss.fit(훈련 세트 중 입력 데이터)
train_scaled = ss.transform()
test_scaled = ss.transform() # 훈련 세트를 기준으로 변환, 테스트 세트는 transform만 진행

ss.mean_ # 훈련 세트에서 학습한 평균
ss.scale_ # 훈련 세트에서 학습한 표준편차

 

 사이파이 (scipy)

  ㆍ 

import scipy

scipy.special.expit(z값) # 시그모이드 함수, decision_function으로 계산한 z값에 대한 확률 출력
scipy.special.softmax(z값) # 소프트맥스 함수, decision_function으로 계산한 각 클래스별 z값에 대한 확률 출력
                           # axis=1 : 각 샘플별 확률합이 1이 되도록 계산
                           # axis=0 : 각 특성별 확률합이 1이 되도록 계산

 

맷플롯립 (matplotlib)

  ㆍ 파이썬에서 과학계산용 그래프를 그리는 대표 패키지

import matplotlib.pyplot as plt

plt.xlabel('') : x축 이름 지정
plt.ylabel('') : y축 이름 지정

plt.xlim(시작 값, 끝 값) : x축 범위 지정
plt.ylim(시작 값, 끝 값) : y축 범위 지정

plt.show() : 그래프 출력

plt.scatter(x, y) : 산점도 그래프
marker= : 모양 지정 매개변수, 기본값('o'), 삼각형('^'), 마름모('D')

 

  넘파이 (numpy)

  ㆍ 파이썬의 대표적인 배열(array) 라이브러리

  ㆍ 고차원의 배열을 손쉽게 만들고 조작하는 도구 제공

  ㆍ 차원 (dimension)

     - 배열에서의 차원은 좌표계의 축

     - 1차원 배열(선), 2차원 배열(면), 3차원 배열(3차원 공간)

     - 왼쪽 위에서부터 시작

  ㆍ 배열 인덱싱 (array indexing) : 여러 개의 인덱스로 한 번에 여러 개의 원소 선택

  ㆍ 브로드캐스팅 (broadcasting) : 크기가 다른 넘파이 배열에서 자동으로 사칙 연산을 모든 행이나 열로 확장하여 수행

  ㆍ 불리언 인덱싱 (boolean indexing) : True, False 값을 전달하여 True인 행만 선택

import numpy as np

np.array(리스트) : 배열로 변환
np.arange(시작 숫자, 종료 숫자, 간격) : 일정한 간격의 정수 또는 실수 배열 생성, 기본 간격 1

np.random.seed(정수) : 난수를 생성하기 위한 정수 초깃값, 초깃값이 같으면 동일한 난수 추출
np.random.shuffle(배열) : 배열 섞기, 다차원 배열일 경우 첫 번째 축(행)만 섞음

np.column_stack((리스트1, 리스트2)) : 리스트를 일렬로 세워 나란히 연결, 리스트는 튜플로 전달
np.concatenate((리스트1, 리스트2)) : 첫번째 차원을 따라 배열 연결, 리스트는 튜플로 전달

np.ones(정수) : 원하는 개수만큼 1로 채운 배열 생성
np.zeros(정수) : 원하는 개수만큼 0으로 채운 배열 생성

np.log() : 자연 상수 e를 밑으로 하는 자연로그
np.log10() : 10을 밑으로 하는 상용로그
np.exp() : 자연 상수 e를 밑으로 하는 지수함수

np.mean(배열) : 평균
np.std(배열) : 표준편차
np.sum(배열) : 합, 배열에 비교연산자를 사용할 경우 bool type True에 맞는 원소 개수 헤아릴 수 있음
  - np.sum(lasso.coef_ == 0) : 라쏘 회귀 모델의 0인 계수
np.round(배열) : 반올림, 기본값(소수점 첫째 자리)
  - decimals= : 유지할 소수점 아래 자릿수 지정 매개변수
axis= : 방향 지정 매개변수, 열(0), 행(1)

array.shape : 배열의 크기 출력 (샘플 수, 특성 수)
array.reshape(a, b) : 배열 크기 변경
   - np.reshape(배열, (a, b))
   - a=행 크기, b=열 크기
   - -1 : -1이 아닌 자리를 고정시키고, -1의 자리를 자동으로 적절한 형태를 계산
   - 바꾸기 전과 후의 원소의 개수는 동일해야 함
array[행, 열] : 2차원 배열은 행과 열 인덱스를 콤마(,)로 나누어 지정

 

 

판다스 (pandas)

  ㆍ 데이터 분석 라이브러리

  ㆍ 데이터프레임 (dataframe)

     - 행, 열로 이루어진 2차원 표 형식의 주요 데이터 구조

     - 다차원 배열을 다루며 넘파이 배열보다 더 많은 기능 제공

     - 넘파이 배열로 쉽게 변환 가능

  ㆍ csv 파일 (comma-separated values)

     - 콤마로 나누어져 있는 텍스트 파일

     - 판다스 데이터프레임 만들 때 많이 사용

     - 첫 줄을 자동으로 인식해 열 제목으로 만들어 줌

import pandas as pd

df = pd.read_csv(csv 파일) # csv 파일을 데이터프레임으로 변환

# read_csv() 매개변수
sep= # 파일 구분자 지정, 기본값(,)
header= # 데이터프레임의 열 이름으로 사용할 csv 파일의 행 번호 지정, 기본값(0)
skiprows= # 파일에서 읽기 전에 건너뛸 행의 개수
nrows= # 파일에서 읽을 행의 개수

df.to_numpy() # 넘파이 배열로 변환
pd.unique(df[열]) # 해당 열의 고유값 추출

 

---

 

파이썬

· 리스트 내포 (list comprehension) : for문과 if문을 한 라인에 작성하여 리스트에 추가

· zip() : 나열된 리스트 각각에서 하나씩 원소를 꺼내 반환

· 인덱스 (index) : 배열의 위치, 배열의 요소 선택, 0부터 시작

· 슬라이싱 (slicing) : 콜론(:)을 통해 인덱스의 범위를 지정하여 여러 개의 원소 선택, 마지막 인덱스의 원소는 포함되지 않음

· 튜플 (tuple) : 원소에 순서가 있고, 수정할 수 없음

· _ : 나중에 사용하지 않고 그냥 버리는 값을 넣어두는 용도로 사용하는 특별한 변수