[Machine Learning] 지도학습(회귀/분류)

출처: 나도코딩 '머신러닝'

 

1. Linear Regression 

1) 기본

X = dataset.iloc[:, :-1].values # 처음부터 마지막 컬럼 직전까지의 데이터 (독립 변수 - 원인)
y = dataset.iloc[:, -1].values # 마지막 컬럼 데이터 (종속 변수 - 결과)

from sklearn.linear_model import LinearRegression
reg = LinearRegression() # 객체 생성
reg.fit(X, y) # 학습 (모델 생성)

y_pred = reg.predict(X) # X 에 대한 예측 값


# 값들 확인하는 방법
reg.predict([[9]]) #9시간 공부했을 때 예상 점수 
reg.coef_ # 기울기 (m)
reg.intercept_ # y 절편 (b)


# 시각화
plt.scatter(X, y, color='blue') # 산점도-> 실제 데이터 분포 나타내줌
plt.plot(X, y_pred, color='green') # 선 그래프 -> 예측값 나타내줌
plt.title('Score by hours') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

 

2) 데이터 세트 분리시키고 모델링

 

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) # 훈련 80 : 테스트 20 으로 분리

from sklearn.linear_model import LinearRegression
reg = LinearRegression()
reg.fit(X_train, y_train) # 훈련 세트로 학습

# 데이터 시각화(훈련 세트)
plt.scatter(X_train, y_train, color='blue') # 산점도
plt.plot(X_train, reg.predict(X_train), color='green') # 선 그래프
plt.title('Score by hours (train data)') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

# 데이터 시각화(테스트 세트) 
plt.scatter(X_test, y_test, color='blue') # 산점도
plt.plot(X_train, reg.predict(X_train), color='green') # 선 그래프
plt.title('Score by hours (test data)') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

 

3) 경사 하강법(Gradient Descent)

# 경사 하강법
from sklearn.linear_model import SGDRegressor # SGD : Stochastic Gradient Descent 확률적 경사 하강법

# 지수표기법
# 1e-3 : 0.001 (10^-3)
# 1e-4 : 0.0001 (10^-4)
# 1e+3 : 1000 (10^3)
# 1e+4 : 10000 (10^4)

# sr = SGDRegressor(max_iter=200, eta0=1e-4, random_state=0, verbose=1)
sr = SGDRegressor()
sr.fit(X_train, y_train)

plt.scatter(X_train, y_train, color='blue') # 산점도
plt.plot(X_train, sr.predict(X_train), color='green') # 선 그래프
plt.title('Score by hours (train data, SGD)') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

sr.coef_, sr.intercept_
sr.score(X_train, y_train) # 훈련 세트를 통한 모델 평가 
sr.score(X_test, y_test) # 테스트 세트를 통한 모델 평가

 

- Epoch :  전체 학습 데이터를 한 번 모두 학습하는 것 을 1 epoch라고 함

  ex) model.fit(X, y, epochs=100) → 전체 데이터를 100번 학습

- max_iter = Epoch 횟수

  전체 훈련 데이터를 몇 번 반복해서 학습할지 정하는 값

  ex) max_iter=100 → 훈련 데이터를 100번 반복해서 학습함

- eta0 = 학습률(learning rate)

   한 번의 학습에서 파라미터(가중치)를 얼마나 크게 바꿀지 결정하는 값

 

4) 선형회귀 분석 vs 경사 하강법

 

• 데이터가 작고 빠른 정확한 결과가 필요: → LinearRegression()
• 데이터가 매우 크거나, 실시간 업데이트, 온라인 학습 필요: → SGDRegressor()

 

2. Multiple Linear Regression

1) One-hot Encoding

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(drop='first'), [2])], remainder='passthrough')
X = ct.fit_transform(X)

 

- 범주형 데이터를 0과 1로만 이루어진 벡터로 바꾸는 것

- 범주가 너무 많을 경우, 열이 너무 많아져서 차원이 폭발할 수 있음(→ 차원의 저주)

   이럴 때는 Label Encoding, Embedding, 또는 Feature Hashing 같은 기법을 고려해야 함.

 

2) 다양한 평가 지표(회귀 모델)

from sklearn.metrics import mean_absolute_error
mean_absolute_error(y_test, y_pred) # 실제 값, 예측 값 # MAE

from sklearn.metrics import mean_squared_error
mean_squared_error(y_test, y_pred) # MSE

from sklearn.metrics import mean_squared_error
mean_squared_error(y_test, y_pred, squared=False) # RMSE

from sklearn.metrics import r2_score
r2_score(y_test, y_pred) # R2

