8. 지도 학습

 

> 가장 가까운 K개 봐서 판단하는 모델 

> 왜 K 근접 이웃 알고리즘 맨 처음에 배우는 이유는 쉽기 때문

 

> 빨간 점이 세모인지 네모인지 모를 때

 

> 가장 가까운 게 세모니깐 세모다

 

> 그래서 개수를 늘려가면서 판단하는 개념 

 

 

> 거리 개념을 알아야 어떤 게 더 가까이 있는지 알 수 있다. 

> 거리 개념은 여러 가지가 있다 (유클리디안, 맨해튼 거리 등등) 

> 유클리디안 거리가 가까워도 맨하튼 거리가 길 수 도 있다. 

> ex) 길이가 짧아도 도달하는 시간이 더 길 수 도 있다

 

> 빨간 점 기준 거리를 구한다 

 

> K 개수 늘려가면서 다수결로 판단한다 

> 몇 개 뽑을지는 사용자가 정한다 

 

 

> 모든 데이터의 거리를 구해야 되게 거리 데이터를 RAM에다가 올려놓음 

> 연산이 빠른 장점이 있고 데이터 용량을 차지하는 단점이 있다

> KNN은 게으른 학습에 포함된다. 

 

> 열정적 학습은 반대 

 

import pandas as pd 
df = pd.read_csv("./data/iris.csv")

df.columns

features = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
X = df[features]
y = df['class']

from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te =  train_test_split(X,y,random_state = 0)

X_tn

> 피처와 타겟 데이터를 나눔 

> random_state를 넣는 이유는 training/test를 구분할 때 데이터가 쏠리지 않도록 random으로 구분한다

> 하지만 random을 가를 때 일정하게 갈라야 한다 왜냐하면 모델 여러 개로 만들고 나서 k 값은 변수로 주면서 accuracy를 비교할 때 random이 매번 다르다면 k값 때문인지 random split 때문이지 모르기 때문에 random 뽑는 걸 고정한다.

> 그래서 random _state = 0 이걸 random seed라고 한다

> 컴퓨터에 완벽한 random seed는 없다 (pesudo random)

> 예) random_state 마다 결과값이 달라질 수 있기 때문에 for 문 돌려서 최고 값 산출 (체리 피킹) 

from sklearn.preprocessing import StandardScaler 
std_scale = StandardScaler()
std_scale.fit(X_tn)

X_tn_std = std_scale.transform(X_tn)
X_te_std = std_scale.transform(X_te)

print(std_scale.mean_)
print(std_scale.scale_)

 

> preprocessing 라이브러리에서 standerdscaler 불러와서

> standard scaler라는 객체 만들어준다 

> 원본 데이터 → 변환기 → 평균/표준 

> 객체는 변환기를 만들어 준 것이다 std_scaler - StandarScaler()

> 표준화 하기 위해선 피쳐의 평균과 표준편차가 필요하다 

> 그래서 평균, 표준편차를 구해야 변환기가 완성된다. 
> std.scale은 3줄에서 깡통

> std.scale.fit(X_tn) 은 X_tn의 각 피쳐의 평균과 표준편차를 구한다 

> y_tn은 standadization은 안 한다, target은 안 건드림 

> target을 변형시키면 예측한 결과를 분석하지 못한다.

> test data를 넣을 때는 기존 training 피쳐의 평균 표준편차를 사용한다.

> fit은 범용적으로 사용된다. (다른 모델에서 구하는 값을 모든 것들) 

> std.scale.transform(X_tn)은 변환기에서 만들어놓은 평균, 표준편차를 활용해서 표준화한다. 

from sklearn.neighbors import KNeighborsClassifier
clf_knn = KNeighborsClassifier(n_neighbors = 2)
clf_knn.fit(X_tn_std, y_tn)

knn_pred = clf_knn.predict(X_te_std)
print(knn_pred)

 

> n_neighbors는 kNN에서 k를 정한다
> 여기서. fit scaler 변환기가 아니라 학습을 하라는 명령문 

> 학습하고 나서 predict로 잘 맞추는지 예측 명령  

> predict값과 y_te이랑 비교해서 몇 점 맞았는지 확인하면 된다. 

> n_neighbors = 2를 hyper parameter라고 한다. (가장 가까운 2개를 본다라는 뜻)

 

> parameter는 data로부터 나오는 값 

