<jupyter_start><jupyter_text>Chapter 7=============================== Polynomial Features- 1차 방정식을 고차다항식으로 변경하는 기법- sklearn.preprocessing.PolynomialFeatures 사용- PolynomialFeatures(degree(**차수**))\begin{align}X0 + X1 + X2 + X1^2 + X1X2 + X2^2\end{align}<jupyter_code>import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
X = np.arange(6).reshape(3, 2)
X
poly = PolynomialFeatures(2)
poly.fit_transform(X)
ploy = PolynomialFeatures(interaction_only=True)
poly.fit_transform(X)<jupyter_output><empty_output><jupyter_text>Example- f 함수\begin{align}x * sin(x^2) + 1 반환\end{align}- sample 함수    + 임의의 값을 넣어 랜덤 값 생성    - linspace 함수    + a 부터 b까지 사이의 size가 n개인 수 균등하게 생성<jupyter_code>def f(size):
    x = np.linspace(0, 5, size)
    y = x * np.sin(x ** 2) + 1
    return (x, y)

def sample(size):
    x = np.linspace(0, 5, size)
    y = x * np.sin(x ** 2) \
        + 1 + np.random.randn(x.size) * 0.5
    return (x, y)
f_x, f_y = f(1000)
plt.plot(f_x, f_y)
X, y = sample(1000)
plt.scatter(X, y, s=3, c='black')
plt.show()
X
X.shape, y.shape
X = X.reshape(-1, 1)
y = y.reshape(-1, 1)
X.shape, y.shape
from sklearn.linear_model import LinearRegression

lr = LinearRegression()
lr.fit(X, y)
f_x, f_y = f(1000)
plt.plot(f_x, f_y)
plt.scatter(X.flatten(), y.flatten(), s=3, c='black')
plt.plot(X.flatten(), lr.predict(X).flatten())
plt.show()
poly_features = PolynomialFeatures(degree=2)
X_poly = poly_features.fit_transform(X)
X_poly[:10]
lr = LinearRegression(fit_intercept=False)
lr.fit(X_poly, y)
f_x, f_y = f(1000)
plt.plot(f_x, f_y)
plt.scatter(X.flatten(), y.flatten(), s=3, c='black')
plt.plot(X.flatten(), lr.predict(X_poly).flatten())
plt.show()
poly_features = PolynomialFeatures(degree=16)
X_poly = poly_features.fit_transform(X)
X_poly[:3]
lr = LinearRegression(fit_intercept=False)
lr.fit(X_poly, y)
f_x, f_y = f(1000)
plt.plot(f_x, f_y)
plt.scatter(X.flatten(), y.flatten(), s=3, c='black')
plt.plot(X.flatten(), lr.predict(X_poly).flatten())
plt.show()<jupyter_output><empty_output><jupyter_text>하고있는 작업- parameter search    + degree를 바꾸며 진행    + 실험적으로 접근     rmse(Root Mean Square Error)- 추정 값 또는 모델이 예측한 값과 실제 환경에서관찰되는 값의 차이를 다룰 때 흔히 사용하는 측도<jupyter_code>def rmse(predctions, targets):
    return np.sqrt(((predctions - targets) ** 2).mean())<jupyter_output><empty_output><jupyter_text>- Lasso : L1- Ridge : L2- 가장 성능이 좋은 모델 : rmse의 값이 가장 작은 것<jupyter_code>poly_range = list(range(10, 50))
rmse_lr_list = []
rmse_lasso_list = []
rmse_ridge_list = []

from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge

for poly_value in poly_range:
    poly_features = PolynomialFeatures(degree=poly_value)
    X_poly = poly_features.fit_transform(X)
    
    lr = LinearRegression(fit_intercept=False)
    lr.fit(X_poly, y)
    
    rmse_lr_list.append(rmse(lr.predict(X_poly), y))

    lasso = Lasso(fit_intercept=False)
    lasso.fit(X_poly, y)
    rmse_lasso_list.append(rmse(lasso.predict(X_poly), y))
    
    ridge = Ridge(fit_intercept=False)
    ridge.fit(X_poly, y)
    rmse_ridge_list.append(rmse(ridge.predict(X_poly), y))
from pandas import DataFrame

data = {
    "poly_range":poly_range,
    "lr_rmse":rmse_lr_list,
    "lasso_rmse":rmse_lasso_list,
    "ridge_rmse":rmse_ridge_list,
}

df = DataFrame(data).set_index("poly_range")
df<jupyter_output><empty_output><jupyter_text>어떻게 최적화 하는가?- **RMSE**의 최소값을 찾자- **Ridge**, **Lasso**, **LR** 모두 써보자- Degree를 10 ~ 50까지 써보자- 결과를 **한눈에 정리**해보자<jupyter_code>plt.plot(poly_range, df["ridge_rmse"], label="ridge")
plt.plot(poly_range, df["lr_rmse"], label="lr")
plt.plot(poly_range, df["lasso_rmse"], label="lasso")
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>L1(Lasso)- Unstable Solution- Always on Solution- Sparse Solution- Feature Selection L2(Ridge)- Stable Solution- Only one Solution- Non-sparse Solution L1의 값이 비슷한 이유- L1(Lasso)의 경우 의미없는 데이터들을 0으로 바꾸기 때문<jupyter_code>df.min()<jupyter_output><empty_output><jupyter_text>확인 결과 **Ridge**가 가장 작다.<jupyter_code>df["ridge_rmse"].sort_values().head()<jupyter_output><empty_output><jupyter_text>가장 작은 Ridge의 **최솟값** 정렬하여 확인`degree`가 `22`일때 가장 값이 적다.<jupyter_code>poly_features = PolynomialFeatures(degree=22)
X_poly = poly_features.fit_transform(X)
ridge = Ridge(fit_intercept=False)
ridge.fit(X_poly, y)
f_x, f_y = f(1000)
plt.plot(f_x, f_y)
plt.scatter(X.flatten(), y.flatten(), s=3, c="black")
plt.plot(X.flatten(), ridge.predict(X_poly).flatten())
plt.show()<jupyter_output><empty_output><jupyter_text>언제 사용하는가?- 한개 변수가 `Y`값과 **비선형적인 관계**가 있다고 의심될 때- **주기적인 패턴**을 보이는 Series 데이터일 때- 모델 자체가 복잡해지면 해결가능한 부분이 많다.    + SVM, Tree-based Models     Challenge<jupyter_code>df = pd.read_csv('yield.csv', sep='\t')
df.head()
plt.scatter(df['Temp'], df['Yield'])
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.16137071651090343, 'fraction_numerical': 0.017860851505711317, 'mean_word_length': 5.447121820615797, 'pattern_counts': {'":': 4, '<': 37, '<?xml version=': 0, '>': 37, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '438740', 'license': 'MIT', 'n_tokens_mistral': 2336, 'n_tokens_neox': 2414, 'n_words': 396, 'path': 'Chapter.7/15.ipynb', 'repo_name': 'alstn2468/Python_For_Machine_Learning', 'size': '4815'}