ANMIAN

회귀(Regression) : class중 하로 분류하는 것이 아니라 임의의 어떤 숫자를 예측하는 문제

k-최근접 이웃 분류 Vs 회귀

분류 : 최근접 이웃 중에 가장 많은 class와 같은 것으로 분류

회귀 : 최근접 이웃의 평균으로 목표 숫자 예측

결정계수(R^2) : coefficient of determination

회귀 모델에서 예측의 적합도를 0과 1 사이의 값으로 계산, 1에 가까울수도 완벽

R^2 = 1 - (타깃 - 예측)^2 / (타깃 - 평균)^2

과대적합(Overfitting) Vs 과소적합(Underfitting)

과대적합은 훈련세트에 너무 심하게 맞춰져 있어 test점수가 낮아지는 현상

과소적합은 훈련세트에 제대로 맞지 않아 훈련세트/테스트세트 둘다 점수가 낮거나 심하면 테스트세트보다 훈련테스의 점수가 낮음

선형회귀 : Linear regression

직선을 학습하는 회귀 알고리즘

가중치(or 계수) : weight(or Coefficient)

선형 회귀가 학습한 직선의 기울기

다중 회귀 : Multiple regression

여러 개의 특성을 사용한 선형 회귀(다차원 그래프가 만들어진다)

transforemer(변환기)

사이킷런의 전처리용 class : 특성을 만들거나 target data없이 input data를 변환

릿지 회귀(Ridge regression)

규제가 있는 선형 회귀 모델 중 하나, alpha로 규제의 강도 조절, alpha가 클수록 규제 강도가 세짐(클수록 과대적합의 가능성 커짐)

라쏘회귀(Lasso regression)

릿지와 달리 계수 값을 아예 0으로 만들 수도 있음

Hyperparameter

머신러닝 모델이 학습할 수 없고 사람이 지정하는 파라미터

로지스틱 회귀(Logistic regression) : 선형 방정식을 사용한 분류 알고리즘, 선형회귀와 달리 sigmoid/softmax function을 사용하여 class 확률을 출력 가능

다중 분류 : target class가 2개 이상인 분류

Sigmoid function : 선형방정식의 출력을 0과 1 사이의 값으로 압축하여 이진 분류를 위해 사용

Softmax : 다중 분류에서 여러 선형 방정식의 출력 결과를 정규화하여 합이 1이 되도록 만든다.

import pandas as pd

fish = pd.read_csv('https://bit.ly/fish_csv_data')
fish.head()

print(pd.unique(fish['Species']))

fish_input = fish[['Weight','Length','Diagonal','Height','Width']].to_numpy()
print(fish_input[:5])

unique한 species종류를 확인하고 input data의 양이 많으니 5개만 잘 들어갔나 확인해보자
['Bream' 'Roach' 'Whitefish' 'Parkki' 'Perch' 'Pike' 'Smelt']

[[242. 25.4 30. 11.52 4.02 ]

[290. 26.3 31.2 12.48 4.3056]

[340. 26.5 31.1 12.3778 4.6961]

[363. 29. 33.5 12.73 4.4555]

[430. 29. 34. 12.444 5.134 ]]

fish_target = fish['Species'].to_numpy()

from sklearn.model_selection import train_test_split

train_input, test_input, train_target, test_target = train_test_split(
    fish_input, fish_target, random_state=42)

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

<< 여기까지 이번 장을 위한 data 준비

이번 장은 주어진 data를 가지고 어느 분류에 해당할 지 확률을 구하는 내용이다.

k-최근접 이웃 분류기의 확률 예측

KNeighborsClassifier로 분류해본다. K를 3으로 두어 주변 3개의 값만 확인하도록 해본다. (단순 비교용)

from sklearn.neighbors import KNeighborsClassifier

kn = KNeighborsClassifier(n_neighbors=3)
kn.fit(train_scaled, train_target)

print(kn.score(train_scaled, train_target))
print(kn.score(test_scaled, test_target))

0.8907563025210085

0.85

print(kn.classes_)
print(kn.predict(test_scaled[:5]))