> hyper parameter는 사용자가 정하는 값 

 

from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_te, knn_pred)
print(accuracy)

from sklearn.metrics import precision_score
precision = precision_score(y_te, knn_pred, average = 'macro')
print(precision)

from sklearn.metrics import recall_score
recall = recall_score(y_te, knn_pred, average = 'macro')
print(recall)

from sklearn.metrics import f1_score
f1 = f1_score(y_te, knn_pred, average = 'macro')
print(f1)

 

#confusion matrix 
from sklearn.metrics import confusion_matrix
conf_matrix = confusion_matrix(y_te, knn_pred)
print(conf_matrix)

#분류 report
from sklearn.metrics import classification_report
class_report = classification_report(y_te, knn_pred)
print(class_report)

> 0,1,2는 target

> 0번을 잘 맞춤, 2번을 잘 못 맞춤

> support는 개수 

> 0번 기준에서 1, 2번 예측하는 건 안 중요함 

> macro avg는 전체 평균 

> weighted avg는 가중 평균 (support 개수를 적용해서) 

> 결과가 0.94에서 올리려고 하면 hyper parameter를 변경해서 best model을 찾는 걸 hyper parameter tunning.

> tn, te 데이터 분류 -데이터 표준화 - 학습 - 결과 - 수정 

> 이건 분류 문제 

 

> 예측은 근처의 값들의 평균으로 구한다 

> 동일한 Flow이나 KNeighborsRegressor로 적용한다 

import pandas as pd
df = pd.read_csv('./data/house_prices.csv', encoding = 'cp949')

features = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
       'PTRATIO', 'B', 'LSTAT']

X = df[features] 
y = df['MEDV'] 

from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te = train_test_split(X,y,random_state = 0)

from sklearn.preprocessing import StandardScaler 
std_scale = StandardScaler()
std_scale.fit(X_tn) 

X_tn_std = std_scale.transform(X_tn) 
X_te_std = std_scale.transform(X_te)

from sklearn.neighbors import KNeighborsRegressor 
clf_knn = KNeighborsRegressor(n_neighbors = 2) 
clf_knn.fit(X_tn_std, y_tn)

knn_pred = clf_knn.predict(X_te_std)
#print(knn_pred)

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_te, knn_pred)
print(mse)

 

 

> 변수들 간의 선형 관계를 이용해서 예측하는 방법

 

 

> w는 가중치, b는 관심 없고 w가 중요

> a 기울기가 b 보다 중요하다 

> 기울기는 피처 x의 영향도를 나타냄 

> 어떤 피쳐가 중요한지 보통 알 수 없는데 선형 회귀 분석에선 어느 정도 알 수 있다

 

> xi는 열 벡터이고 i 번째 x (피처)를 f 함수에 집어넣었을 때 yi^는 i 번째 target의 추정치

> i 번째의 x는 i 번째 피쳐가 아님, 피쳐들의 행의 순서임

 

> 오차는 target과 target 추정량의 차이 

> 오차는 망소 항목 

> 오차 제곱합을 작게 만들어서 w를 구한다 

 

> 통계에선 독립 변수, 종속 변수라고 명명함

> 피처가 하나일 때 가정 

 

> 회귀 분석은 가정이 필요하다 (ML에선 안 씀)
> 정규 분포를 따르는 조건은 매우 제약되는 조건임

> 분산도 x값에 관계없이 일정하다도 어려운 조건

> 오차 없이 측정할 수 없는 변수는 거의 불가 

> 오차들은 독립 또한.

> 고전적인 회귀 분석의 가정을 맞추기 위해 사전 작업을 많이 필요 

> ML에선 고전적인 회귀 분석 가정을 무시한다 

> 통계학은 가정과 과정이 중요 ML은 결과 잘 나오면 끝

 

> w를 구하기 위한 방법

> 이 함수는 목적함수가 된다. 

> y^ 추정량이고 점들이 실제 값

> 평균이 y_bar 

> 만약 실제 값이 88이고 추정 값이 85이면 차이가 3 평균이 80이면 평균 차이가 5

> 평균과 추정값의 차이를 SSR (설명 가능한 오차) 

> 실제 값과 추정값의 차이를 SSE (설명 안 되는 오차)  : 왜 오차가 났는지 모름

> SST는 SSR + SSE

 