1. MAE (Mean Absolute Error) : (실제 값과 예측 값) 차이의 절대값
2. MSE (Mean Squared Error) : 차이의 제곱
3. RMSE (Root Mean Squared Error) : 차이의 제곱에 루트
4. R2 : 결정 계수
5. R2 는 1에 가까울수록, 나머지는 0에 가까울수록 좋음

 

3. Polynomial Regression

1) 기본 코드

from sklearn.preprocessing import PolynomialFeatures

# X의 차원을 우선 바꾼다
poly_reg = PolynomialFeatures(degree=4) # 4차
X_poly = poly_reg.fit_transform(X)

poly_reg.get_feature_names_out()
# output : array(['1', 'x0', 'x0^2', 'x0^3', 'x0^4'], dtype=object)

# 차원이 바뀐 X로 회귀 학습 진행
lin_reg = LinearRegression()
lin_reg.fit(X_poly, y) # 변환된 X 와 y 를 가지고 모델 생성 (학습)

# 데이터 시각화
plt.scatter(X, y, color='blue')
plt.plot(X, lin_reg.predict(poly_reg.fit_transform(X)), color='green')
plt.title('Score by hours (genius)') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

 

2) numpy

 

# shape -> 배열의 모양(차원)을 알려주는 속성으로 튜플로 반환값을 돌려줌

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape)  # 출력: (2, 3)

2행 3열짜리 배열

 

# reshape -> 배열의 모양을 바꾸는 함수

b = np.array([1, 2, 3, 4, 5, 6])
b2 = b.reshape(2, 3)
print(b2)
# 출력:
# [[1 2 3]
#  [4 5 6]]

 

# arrange - > 숫자를 순차적으로 생성하는 함수고 배열로 반환됨

 

시각화한 그래프를 쫌 더 매끄럽게 만들어주기 위해 numpy 사용

X_range = np.arange(min(X), max(X), 0.1) # X 의 최소값에서 최대값까지의 범위를 0.1 단위로 잘라서 데이터를 생성
X_range.shape
# output : (46, ) 즉 46행 1열

X_range = X_range.reshape(-1, 1) # row 개수는 자동으로 계산, column 개수는 1개

plt.scatter(X, y, color='blue')
plt.plot(X_range, lin_reg.predict(poly_reg.fit_transform(X_range)), color='green')
plt.title('Score by hours (genius)') # 제목
plt.xlabel('hours') # X 축 이름
plt.ylabel('score') # Y 축 이름
plt.show()

이렇게 하면 조금 더 부드러운 곡선을 얻을 수 있음

 

 

4. Logistic Regression

1) 기본코드

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()
classifier.fit(X_train, y_train)

# 예측
classifier.predict([[6]])
# 결과 1 : 합격할 것으로 예측
classifier.predict_proba([[6]]) # 합격할 확률 출력
# 불합격 확률 14%, 합격 확률 86%

# 예측 일반화
y_pred = classifier.predict(X_test)
# 예측 값 vs 실제 값. -> y_pred vs y_test

classifier.score(X_test, y_test) # 모델 평가
# 전체 테스트 세트 4개 중에서 분류 예측을 올바로 맞힌 개수 3개 -> 3/4 = 0.75

 

2) 시각화

X_range = np.arange(min(X), max(X), 0.1) # X 의 최소값에서 최대값까지를 0.1 단위로 잘라서 데이터 생성
p = 1 / (1 + np.exp(-(classifier.coef_ * X_range + classifier.intercept_))) # y = mx + b
p = p.reshape(-1) # 1차원 배열 형태로 변경

# 훈련세트
plt.scatter(X_train, y_train, color='blue')
plt.plot(X_range, p, color='green')
plt.plot(X_range, np.full(len(X_range), 0.5), color='red') # X_range 개수만큼 0.5 로 가득찬 배열 만들기
plt.title('Probability by hours')
plt.xlabel('hours')
plt.ylabel('P')
plt.show()

 

3) 혼돈행렬(Confusion Matrix)

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
cm

# TRUE NEGATIVE (TN)       FALSE POSITIVE (FP)
# 불합격일거야 (예측)      합격일거야 (예측)
# 불합격 (실제)             불합격 (실제)

# FALSE NEGATIVE (FN)      TRUE POSITIVE (TP)
# 불합격일거야 (예측)      합격일거야 (예측)
# 합격 (실제)               합격 (실제)

array([[1, 1],
       [0, 2]], dtype=int64)

 

모델이 예측한 실제 정답과 비교해서 얼마나 정확히 맞췄는지, 어디서 틀렸는지 표로 나타낸 것.

-> accuracy, recall, precision 등을 구할 수 있음