['Bream' 'Parkki' 'Perch' 'Pike' 'Roach' 'Smelt' 'Whitefish']

['Perch' 'Smelt' 'Pike' 'Perch' 'Perch']

import numpy as np

proba = kn.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=4))

[[0. 0. 1. 0. 0. 0. 0. ]

[0. 0. 0. 0. 0. 1. 0. ]

[0. 0. 0. 1. 0. 0. 0. ]

[0. 0. 0.6667 0. 0.3333 0. 0. ]

[0. 0. 0.6667 0. 0.3333 0. 0. ]]

단순에 주변 3개의 이웃 중에 얼마의 비중으로 들어 있는가를 보여준다.

distances, indexes = kn.kneighbors(test_scaled[3:4])
print(train_target[indexes])

[['Roach' 'Perch' 'Perch']]

로지스틱 회귀

import numpy as np
import matplotlib.pyplot as plt

z = np.arange(-5, 5, 0.1)
phi = 1 / (1 + np.exp(-z))

plt.plot(z, phi)
plt.xlabel('z')
plt.ylabel('phi')
plt.show()

로지스틱 회귀로 이진 분류 수행하기

char_arr = np.array(['A', 'B', 'C', 'D', 'E'])
print(char_arr[[True, False, True, False, False]])

['A' 'C']  <<- True인 값만 표시된다.

bream_smelt_indexes = (train_target == 'Bream') | (train_target == 'Smelt')
train_bream_smelt = train_scaled[bream_smelt_indexes]
target_bream_smelt = train_target[bream_smelt_indexes]

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression()
lr.fit(train_bream_smelt, target_bream_smelt)

print(lr.predict(train_bream_smelt[:5]))
print(lr.predict_proba(train_bream_smelt[:5]))

['Bream' 'Smelt' 'Bream' 'Bream' 'Bream']

[[0.99759855 0.00240145]

[0.02735183 0.97264817]

[0.99486072 0.00513928]

[0.98584202 0.01415798]

[0.99767269 0.00232731]]

두개의 값으로 예측을 했다. 이 두개의 값이 무엇인지 알아보자

print(lr.classes_)

['Bream' 'Smelt']

 5개를 예측했는데 두번째가 Smelt일 것으로 예측(양성 클래스가 Smelt)하였고,

나머지 4개는 Bream으로 예측하였다.

로지스틱 회귀가 학습한 계수를 확인해보자

print(lr.coef_, lr.intercept_)

[[-0.4037798 -0.57620209 -0.66280298 -1.01290277 -0.73168947]] [-2.16155132]

decisions = lr.decision_function(train_bream_smelt[:5])
print(decisions)

[-6.02927744 3.57123907 -5.26568906 -4.24321775 -6.0607117 ]

from scipy.special import expit
print(expit(decisions))

[0.00240145 0.97264817 0.00513928 0.01415798 0.00232731]

로지스틱 회귀로 다중 분류 수행하기

lr = LogisticRegression(C=20, max_iter=1000)
lr.fit(train_scaled, train_target)

print(lr.score(train_scaled, train_target))
print(lr.score(test_scaled, test_target))

0.9327731092436975

0.925

C는 기본값이 1이며 숫자가 적을수록 규제가 강하다.

max_iter는 기본값이 100이며 충분히 훈련하기 위해 값을 늘려줘야 한다.

print(lr.predict(test_scaled[:5]))

proba = lr.predict_proba(test_scaled[:5])
print(lr.classes_)
print(np.round(proba, decimals=3))

['Perch' 'Smelt' 'Pike' 'Roach' 'Perch']

['Bream'   'Parkki'    'Perch'    'Pike'        'Roach'   'Smelt'   'Whitefish']

[[0.          0.014      0.841     0.             0.136     0.007    0.003]

 [0.          0.003      0.044     0.             0.007     0.946    0. ]

 [0.          0.           0.034     0.935        0.015     0.016    0. ]

 [0.011     0.034      0.306     0.007        0.567     0.          .076]

 [0.         0.            0.904    0.002        0.089     0.002     0.001]]