> 만든 모형이 얼마나 잘 만들었는지 확인할 때 r^2 값도 사용 가능 

> r^2 값이 음수로도 나올 수 있다

 

> 왜 음수가 나올 수 있냐면 모형이 성능이 아주 떨어지면 나올 수 있다.

> 선형 회귀 모형이 평균으로 예측하는 것보다 못할 때 음수가 나온다 

 

> w도 쓰고 베타라고도 표현함

> 1은 바이어스 때문에 넣음 

 

> 목적 함수가 오차 제곱 합 

> y에서 y추정량 뺀 걸 전치하고 곱이 목적함수다

> 목적 함수가 최소화하는 w를 구하는 게 w^ 추정량이다

> 목적 함수가 있으면 제약 조건이 있어야 함

> 이 식에선 제약 조건이 없기 때문에 라그랑주 프리멀 함수가 위의 식이다.

> Solution은 해당 식을 미분해서 0 되는 지점을 찾으면 된다. (컨벡스 최적화 만족)

> 행렬/벡터의 미분은 수학 테크닉이 필요하기에 넘어감 

> 결과식에서 X는 피처의 행렬, y는 target 그래서 가지고 있는 data로 w를 만들 수 있다.

> 공분산 행렬의 det가 0이 되면 안 된다.

> det 0이 아니면 변수들끼리 선형 독립이다. Feature들이 Full Rank여야 한다. 

> Full Rank가 아니어도 선형 회귀 못 쓰는 건 아니다 (Trick 존재) 

> X는 scaling 한 데이터를 넣어야 한다.

 

> 피처들 간 관계가 성립하는 걸 다중공선성 (=선형 종속)

> ML에서 용어만 다르게 가져가고 개념은 같다. 

 

> 피처가 3개 근데 CPU 성능과 전체 성능 관계가 있다 (선형 종속) 

> Corr 하면 높게 나옴 (보통 경우는 좋지만, ML에서 빼야 할 수 있기 때문에) 

> Corr 낮은 게 좋다

> 어떤 걸 빼는지 정할 때 하나씩 넣어보면서 가장 성능이 좋은 케이스의 조합을 선택

> 다 해봐야 돼서 시간이 오래 걸림

> 이런 케이스는 빼던지 다 쓰던지 선택할 수 있는데 이때 차원 축소가 들어감

> 차원 축소를 하려면 Corr 구하던가 카이제곱 검정을 한다 

> 이런 경우는 예측 값이 매우 크게 나온다 (explode 되었다) 

> 이럴 때 제약 조건을 사용해서 explode를 방지한다.

 

 

> 조건을 거는걸 regularization이라고 한다.

> 가장 유명한 2개 L1, L2 regularization (Lasso, Ridge)

> Lasso는 w를 구하고 절댓값의 합이 t 보다 작아야 한다

> Ridge는 w의 제곱합이 t 보다 작아야 한다. 

> 학문계의 한 획을 그은 건 Lasso다 (2000년대 초반) 

> Ridge 범위 안에 들어올 확률이 가장 높은 영역은 오른쪽, 왼쪽 아래이다. 
> Lasso는 꼭짓점에서 많이 걸림

> Lasso의 꼭짓점은 (w1, 0) w2가 없어졌다 즉 피처가 하나 없어져서 차원 축소 효과가 있다.
> 근데 꼭짓점에 걸려야 차원 축소가 되는 거다. (그렇다고 ridge가 별로란 얘기는 아님) 

> t는 도형의 크기

> L1, L2 명칭 이유 : Lp space의 p의 값이다. 

 

 

> 목적 함수와 제한 조건을 표현하면 위와 같다

 

> 목적 함수와 제약 조건이 있기 때문에 라그랑주 프리멀 함수로 표현 가능하다. 

> 람다는 제약 조건의 강도 

 

> 미분에서 0되는 지점을 찾으면 된다. 

> 머신 러닝엔 여러 알고리즘이 있고 그중 선택해서 쓰면 된다. 

 

> 절댓값이기 때문에 미분을 구할 수 없음

> 그래디언트 디센트 방식으로 컴퓨터로 계산하면 된다.

 

> 식으로 표현되면 Closed form이라고 하지만 Lasso는 Closed Form이 없다. 

 

> Lp space의 p 즉 위의 장표에서 q를 가변 해서 제약 조건을 만들 수 있다. 

 

