import joblib
'''
훈련모델 저장하기
- 파일 확장자는 자유롭게
'''
joblib.dump(rf, "./model/rf_model_joblib.md")
''' 모델 파일 불러들이기 '''
joblib_model = joblib.load("./model/rf_model_joblib.md")
joblib_model
joblib_model.predict(test_input)
pickle 방식
import pickle
'''
훈련모델 저장하기
- wb : w는 쓰기, b는 바이너리 => 바이너리 형태로 쓰기
'''
with open("./model/rf_model_pickle.md", "wb") as fw :
pickle.dump(rf, fw)
'''
모델 파일 불러오기
- rb : r는 읽기, b는 바이너리 => 바이너리 형태의 파일 내용 읽기
'''
with open ("./model/rf_model_pickle.md", "rb") as f :
load_pickle_model = pickle.load(f)
load_pickle_model
군집할 갯수는 종속변수의 범주의 갯수와 동일함(이미 종속변수를 알고 있는 경우도 있고, 아닌 경우도 있음)
군집의 갯수를 이미 알고 있는 경우에는 직접 갯수 정의, 모르는 경우에는 하이퍼파라미터 튜닝을 통해 적절한 갯수 선정
🖍️작동방식
데이터들을 이용해서 무작위로 K개의 클러스터 중심을 정함
각 샘플에서 가장 가까운 클러스터 중심을 찾아서 해당 클러스터의 샘플로 지정
특정 클러스터에 속한 "샘플들의 평균값"으로 클러스터 중심을 변경
클러스터 중심에 변화가 없을 때까지 2번 ~ 3번을 반복 수행하게 되는 모델임
사용할 라이브러리
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score, confusion_matrix
''' KMeans 군집 모델 '''
from sklearn.cluster import KMeans
사용할 데이터 셋 - 와인데이터
'''
- 데이터 불러오기 : 변수명 data
- 독립변수와 종속변수로 나누기 : 변수명은 X, y
'''
data = pd.read_csv("./data/08_wine.csv")
X = data.iloc[:,:-1]
y = data["class"]
X.shape, y.shape
from sklearn.cluster import KMeans
'''
군집분석 평가 방법 : 실루엣 score로 평가함
- 값의 범위 : -1 ~ 1 사이의 값
- -1에 가까울 경우 : 군집 분류가 잘 안된 경우
- 0에 가까울 경우 : 이도 저도 아닌 상태()
- 1에 가까울 경우 : 군집이 잘 된 경우
'''
from sklearn.metrics import silhouette_score
''' Iris(붓꽃) 데이터셋 라이브러리 '''
from sklearn.datasets import load_iris
import seaborn as sns
Iris 데이터 읽어들이기
iris = load_iris()
iris
특성 설명
- sepal length : 꽃받침 길이 - sepal width : 꽃받침 너비 - petal length : 꽃잎 길이 - petal width : 꽃잎 너비
분석 주제 - 4가지 독립변수 특성을 이용하여 붓꽃의 품종 종류별로 군집(클러스터) 분류하기
독립변수와 종속변수 데이터 추출하기
'''
독립변수명 : X
종속변수명 : y
'''
X = iris.data
y = iris.target
X.shape, y.shape
군집 모델 생성 / 훈련 및 예측
'''
- 군집분류에서는 별도로 훈련과 검증데이터로 분류하기 않고, 전체 데이터를 사용하여 군집합니다.
'''
'''
* 군집모델 생성하기
- 군집 갯수 지정
- n_init : 초기 중심점 설정 횟수는 10으로 설정
- 랜덤 규칙 : 42번
'''
kmeans_model = KMeans(n_clusters=3, n_init=10, random_state=42)
kmeans_model
'''
- 모델 훈련 및 군집하기(예측)
- 군집분석에서는 훈련과 동시에 예측이 수행 됨
'''
kmeans_labels = kmeans_model.fit_predict(X)
print(kmeans_labels)
print(y)
군집결과 시각화하기
주성분분석(PCA)을 통해 시각화하기
주성분분석(PCA) → 훈련에 사용된 특성들 중에 특징을 가장 잘 나타낼 수 있는 특성을 추출하는 방식 → 특성을 추출하여 특성을 축소시키는 방식으로 "차원축소"라고 칭한다. → 주요 성분의 특성만을 사용하기 때문에 빠른 성능을 나타냄
''' 데이터 처리 '''
import pandas as pd
''' 데이터 분류 '''
from sklearn.model_selection import train_test_split
''' 하이퍼파라미터 튜닝 '''
from sklearn.model_selection import GridSearchCV
''' 사용할 분류모델들 '''
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import HistGradientBoostingClassifier
from xgboost import XGBClassifier
''' 데이터 스케일링 : 정규화 '''
from sklearn.preprocessing import StandardScaler
''' 평가 '''
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
''' 오차행렬(혼동행렬) '''
from sklearn.metrics import confusion_matrix
from sklearn.metrics import ConfusionMatrixDisplay
데이터 셋
data = pd.read_csv("./data/08_wine.csv")
data.info()
data.describe()
데이터프레임에서 독립변수와 종속변수로 데이터 분리하기
'''
사용할 변수
- 독립변수 : X
- 종속변수 : y
'''
# X = data[["alcohol", "sugar", "pH"]]
X = data.iloc[:,:-1]
y = data["class"]
X, y
정규화
'''
사용할 변수
- 독립변수 정규화 : X_scaled
'''
ss = StandardScaler()
ss.fit(X)
X_scaled = ss.transform(X)
X_scaled
''' 모델 이름을 리스트 변수에 담기 '''
model_name = [rf_model.__class__.__name__,
et_model.__class__.__name__,
gd_model.__class__.__name__,
hg_model.__class__.__name__,
xgb_model.__class__.__name__]
model_name
GridSearchCV를 위한 하이퍼파라미터 매개변수 정의
n_estimators() - 트리의 갯수를 의미함 - 트리의 갯수를 늘리게 되면 모델의 복잡성이 증가됨 - 과적합을 방지하고 더 좋은 성능을 낼 수 있음 - 설정값 : 제한은 없으나, 50, 100 ~ 1000 사이의 값을 주로 사용 - rf, xt, gb, xgb에서 사용가능 - hg에서는 max_iter() 함수를 사용함
max_depth() - 각 트리의 최대 깊이를 의미함(root 노드는 제외) - 트리의 최대 깊이가 길어질 수록 모델의 복잡성이 증가함 - 설정값 : 제한 없음, 주로 None ~ 50 사이의 값이 주로 사용됨 - 모든 모델 사용가능
min_samples_split() - 노드를 분할하기 위한 최소한의 갯수를 의미함 - 설정값: 제한없음, 2 ~ 10 사이의 값이 주로 사용됨 - rf, xt, gb 모델만 사용가능
min_samples_leaf() - 리프 노드 (결정노드)의 최소한의 샘플 수를 의미함 - 설정값 : 제한없음, 1 ~ 10 사이의 값이 주로 사용됨 - rf, xt, gb, hg 모델 사용가능 - xgb 모델은 min_child_weight() 함수 사용
분류 모델 평가 방법 - 정확도, 정밀도, 재현율, F1-score 값을 이용해서 평가함 - 예측에 오류가 있는지 확인 : 오차행렬도(혼동행렬도)를 통해 확인
평가 기준 - 정확도를 이용하여 과적합 여부 확인(이미 위에서 실행함) - 재현율이 높고, F1-score 값이 높은 값을 가지는 모델을 선정하게 됨 - 정확도, 정밀도, 재현율, F1-score의 모든 값은 0~1 사이의 값을 가지며, 값이 높을 수록 좋다. - 재현율을 가장 중요시 여긴다.
성능 평가에 시각화 자료 사용
''' 시각화 라이브러리 정의하기 '''
import matplotlib.pyplot as plt
import seaborn as sns
''' 한글처리 '''
plt.rc("font", family = "Malgun Gothic")
''' 마이너스 기호 처리 '''
plt.rcParams["axes.unicode_minus"] = True
import numpy as np
''' 오차행렬 계산 라이브러리 '''
from sklearn.metrics import confusion_matrix
''' 오차행렬도 시각화 라이브러리 '''
from sklearn.metrics import ConfusionMatrixDisplay
오차행렬도 그리기
''' 오차행렬의 기준 특성은 종속변수 기준 '''
''' 훈련에서 사용한 종속변수의 범주 확인하기 '''
rf.classes_
''' 오차행렬 평가 매트릭스 추출하기 '''
cm = confusion_matrix(test_target, y_pred, labels=rf.classes_)
''' 오차행렬도 시각화 하기 '''
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
display_labels=rf.classes_)
disp.plot()
TN (0, 0) 실제 0인 값을 0으로 예측 > 참 FP (0, 1) 실제 0인 값을 1로 예측 > 긍정적 오류 FN (1, 0) 실제 1인 값을 0으로 예측 > 부정적 오류 : 해당 값이 많을 수록 사용할 수 없는 모델이 된다. TP (1, 1) 실제 1인 값을 1로 예측 > 참
<오차행렬(혼동행렬)> - 어떠한 유형의 오류가 발생하고 있는지를 나타내는 값 - 이를 시각화한 것을 오차행렬도 또는 혼동행렬도라고 칭함 - 정확도(score)의 값과 오차행렬도의 시각화 결과로 최종 모델을 선정한다.
정규화 : StandardScaler→ 분류 또는 회귀에서 사용가능하며, 주로 분류에서 사용됨
정규화 :RobustScaler → 분류 및 회귀 모두 사용가능
표준화 : MinMaxScaler→ 분류 또는 회귀에서 사용가능 하며, 주로 회귀에서 사용됨(최대 및 최소 범위 내에서 처리되는 방식)
1. 정규화 : StandardScaler
'''
훈련데이터 정규화 변수 : train_std_scaler
테스트데이터 정규화 변수 : test_std_scaler
'''
from sklearn.preprocessing import StandardScaler
''' 정규화 클래스 생성하기 '''
ss = StandardScaler()
''' 정규화 패턴 찾기 : 훈련데이터만 사용 '''
ss.fit(train_input)
''' 훈련 및 테스트 독립변수 변환하기 '''
train_std_scaler = ss.transform(train_input)
test_std_scaler = ss. transform(test_input)
train_std_scaler.shape, test_std_scaler.shape
2. 정규화 :RobustScaler
'''
훈련데이터 정규화 변수 : train_rbs_scaler
테스트데이터 정규화 변수 : test_rbs_scaler
'''
from sklearn.preprocessing import RobustScaler
''' 정규화 클래스 생성하기 '''
rbs = RobustScaler()
''' 정규화 패턴 찾기 : 훈련데이터만 사용 '''
rbs.fit(train_input)
''' 훈련 및 테스트 독립변수 변환하기 '''
train_rbs_scaler = rbs.transform(train_input)
test_rbs_scaler = rbs. transform(test_input)
train_rbs_scaler.shape, test_rbs_scaler.shape
3.표준화 : MinMaxScaler
'''
훈련데이터 표준화 변수 : train_mm_scaler
테스트데이터 표준화 변수 : test_mm_scaler
'''
from sklearn.preprocessing import MinMaxScaler
''' 표준화 클래스 생성하기 '''
mm = MinMaxScaler()
''' 표준화 패턴 찾기 : 훈련데이터만 사용 '''
mm.fit(train_input)
''' 훈련 및 테스트 독립변수 변환하기 '''
train_mm_scaler = mm.transform(train_input)
test_mm_scaler = mm. transform(test_input)
train_mm_scaler.shape, test_mm_scaler.shape
🍇 훈련하기
''' 훈련모델 생성하기 '''
from sklearn.ensemble import RandomForestClassifier
''' 모델(클래스) 생성하기
- cpu의 코어는 모두 사용, 랜덤값은 42번을 사용하여 생성하기
- 모델 변수의 이름은 rf 사용
'''
rf = RandomForestClassifier(random_state=42, n_jobs=-1)
''' 모델 훈련 시키기 '''
rf.fit(train_std_scaler, train_target)
''' 훈련 및 검증(테스트) 정확도(score) 확인하기 '''
train_score = rf.score(train_std_scaler, train_target)
test_score = rf.score(test_std_scaler, test_target)
print(f"훈련 = {train_score} / 검증 = {test_score}")
### 모델 라이브러리 불러들이기
from sklearn.linear_model import LinearRegression
### 사용할 데이터
train_input, train_target, test_input, test_target
### 모델(클래스 생성하기)
lr = LinearRegression()
### 모델 훈련 시키기
lr.fit(train_input, train_target)
### 훈련 정확도
train_r2 = lr.score(train_input, train_target)
### 테스트(검증) 정확도
test_r2 = lr.score(test_input, test_target)
print(f"훈련={train_r2} / 테스트={test_r2}")
### (해석)
# - 결정계수 확인 결과, 훈련 결정계수 > 테스트 결정계수이므로 과소적합은 일어나지 않았으나,
# - 두 계수의 차이가 0.12로 과대적합이 의심됨
- 임의 값 예측 시 KNN보다는 성능이 좋은 예측이 가능하며, 과적합이 발생하지 않는 일반화된 모델로 보여지나, y절편의 값이 음수로 예측시 음수의 데이터가 예측 될 가능성이 있는 모델로 보여짐 - 종속변수 무게의 값은 0이하로 나올 수 없기에 이상치를 예측할 수 있는 모델로 현재 사용하는 데이터를 예측하기에는 부적합한 모델로 여겨짐
🧁 다항회귀모델
데이터의 분포가 선형이면서 곡선을 띄는 경우에 사용됨
곡선(포물선)의 방정식이 적용되어 있음
y = (a * x^2) + (b * x) +c
독립변수는 2개가 사용됨 : x^2값과 x값
🧁 훈련 및 테스트데이터의 독립변수에 x^2값 추가하기
# - 훈련 독립변수
train_poly = np.column_stack((train_input**2, train_input))
# - 테스트 독립변수
test_poly = np.column_stack((test_input**2, test_input))
train_poly.shape, test_poly.shape
🧁 모델 훈련 및 예측
### 모델 생성하기
# - 선형, 다형, 다중 회귀모델은 하나의 모델(클래스) 사용
# - 직선, 곡선에 대한 구분은 독립변수의 갯수로 모델이 알아서 구분해준다.
lr = LinearRegression()
### 모델 훈련 시키기
lr.fit(train_poly, train_target)
### 훈련 정확도 확인하기
train_r2 = lr.score(train_poly, train_target)
### 테스트 정확도 확인하기
test_r2 = lr.score(test_poly, test_target)
### 과적합 여부 확인(해석)
# - 0.007 정도의 과소적합(훈련 < 검증)이 발생
print(f"훈련 결정계수 = {train_r2} / 테스트 결정계수 = {test_r2}")
### 임의 값 길이 50으로 예측하기
pred = lr.predict([[50**2, 50]])
print(f"길이 50 예측 결과 : {pred}")
🧁 추세선 그리기
추세선을 그리기 위해서는 곡선의 방정식에 사용할 계수 a,b와 절편 c를 알아야 함
print(f"계수 = {lr.coef_} / 절편 = {lr.intercept_}")
a = lr.coef_[0]
b = lr.coef_[1]
c = lr.intercept_
print(f"a = {a} / b = {b} / c = {c}")
plt.scatter(train_input, train_target)
plt.scatter(50, pred[0], marker='^')
# 추세선
# - 추세선이 사용할 x축값 지정(0~50까지의 순차적인 값 사용)
point = np.arange(0, 51)
plt.plot(point, a*point**2 + b*point + c)
plt.grid()
plt.show()
해석 - 선형회귀모델의 경우에는 음의 절편값이 나타나는 모델이었으나, 다항회귀모델의 경우에는 이를 해소할 수 있었음 - 단, 길이(x)가 10이하의 독립변수는 사용하면 안됨 - 다항회귀모델의 훈련 및 테스트 결정계수의 결과 미세한 과소적합을 보이고 있으나, 사용가능한 모델로 판단됨 - 선형회귀모델에 비하여 독립변수들이 전체적으로 추세선에 가깝게 위치하고 있기에 오차가 적은 모델이라고 분석 됨
🧁 과소 / 과대 적합을 해소하기 위한 방법
데이터 양(row 데이터, 행)을 늘릴 수 있는지 확인
분석 모델이 좀 더 집중해서 훈련할 수 있도록 특성(독립변수)을 추가하는 방법 확인 → 특성을 추가(늘리는)하는 방법은 "특성공학" 개념을 적용 → 특성을 늘려서 사용하는 모델로 다중회귀모델이 있음 → 특성을 늘린다는 의미는 훈련의 복잡도를 증가시킨다고 표현하며, 복잡도가 증가되면, 훈련의 집중력이 강해지게 됨
복잡도를 늘리는 방법으로는 "규제" 방법이 있음 → "규제"를 하는 하이퍼파라미터 속성을 이용하는 방식으로 릿지와 라쏘 회귀모델 방식이 있음
이외 다른 회귀모델을 사용하여 비교
특성 → 컬럼, 필드, 퓨처 모두 같은 의미
데이터 처리 분야에서는 컬럼 또는 필드라고 칭하며, 머신러닝에서는 특성이라고 칭하며, 딥러닝에서는 퓨처라고 칭함
💎 다중회귀모델(Multiple Regression)
여러개의 특성을 사용한 회귀모델
특성이 많을수록 복잡도가 증가됨(훈련 시간이 오래걸림, 시스템 성능에 따라 빠를 수도 있음)
다중회귀모델 공식 y = a*x1 + b*x2 + c*x3 + ... + y절편 (x의 값은 3개 이상)
💎 데이터 불러들이기
사용할 데이터프레임 변수
import pandas as pd
df = pd.read_csv("./data/03_농어의_길이_높이_두께_데이터.csv")
💎 농어의 길이, 두께 높이 값을 이용해서 무게 예측하기
독립변수 : 길이, 두께, 높이
종속변수 : 무게
독립변수 생성하기 → 데이터프레임의 특성 중에 독립변수로 사용할 특성들을 2차원의 리스트 또는 배열 형태로 만들어아야 한다. → to_numpy() : 행렬 데이터 형태를 리스트 배열 형태로 바꿈
from sklearn.linear_model import LinearRegression
### 모델 생성하기
lr = LinearRegression()
### 모델 훈련시키기
lr.fit(train_input, train_target)
### 훈련 정확도 및 검증(테스트) 정확도 확인하기
train_r2 = lr.score(train_input, train_target)
test_r2 = lr.score(test_input, test_target)
print(f"훈련 = {train_r2} / 테스트 = {test_r2}")
과적합 여부 판단하기 - 훈련과 검증(테스트) 결정계수의 결과로 볼 때 과소적합은 발행하지 않았다. 또한, 0.07 ~ 0.08 정도로 과대적합 또한 일어나지 않은 일반화 된 모델로 볼 수 있음 - 다만, 검증(테스트) 정확도가 0.8대에서 0.9대로 올릴 수 없을지 고민해 본다. - 특성공학을 적용하여 특성 늘리는 방법으로 집중도를 강화하는 방식을 사용해서 성능 향상이 되는지 확인한다.
특성을 생성하는 라이브러리 - 사용 패키지 : sklearn.preprocessing - 사용 클래스 : PolynomialFeatures(변환기라고 보통 칭한다) - 사용 함수 : fit(훈련 독립변수에서 생성할 특성의 패턴 찾기), transform(찾은 패턴으로 특성 생성하기) - 종속변수는 사용되지 않는다.
💎 테스트 데이터로 예측하기
test_pred = lr.predict(test_input)
test_pred
💎 평균절대오차(MAE) 확인하기
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(test_target, test_pred)
mae
💎 특성공학
💎 특성공학 적용하기
패키지 정의하기
from sklearn.preprocessing import PolynomialFeatures
클래스 생성하기 - 특성을 생성 시킬 때 y절편값도 생성을 함께 시킨다. - 특성만 있으면 되기 때문에 y절편은 생성에서 제외시키기 위해서 include_bias(y절편) = False로 설정한다.
poly = PolynomialFeatures(include_bias = False)
sample 데이터로 어떤 특성들이 만들어지는지 확인하기
temp_data = [[2, 3, 4]]
temp_data
특성을 만들 패턴 찾기
poly.fit(temp_data)
찾은 패턴으로 특성 생성하기
poly.transform(temp_data)
💎 실제 독립변수를 이용해서 특성 생성하기
클래스 생성하기
degree = 2 - 차원을 의미하며 2는 제곱승을 의미함 - 3을 넣으면 2의 제곱, 3의 제곱을 수행 - 4를 넣으면 2의 제곱, 3의제곱, 4의 제곱승을 수행함 - 기본값은 2 (생략하면 2의 제곱승이 적용됨)
### 훈련 독립변수에 특성 추가하기
train_poly = poly.transform(train_input)
### 테스트 독립변수에 특성 추가하기
test_poly = poly.transform(test_input)
train_poly.shape, test_poly.shape
사용된 패턴 확인하기
poly.get_feature_names_out()
💎 모델 생성 / 훈련 / 예측 / 평가
### 모델 생성하기
lr = LinearRegression()
### 모델 훈련시키기
lr.fit(train_poly, train_target)
### 훈련 정확도 및 검증(테스트) 정확도 확인하기
train_r2 = lr.score(train_poly, train_target)
test_r2 = lr.score(test_poly, test_target)
### 예측 하기
test_pred = lr.predict(test_poly)
### 모델 평가하기(MAE)
mae = mean_absolute_error(test_target, test_pred)
print(f"훈련 = {train_r2} / 테스트 = {test_r2} / 오차 = {mae}")
해석 - 특성공학을 적용하지 않은 모델은 검증(테스트) 정확도가 다소 낮았으며, 오차가 50g 정도 있으나- 특성공학을 적용하여 특성을 추가하여 훈련 집중도를 높였을 때는 훈련 및 검증(테스트) 정확도 모두 높아졌으며, 과적합이 발생하지 않은 일반화 모델로 오차는 30g정도의 매우 우수한 모델로 판단 됨 - 이 모델을 사용하려면, 독립변수의 특성 길이, 높이, 두께 3개의 특성을 사용해야 하고 특성 생성 시 degree 2를 적용한 특성을 사용해야 함
💎규제
💎 규제
과대 또는 과소 적합 중에 주로 과대적합이 발생 했을 때 사용된다.
훈련의 정확도가 다소 낮아지는 경향이 있으나. 검증(테스트) 정확도를 높이는 효과가 있음
훈련모델을 일반화하는데 주로 사용되는 방법임
규제 개념을 적용한 향상된 모델 : 릿지(Ridge)와 라쏘(Lasso)가 있다.
💎 규제 순서
정규화(단위(스케일)을 표준화 시키는 방식)
규제가 적용된 모델 훈련 / 검증
💎 훈련 및 테스트 독립변수 정규화 하기
정규화를 위한 라이브러리
from sklearn.preprocessing import StandardScaler
정규화 순서 1. 정규화 클래스 생성 2. fit() : 정규화 패턴 찾기(훈련 독립변수 사용) 3. transform() : 찾은 패턴으로 정규화 데이터로 변환(훈련 및 테스트 독립변수 변환)
''' 1. 정규화 클래스 생성 '''
ss = StandardScaler()
''' 2. 정규화 패턴 찾기 '''
ss.fit(train_poly)
''' 3. 찾은 패턴으로 훈련 및 테스트 독립변수 변환 생성하기 '''
train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)
print(f"{train_scaled.shape} / {test_scaled.shape}")
릿지(Ridge) 모델
from sklearn.linear_model import Ridge
''' 모델 생성하기'''
ridge = Ridge()
''' 모델 훈련시키기 '''
ridge.fit(train_scaled, train_target)
''' 훈련 및 검증(테스트) 정확도 확인하기 '''
train_r2 = ridge.score(train_scaled, train_target)
test_r2 = ridge.score(test_scaled, test_target)
train_r2, test_r2
해석 - 과적합 여부를 확인한 결과, 과소적합은 발생하지 않았으며- 기존 특성공학을 적용한 우수한 모델보다는 훈련 정확도는 0.005정도 낮아 졌지만 검증(테스트) 정확도는 0.013 정도 높아졌음 - 또한, 평균절대오차(MAE)도 1g 낮아졌음 - 따라서, 일반화되고, 오차가 적은 Ridge 모델은 매우 우수한 모델로 판단됨
라쏘(Lasso) 모델
### 사용할 패키지
from sklearn.linear_model import Lasso
### 모델 생성하기
lasso = Lasso()
''' 모델 훈련시키기 '''
lasso.fit(train_scaled, train_target)
''' 훈련 및 검증(테스트) 정확도 확인하기 '''
train_r2 = lasso.score(train_scaled, train_target)
test_r2 = lasso.score(test_scaled, test_target)
train_r2, test_r2