생선의 종류가 7가지라 열이 7개

print(lr.coef_.shape, lr.intercept_.shape)

(7, 5) (7,)   <<- 선형 방정식

decision = lr.decision_function(test_scaled[:5])
print(np.round(decision, decimals=2))

[[ -6.5 1.03 5.16 -2.73 3.34 0.33 -0.63]

[-10.86 1.93 4.77 -2.4 2.98 7.84 -4.26]

[ -4.34 -6.23 3.17 6.49 2.36 2.42 -3.87]

[ -0.68 0.45 2.65 -1.19 3.26 -5.75 1.26]

[ -6.4 -1.99 5.82 -0.11 3.5 -0.11 -0.71]]

from scipy.special import softmax

proba = softmax(decision, axis=1)
print(np.round(proba, decimals=3))

[[0.      0.014      0.841      0.        0.136      0.007     0.003]

 [0.      0.003      0.044      0.        0.007      0.946     0. ]

 [0.      0.          0.034       0.935   0.015      0.016     0. ]

 [0.011 0.034      0.306      0.007    0.567     0.          0.076]

 [0.     0.           0.904      0.002    0.089     0.002     0.001]]

keyword : 다중회귀, 특성공학, 릿지, 라쏘, 하이퍼파라미터

multiple regression, feature engineering, Ridge, Lasso, hyperparameter

농어의 무게를 예측하는데 길이 정보만 사용되었다.

높이, 두께 등 다양한 값을 추가하여 예측 성공율을 높여 보자.

PolynomialFeatures Class를 사용할 것이라고 하는데....

다중회귀(multiple regression) : 여러개의 특성을 사용한 선형 회귀

특성공학(feature engineering) : feature engineering란 용어가 이해하기 좀 더 쉽다. 기존의 특성을 이용해 새로운 특성을 만들어내는 작업

       이번 예제에서는 '농어 길이 * 농어 높이'를 새로운 특성으로 정의했다.

Pandas : data 분석 library(dataframe 사용)

import pandas as pd
df = pd.read_csv('https://bit.ly/perch_csv_data')
perch_full = df.to_numpy()
print(perch_full)

[[ 8.4 2.11 1.41]
[13.7 3.53 2. ]
[15. 3.82 2.43]
[16.2 4.59 2.63]
[17.4 4.59 2.94]
[18. 5.22 3.32]

[18.7 5.2 3.12]

[19. 5.64 3.05]

....

https://bit.ly/perch_csv_data => https://raw.githubusercontent.com/rickiepark/hg-mldl/master/perch_full.csv

length, height, width
8.4 ,  2.11,  1.41
13.7,  3.53,  2.  
15. ,  3.82,  2.43
16.2,  4.59,  2.63
17.4,  4.59,  2.94
....

import numpy as np

perch_weight = np.array(
    [5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0, 85.0, 85.0, 
     110.0, 115.0, 125.0, 130.0, 120.0, 120.0, 130.0, 135.0, 110.0, 
     130.0, 150.0, 145.0, 150.0, 170.0, 225.0, 145.0, 188.0, 180.0, 
     197.0, 218.0, 300.0, 260.0, 265.0, 250.0, 250.0, 300.0, 320.0, 
     514.0, 556.0, 840.0, 685.0, 700.0, 700.0, 690.0, 900.0, 650.0, 
     820.0, 850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0, 1100.0, 
     1000.0, 1000.0]
     )

from sklearn.model_selection import train_test_split
#train data와 test data 생성
train_input, test_input, train_target, test_target = train_test_split(perch_full, perch_weight, random_state=42)

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures()
poly.fit([[2, 3]])
print(poly.transform([[2, 3]]))

[[1. 2. 3. 4. 6. 9.]]

주인공이 나왔다.

fit()은 추가적인 특성을 찾아내고, transform은 값을 넣는다.

2,3을 가지고 특성을 찾았기 때문에 2,3 그리고 2^2, 3^2가 추가되고, 2+3, 2*3도 추가되었다.

그런데 1은? 절편값이라고 하는데 선형모델에서는 자동으로 추가되기 때문에 필요하지 않다고 한다.

이 값을 제거하기 위해 include_bias=False를 준다.

사이킷런에서는 자동으로 False로 해준다고 한다.

poly = PolynomialFeatures(include_bias=False)
poly.fit([[2, 3]])
print(poly.transform([[2, 3]]))

[[2. 3. 4. 6. 9.]]

poly = PolynomialFeatures(include_bias=False)

poly.fit(train_input)
train_poly = poly.transform(train_input)
print(train_poly.shape)

(42, 9)

poly.get_feature_names_out()

array(['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2', 'x2^2'], dtype=object)

get_feature_names_out() : feature가 어떻게 구성되었는지 보여준다.

test_poly = poly.transform(test_input)

다중회귀 모델 훈련하기

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))