> Lasso, Ridge 둘 다 쓰고 싶으면 둘 다 쓰면 되고 두 가지 이상의 제약 조건을 사용하는걸 elastic net이라고 한다. 

> 1-알파 는제약식의 가중치다. 

> 알파가 1이면, Lasso, 0이면 Ridge 

> elastic net은 Lasso가 closed form 없기 때문에 동일하게 없다 

 

#회귀 분석 Linear Regression 
import pandas as pd
df = pd.read_csv('./data/house_prices.csv', encoding = 'cp949')

features = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
       'PTRATIO', 'B', 'LSTAT']

X = df[features] 
y = df['MEDV']

from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te = train_test_split(X, y, random_state = 0)

from sklearn.preprocessing import StandardScaler 
std_scale = StandardScaler()
std_scale.fit(X_tn)
X_tn_std = std_scale.transform(X_tn) 
X_te_std = std_scale.transform(X_te)

from sklearn.linear_model import LinearRegression
clf_lr = LinearRegression()
clf_lr.fit(X_tn_std, y_tn)

print(clf_lr.coef_)
print(clf_lr.intercept_)

from sklearn.linear_model import Ridge
clf_ridge = Ridge(alpha =1)
clf_ridge.fit(X_tn_std, y_tn)

from sklearn.linear_model import Lasso 
clf_lasso = Lasso(alpha = 0.2) 
clf_lasso.fit(X_tn_std, y_tn)

from sklearn.linear_model import ElasticNet
clf_elastic = ElasticNet(alpha = 0.01, l1_ratio = 0.01)
clf_elastic.fit(X_tn_std, y_tn)

pred_lr = clf_lr.predict(X_te_std)
pred_ridge = clf_ridge.predict(X_te_std)
pred_lasso = clf_lasso.predict(X_te_std)
pred_elastic = clf_elastic.predict(X_te_std)

from sklearn.metrics import r2_score
print(r2_score(y_te, pred_lr))
print(r2_score(y_te, pred_ridge))
print(r2_score(y_te, pred_lasso))
print(r2_score(y_te, pred_elastic))

from sklearn.metrics import mean_squared_error
print(mean_squared_error(y_te, pred_lr))
print(mean_squared_error(y_te, pred_ridge))
print(mean_squared_error(y_te, pred_lasso))
print(mean_squared_error(y_te, pred_elastic))

 

 

> Regression을 하고 나면 계수를 알 수 있다.
> coef는 w, intercept는 b

> coef는 피처 x의 영향도, 클수록 영향이 크다

> coef의 절댓값이 높다고 해당 피처가 가장 중요하다고 말할 수는 없다 (여러 가지 고려 사항이 있다)

> 제약의 정도가 alpha 

> l1 ratio는 lasso의 비율 
> 다른 알고리즘이랑 섞이면 데이터 결과가 잘 안 나올 수 있다. 

> 연속형 데이터는 선형 회귀 분석으로 가능하나 분류는 안 됨

 

> 로지스틱은 구분 그리고 연속형 사용 가능 다, 타깃 범위가 제한이 있다

> x를 변형해서 사용하고 이 함수를 시그모이드 함수라고 한다 

> 그래서 식을 풀면 아래식과 같다

> 확률이기 때문에 파이(x)라고 표현한다 

> 오즈비는 참고 

> 0,1 사이 값이 나온다

 

> 분류는 0.5 기준으로 0, 1로 판단해서 할 수 있다

> 0.5일 때 기울기가 가장 가파르다, 0.5 부근에서 조금만 증가해도 1일 확률이 급격하게 증가한다. 

 

> 이것도 손으로 말고 그레디언트 디센트로 구한다. 

 

df.columns

# feature, target 구분
features = ['Alcohol', 'Malic', 'Ash', 'Alcalinity', 'Magesium', 'Phenols',
       'Flavanoids', 'Nonflavanoids', 'Proanthocyanins', 'Color', 'Hue',
       'Dilution', 'Proline'] 
X = df[features]
y = df['class']

#test data split
from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te = train_test_split(X,y,random_state = 0)

#표준화
from sklearn.preprocessing import StandardScaler 
std_scale = StandardScaler()
std_scale.fit(X_tn)
X_tn_std = std_scale.transform(X_tn)
X_te_std = std_scale.transform(X_te)