0.9903183436982124

훈련점수

print(lr.score(test_poly, test_target))

0.9714559911594132

테스트점수

제곱까지의 변수만 사용하였는데 3승,4승의 항을 넣으려면 degree를 조정하면 된다.(max=5)

poly = PolynomialFeatures(degree=5, include_bias=False)

poly.fit(train_input)
train_poly = poly.transform(train_input)
test_poly = poly.transform(test_input)

print(train_poly.shape)
print(poly.get_feature_names_out())

(42, 55)

['x0' 'x1' 'x2' 'x0^2' 'x0 x1' 'x0 x2' 'x1^2' 'x1 x2' 'x2^2' 'x0^3'
 'x0^2 x1' 'x0^2 x2' 'x0 x1^2' 'x0 x1 x2' 'x0 x2^2' 'x1^3' 'x1^2 x2'
 'x1 x2^2' 'x2^3' 'x0^4' 'x0^3 x1' 'x0^3 x2' 'x0^2 x1^2' 'x0^2 x1 x2'
 'x0^2 x2^2' 'x0 x1^3' 'x0 x1^2 x2' 'x0 x1 x2^2' 'x0 x2^3' 'x1^4'
 'x1^3 x2' 'x1^2 x2^2' 'x1 x2^3' 'x2^4' 'x0^5' 'x0^4 x1' 'x0^4 x2'
 'x0^3 x1^2' 'x0^3 x1 x2' 'x0^3 x2^2' 'x0^2 x1^3' 'x0^2 x1^2 x2'
 'x0^2 x1 x2^2' 'x0^2 x2^3' 'x0 x1^4' 'x0 x1^3 x2' 'x0 x1^2 x2^2'
 'x0 x1 x2^3' 'x0 x2^4' 'x1^5' 'x1^4 x2' 'x1^3 x2^2' 'x1^2 x2^3' 'x1 x2^4'
 'x2^5']

lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

0.9999999999991096

-144.40579242335605

특성의 개수가 많아 훈련 세트에서는 거의 완벽하게 학습이 되지만 과대적합으로 인해 test set에서는 형편없는 점수가 나온다.

규제 : 과대적합을 줄이는 방법

선형회귀 모델의 경우 계수(or 기울기)를 줄여 일반적인 모델로 만들 수 있다.

정규화

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()
ss.fit(train_poly)

train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)

train set와 test set는 항상 함께!

Ridge : 계수를 제곱한 값을 기준으로 규제를 적용, alpha값이 클수록 규제가 심해진다.(default=1)       solver를 지정할 수 있다.(ㅊ매개변수에 최적의 모델을 찾기 위한 방법 지정       default : solver=auto       추천 : solver=sag, solver=saga    (saga는 sag의 개선버전으로 사이킷런 0.19 이후 적용)Lasso : 절댓값을 기준으로 규제를 적용

Ridge

from sklearn.linear_model import Ridge

ridge = Ridge()
ridge.fit(train_scaled, train_target)
print(ridge.score(train_scaled, train_target))
print(ridge.score(test_scaled, test_target))

0.9896101671037343

0.9790693977615397

import matplotlib.pyplot as plt

train_score = []
test_score = []

alpha_list = [0.001, 0.01, 0.1, 1, 10, 100]
for alpha in alpha_list:
    # 릿지 모델을 만듭니다
    ridge = Ridge(alpha=alpha)
    # 릿지 모델을 훈련합니다
    ridge.fit(train_scaled, train_target)
    # 훈련 점수와 테스트 점수를 저장합니다
    train_score.append(ridge.score(train_scaled, train_target))
    test_score.append(ridge.score(test_scaled, test_target))

plt.plot(np.log10(alpha_list), train_score)
plt.plot(np.log10(alpha_list), test_score)
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

alpha값을 변경해가며 확인하여 train 점수와 test 점수가 가장 비슷한 alpha가 최적의 값이 된다.

그래프의 왼쪽은 훈련세트에서 점수가 높고 테스트세트에서 점수가 낮은 과대적합, 오른쪽은 둘 다 점수가 낮아지는 과소적합의 모습을 보인다.

여기에서는 0.1이 최적의 값이 되었다.

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

print(ridge.score(train_scaled, train_target))
print(ridge.score(test_scaled, test_target))

0.9903815817570366

0.9827976465386927

Lasso

Rigde와 동일하게 사용하고 이름을 Lasso로 바꾼다.

from sklearn.linear_model import Lasso

lasso = Lasso()
lasso.fit(train_scaled, train_target)
print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))

0.989789897208096

0.9800593698421883

train_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)
plt.plot(np.log10(alpha_list), test_score)
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

이 결과에서 최적값은 alpha=1 값이다. 즉 10^1 = 10 이다.

lasso = Lasso(alpha=10)
lasso.fit(train_scaled, train_target)

print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))

0.9888067471131867

0.9824470598706695

print(np.sum(lasso.coef_ == 0))

40

Lasso모델은 계속의 값을 0으로 설정할 수도 있다. 55가지 특성 중 40가지는 사용되지 않았다는 뜻이다.이 값을 이용하여 필요하지 않은 특성을 골라낼 수 있다.

print(lr.coef_, lr.intercept_)

이번 장에서는 k-최근접이웃 알고리즘의 한계에 대해 이야기한다.

기존에 참고하는 data가 충분하지 않고 새로운 영역에 대한 data가 들어왔을 때 기존에 있는 자료만 가지고 비슷한 이웃을 찾아 결과를 알려준다면 그 결과가 원하는 내용이 되지 않는다는 것이다.

import numpy as np

perch_length = np.array(
    [8.4, 13.7, 15.0, 16.2, 17.4, 18.0, 18.7, 19.0, 19.6, 20.0, 
     21.0, 21.0, 21.0, 21.3, 22.0, 22.0, 22.0, 22.0, 22.0, 22.5, 
     22.5, 22.7, 23.0, 23.5, 24.0, 24.0, 24.6, 25.0, 25.6, 26.5, 
     27.3, 27.5, 27.5, 27.5, 28.0, 28.7, 30.0, 32.8, 34.5, 35.0, 
     36.5, 36.0, 37.0, 37.0, 39.0, 39.0, 39.0, 40.0, 40.0, 40.0, 
     40.0, 42.0, 43.0, 43.0, 43.5, 44.0]
     )
perch_weight = np.array(
    [5.9, 32.0, 40.0, 51.5, 70.0, 100.0, 78.0, 80.0, 85.0, 85.0, 
     110.0, 115.0, 125.0, 130.0, 120.0, 120.0, 130.0, 135.0, 110.0, 
     130.0, 150.0, 145.0, 150.0, 170.0, 225.0, 145.0, 188.0, 180.0, 
     197.0, 218.0, 300.0, 260.0, 265.0, 250.0, 250.0, 300.0, 320.0, 
     514.0, 556.0, 840.0, 685.0, 700.0, 700.0, 690.0, 900.0, 650.0, 
     820.0, 850.0, 900.0, 1015.0, 820.0, 1100.0, 1000.0, 1100.0, 
     1000.0, 1000.0]
     )

from sklearn.model_selection import train_test_split