# 학습
from sklearn.linear_model import LogisticRegression
clf_logic_l2 = LogisticRegression(penalty = 'l2')
clf_logic_l2.fit(X_tn_std, y_tn) 

print(clf_logic_l2.coef_,'\n') #class 0, 1, 2에 대한 3가지 coef
print(clf_logic_l2.intercept_, '\n') 

#예측
pred_logistic = clf_logic_l2.predict(X_te_std)
print(pred_logistic, '\n')

#에측의 확률
pred_proba = clf_logic_l2.predict_proba(X_te_std)

from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_te, pred_logistic)
print(accuracy, '\n')


from sklearn.metrics import precision_score
precision = precision_score(y_te, pred_logistic, average = 'macro')
print(precision, '\n')

from sklearn.metrics import recall_score
recall = recall_score(y_te, pred_logistic, average = 'micro')
print(recall, '\n')

from sklearn.metrics import f1_score
f1 = f1_score(y_te, pred_logistic, average = 'macro')
print(f1, '\n')

from sklearn.metrics import confusion_matrix
conf_matrix = confusion_matrix(y_te, pred_logistic)
print(conf_matrix, '\n')

from sklearn.metrics import classification_report 
class_report = classification_report(y_te, pred_logistic)
print(class_report)

 

> penalty = l2 나는 건 Ridge 제약식을 넣었다는 뜻

> intercept가 3개이면 class 별로 나옴

> 구분도 가능하고 확률로 예측할 수 있다. 

> pred_proba의 열 순서대로 0,1,2 일 확률 

> 시그모이드 함수는 0, 1을 분류하는 함수
> 역기서 말하는 확률은 시그모이드가 (이진분류)가 아니고 소프트 맥스 (다중분류)이다.

 

 

> Linear Regression에서 r square 보다 MSE를 더 많이 씀

> Logistic Regression은 범주형일 때 사용

 

> 배드민턴 치는지 안 치는지의 데이터 

 

> 나이브 베이즈에서 피처는 조건부 독립 

> 독립은 두 사건이 일어날 확률이 각각의 사건을 곱과 같다 (선형 독립이랑은 다르다) 

> P(X1, X2/Y)는 P(X1 교집합 X2 / Y)로 고쳐 쓸 수 있다. (comma를 교집합으로 바꿀 수 있다) 

> 타깃이 주어졌을 때 피쳐 X1, X2가 독립이다라는 뜻

> 예) 배드민턴 치냐 안치냐 주어졌을 때 날씨, 온도는 독립이다라는 가정

> 날씨와 온도는 관계가 있겠지만 naive 하게 독립이라고 치자 라는 게 나이브 베이즈

> 이렇게 해도 되는 이유는 결과가 잘 나와서 (계산이 복잡한 것도 있음)

> 피쳐가 많으니깐 날씨랑 타깃만 고려 

 

> crosstab으로 그릴 수 있다

> 그린 후 확률을 구할 수 있음 

 

> 바람이 추가되면 

 

> 조건부 독립이라고 가정했기 때문에 crosstab을 붙이면 된다 

 

> 모든 피쳐 반영 

 

> 네, 아니오를 구분을 조건부 확률로 구분한다 

> 베이즈 정리를 활용해서 확률을 계산한다 

 

> 분자에 조건부 독립을 다 곱하고 분모는 scaler로 무시 

> 나이브 베이즈의 종류가 많다 (가우시안)

> GaussianNB는 가우시안 분포로 NB 구함, Complement, Bernoulii, 다항분포 NB 등등

from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te = train_test_split(X,y, random_state=0)

from sklearn.preprocessing import StandardScaler
std_scale = StandardScaler()
std_scale.fit(X_tn) 

X_tn_std = std_scale.transform(X_tn)
X_te_std = std_scale.transform(X_te)

from sklearn.naive_bayes import GaussianNB
clf_gnb = GaussianNB()
clf_gnb.fit(X_tn_std, y_tn)

pred_gnb = clf_gnb.predict(X_te_std)
print(pred_gnb)

 

from sklearn.metrics import accuracy_score
a = accuracy_score(y_te, pred_gnb)
print(a, '\n')

from sklearn.metrics import recall_score
r = recall_score(y_te, pred_gnb, average = 'macro')
print(r, '\n')

from sklearn.metrics import precision_score
p = precision_score(y_te, pred_gnb, average = 'macro')
print(p, '\n')