# 훈련 세트와 테스트 세트로 나눕니다
train_input, test_input, train_target, test_target = train_test_split(
    perch_length, perch_weight, random_state=42)
# 훈련 세트와 테스트 세트를 2차원 배열로 바꿉니다
train_input = train_input.reshape(-1, 1)
test_input = test_input.reshape(-1, 1)

from sklearn.neighbors import KNeighborsRegressor

knr = KNeighborsRegressor(n_neighbors=3)
# k-최근접 이웃 회귀 모델을 훈련합니다
knr.fit(train_input, train_target)

print(knr.predict([[50]]))

[1033.33333333]

import matplotlib.pyplot as plt

# 50cm 농어의 이웃을 구합니다
distances, indexes = knr.kneighbors([[50]])

# 훈련 세트의 산점도를 그립니다
plt.scatter(train_input, train_target)
# 훈련 세트 중에서 이웃 샘플만 다시 그립니다
plt.scatter(train_input[indexes], train_target[indexes], marker='D')
# 50cm 농어 데이터
plt.scatter(50, 1033, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

농어의 길이가 50이나 되는데 최근접 이웃인 45보다 작은 농어의 평균 값을 50cm짜리 농어의 무게로 예측한다.

print(np.mean(train_target[indexes]))

1033.3333333333333

print(knr.predict([[100]]))

[1033.33333333]

# 100cm 농어의 이웃을 구합니다
distances, indexes = knr.kneighbors([[100]])

# 훈련 세트의 산점도를 그립니다
plt.scatter(train_input, train_target)
# 훈련 세트 중에서 이웃 샘플만 다시 그립니다
plt.scatter(train_input[indexes], train_target[indexes], marker='D')
# 100cm 농어 데이터
plt.scatter(100, 1033, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

선형회귀 : 직선으로 결과값 예측

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
# 선형 회귀 모델 훈련
lr.fit(train_input, train_target)

# 50cm 농어에 대한 예측
print(lr.predict([[50]]))

[1241.83860323]

print(lr.coef_, lr.intercept_)

[39.01714496] -709.0186449535477

from sklearn.linear_model import LinearRegression

lr = LinearRegression()
# 선형 회귀 모델 훈련
lr.fit(train_input, train_target)

# 50cm 농어에 대한 예측
print(lr.predict([[50]]))

[1241.83860323]

print(lr.coef_, lr.intercept_)

[39.01714496] -709.0186449535477

# 훈련 세트의 산점도를 그립니다
plt.scatter(train_input, train_target)
# 15에서 50까지 1차 방정식 그래프를 그립니다
plt.plot([15, 50], [15*lr.coef_+lr.intercept_, 50*lr.coef_+lr.intercept_])
# 50cm 농어 데이터
plt.scatter(50, 1241.8, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

print(lr.score(train_input, train_target))
print(lr.score(test_input, test_target))

0.939846333997604

0.8247503123313558

# 직선으로 추세선을 만들어 기울기에 맞는 값을 예측한다.

다항회귀 : 곡선으로 결과값 예측

train_poly = np.column_stack((train_input ** 2, train_input))
test_poly = np.column_stack((test_input ** 2, test_input))

print(train_poly.shape, test_poly.shape)

(42, 2) (14, 2)

lr = LinearRegression()
lr.fit(train_poly, train_target)

print(lr.predict([[50**2, 50]]))

[1573.98423528]

print(lr.coef_, lr.intercept_)

[ 1.01433211 -21.55792498] 116.05021078278276

무게 = 1.01 * 길이^2 - 21.6 * 길이 + 116.05

# 구간별 직선을 그리기 위해 15에서 49까지 정수 배열을 만듭니다
point = np.arange(15, 50)
# 훈련 세트의 산점도를 그립니다
plt.scatter(train_input, train_target)
# 15에서 49까지 2차 방정식 그래프를 그립니다
plt.plot(point, 1.01*point**2 - 21.6*point + 116.05)
# 50cm 농어 데이터
plt.scatter([50], [1574], marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

0.9706807451768623

0.9775935108325121