from sklearn.metrics import f1_score
f = f1_score(y_te, pred_gnb, average = 'macro')
print(f)

from sklearn.metrics import confusion_matrix
c_m = confusion_matrix(y_te, pred_gnb)
print(c_m)

from sklearn.metrics import classification_report 
c_r = classification_report(y_te, pred_gnb)
print(c_r)

 

> 나이브 베이즈는 분류만 가능하고 예측이 안 됨 

 

> 의사결정 나무 Decision Tree (쉬워서 유명한 방법) 

> 수학이 안 들어감 

> 의사결정이 가능하게 나무를 만듦

> 덩어리 하다를 노드(node)라고 함 

 

 

> 위의 노드를 root node, 밑은 leaf node라고 함

 

> 테스트 한 번한 모델이 좋음

> 나무가 작을수록 좋음 

 

> 개별 성능이 가장 좋은 것이 위로 올라감 

> 날씨 피쳐로 해보면 맑음에서 애매함
> 분리가 잘 되었을 때 1점이라고 하면 4점이다.

> 강함에 아니오가 잘 분류되어 3점 

> 습도는 테스트는 0 점

> 날씨가 점수가 높기 때문에 첫 번째 root로 올라감 (첫 번째 test가 됨) 

 

> 날씨가 맑음에서 애매하기 때문에 맑음만 모아서 추가 테스트를 함

 

> 바람이 좋기 때문에 2 번째로 붙임

> 장점은 쉽다, 단점은 오버 피팅이다

> 이 데이터에서만 맞아서 새로운 데이터를 잘 맞추진 못하여 순정 보단 변형된 모델을 활용한다

 

> 엔트로피 : 무질서의 정도

 

> y는 타깃이고 타깃이 k이면 1이고 아니면 0인 지시함수를 다 더하고 개수 n으로 나눈다 (=확률)

> H(Qm)이 엔트로피다 

 

> 예) 후라이드가 0, 양념도 0인데 반반이면 엔트로피가 최고 높다 (1/2 일 때)

 

 

> 엔트로피 구해보기

 

> 지니 계수도 있다, ML 돌릴 때 엔트로피나 지니계수로 변경해서 사용할 수 있다 

 

> 피쳐가 연속형의 데이터일 경우 숫자에 대해서 모든 나무를 다 그린다. 

> 수학보단 컴퓨터의 연산 처리 능력에 좌우되는 알고리즘이다. 

 

> 타깃이 연속형일 경우 평균을 구해서 예측한다 (kNN처럼)

> regression 계열의 알고리즘은 corr 직선처럼, tree 계열은 discrete 하게 표현됨

 

 

from sklearn import tree
clf_tree = tree.DecisionTreeClassifier(random_state = 0)
clf_tree.fit(X_tn_std, y_tn)

pred_tree = clf_tree.predict(X_te_std)
print(pred_tree)

from sklearn.metrics import confusion_matrix 
c_m = confusion_matrix(y_te, pred_tree)
print(c_m)

from sklearn.metrics import classification_report 
print(classification_report(y_te, pred_tree))

df1 = pd.read_csv('./data/house_prices.csv', encoding = 'cp949')

df1.columns

X = df1[['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
       'PTRATIO', 'B', 'LSTAT']]
y = df1['MEDV']

from sklearn.model_selection import train_test_split 
X_tn, X_te, y_tn, y_te = train_test_split(X, y , random_state=0)

from sklearn.preprocessing import StandardScaler 
std_scaler = StandardScaler()
std_scaler.fit(X_tn) 

X_tn_std = std_scaler.transform(X_tn)
X_te_std = std_scaler.transform(X_te)

from sklearn.tree import DecisionTreeRegressor 
clf_tree = DecisionTreeRegressor(random_state =0)
clf_tree.fit(X_tn_std, y_tn)

tree_pred = clf_tree.predict(X_te_std)

from sklearn.metrics import mean_squared_error
print(mean_squared_error(y_te,tree_pred))

 

> tree.Decision에서 random_state가 0은 무작윌 뽑는 걸 일정하게 해서 모델을 다시 실행해도 항상 동일한 학습/테스트 데이터 분할과 예측 결과를 얻게 하기 위함

> 분류 Classifier, 예측 Regressor 둘 다 가능 

 

> 서포트 벡터 머신 예전에 인기 많았었음 (왜냐하면 이름이 멋있음)
> 수학이 많이 들어감 (좀 어려움)

> 수학이 많이 들어갈수록 잘될 거라고 기대가 있다

> 개념은 보조선(서포트 벡터)을 추가해서 보조선 안 으로 안 들어오게 하는 것.

> 보조선 범위가 좁으면 구분하기가 애매해질 수 있다 그래서 넓은 범위가 좋다 (도로가 넓히게 좋다)

> 보조선을 그리는 방법으로 내적을 활용한다 

 

 

 

 

> 내적을해 서 특정 c 값 기준으로 밖으로 튀어나가면 +, 안나가면 -

> 저 보조선들이 hyper plane이고 hyper plane으로 나눠지는 공간을 half space다.

 

> 우변이 c를 0으로 표현하고 싶어서 좌변으로 옮기고 부호를 바꿔서 b로 표현 가능

> wx + b (Deep learning)에도 많이 나옴

> 0보다 크면 노란 영역

> 0인지 아닌지 판단을 하게 되는데 이를 Decision Rule이라고 한다 

 

> 0이 기준으면 보조선 안에도 포함되기 때문에 도로 너비를 1이라고 가정해서 -1, 0, 1 사이의 조건으로 구분한다

> Deicison Rule이 2개가 된다 

 

> Decision Rule이 2개인걸 안 좋아하기 때문에 하나의 식으로 표현한다

> 1은 계산 쉽게하기 위해서 

 

> 도로를 최대한 넓게 만들어서 최대한 분리를 잘해야 한다. 

> w를 normalization을 하고 서포트 벡터의 거리를 곱하면 너비가 된다

> 최대화하는 것이 목적이기 때문에 최대화 함수는 목적 함수이다. 

 

> 결국 목적 함수인 너비는 w의 크기를 최소화하는 값을 찾아야한다. 

> 2는 scaler로 크게 의미 없어서 무시함

> 1/2 norm(w)^2 로 표현하는 이유는 라그랑주 프리멀 함수에서 미분하기 좋기 때문

> 위처럼 내적으로 표현이 가능하다. 

 

 

> 목적 함수가 벡터 자신을 내적 하고 최솟값이 된다.

 

> 이걸 하나의 식으로 표현하면 다음과 같다. 

 

 

> 미분해서 0되는 지점 찾으면 된다. 

> 서포트 벡터 머신이 직선이 리니어 모양에만 국한되지 않는다. 

> sklearn에서 옵션을 변경하면 가능하고 자기 자신 내적이 다른 걸로 변경되는 것이다.

 

from sklearn.model_selection import train_test_split
X_tn, X_te, y_tn, y_te = train_test_split(X, y, random_state =0)

from sklearn.preprocessing import StandardScaler 
std_scaler = StandardScaler()
std_scaler.fit(X_tn)

X_tn_std = std_scaler.transform(X_tn) 
X_te_std = std_scaler.transform(X_te)

from sklearn import svm
clf_svm_lr = svm.SVC(kernel = 'linear')
clf_svm_lr.fit(X_tn_std, y_tn)

pred_svm = clf_svm_lr.predict(X_te_std)

from sklearn.metrics import classification_report 
print(classification_report(y_te, pred_svm))

 

 

> kernel 옵션이 바뀌면 서포트 벡터 머신이 바뀐다 (곡선, 원형 등등) 

 

> 서포트 벡터 범위 안에 몇 개의 데이터가 포함되는 것을 허용하는 것을 소프트 마진이라고 한다.

> 한 개도 들어오지 않는 조건은 하드 마진 이라고 한다. 

 

> 회귀 분석은 서포트 벡터 안으로 들어오는 것의 초평면을 찾는 것이 목적

> 서포트 벡터 밖으로 나가는 것들은 Loss이고 이를 입실론-intensive 손실이라고 한다. 

> 밖으로 나가면 Loss가 올라간다. 

 

from sklearn.svm import SVR
clf_svm_lr = SVR(kernel = 'linear')
clf_svm_lr.fit(X_tn_std, y_tn)

svm_pred = clf_svm_lr.predict(X_te_std)

from sklearn.metrics import mean_squared_error 
mse = mean_squared_error(y_te, svm_pred)
print(mse)

 

Ref : https://losskatsu.github.io/categories/#