๐2์ฃผ์ฐจ 220117 ~ 220123 ๊ณต๋ถ๊ธฐ๋ก
๐ ๋ณธ ํฌ์คํ ์ <ํผ์ ๊ณต๋ถํ๋ ๋จธ์ ๋ฌ๋+๋ฅ๋ฌ๋> ์ฑ ์ ๋ฐํ์ผ๋ก ์์ฑํจ์ ์๋ฆฝ๋๋ค.
โ Ch.03-3 ํน์ฑ ๊ณตํ๊ณผ ๊ท์
๐ฅํน์ฑ๊ณตํ(feature engineering)
ํน์ฑ ๊ณตํ(Feature engineering)์ ๋จธ์ ๋ฌ๋์ pre-processing ๋จ๊ณ๋ก, ๊ธฐ์กด์ ๋ฐ์ดํฐ๋ก๋ถํฐ ์๋ก์ด ํน์ฑ์ ์ถ์ถํ๋ ์์ ์ ์๋ฏธํ๋ค. Feature engineering์ ๋ ์ข์ ๋ฐฉ๋ฒ์ผ๋ก ์์ธก ๋ชจ๋ธ์์ ๊ทผ๋ณธ์ ์ธ ๋ฌธ์ ๋ฅผ ๋ํ๋ด๋๋ก ๋๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ๋ณด์ด์ง ์๋ ๋ฐ์ดํฐ๋ก๋ถํฐ ๋ชจ๋ธ์ ์ ํ์ฑ์ ํฅ์์ํจ๋ค. ๋จธ์ ๋ฌ๋์์ Feature engineering์ ์ฃผ๋ก 4๊ฐ์ง์ ๊ณผ์ (Feature Creation, Transformation, Feature Extraction, and Feature Selection)์ ๊ฑฐ์น๋ค. ๋ณธ ํฌ์คํ ์ ์ฌ์ดํท๋ฐ์ ์ด์ฉํ์ฌ Transformation์ ๋ณด์ฌ์ฃผ๊ธฐ ๋๋ฌธ์, ๋ ๋ง์ ์ค๋ช ์ ์ํ๋ค๋ฉด, ๋ณธ ํฌ์คํ ํ๋จ์ ์ฐธ๊ณ ์๋ฃ๋ฅผ ์ฐธ๊ณ ํ๋ฉด ๋๋ค.
Feature engineering์ ๋ชฉํ
1. ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฑธ๋ง๋ ์ ๋นํ ์ ๋ ฅ ๋ฐ์ดํฐ์ ์ ์ค๋น
2. ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํฅ์์ํค๋ ๊ฒ์ด๋ค.
Feature engineering์ ์ฌ์ฉํ๋ ์ด์
๊ณผ์ ํฉ๊ณผ ํธํฅ์ ๋ฐฉ์งํ๊ธฐ ์ํด์์ด๋ค. ๊ณผ์ ํฉ์ ๋ฐฉ์งํ๋ ์ด์ ๋ ๋ถํ์ํ ์์๋ค์ด ๋ถ์์ ์ฌ์ฉ๋ ๊ฒฝ์ฐ ๊ณผ์ ํฉ์ด ๋ฐ์ํ์ฌ ํ ์คํธ ์ธํธ๊ฐ ์ ๋๋ก ๋์ํ์ง ์๊ฑฐ๋, ๋ชจ๋ธ์ด ๋จ์ํด์ง ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ํธํฅ ๋ฐฉ์ง๋ฅผ ํ๋ ์ด์ ๋ ๋ถ์ ํํ ์ ๋ณด๋ค์ด ๋ถ์์ ์ ์ฉ๋ ๊ฒฝ์ฐ ํธํฅ์ด ๋ฐ์ํ๊ธฐ ๋๋ฌธ์ด๋ค.
+) ๋ฐ์ดํฐ๊ฐ ๋ฐฉ๋ํ๋ค๊ณ ํด๋ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋๋ฐ ์ฐ๋ฉด ์ ํํ ๋ํ๋ ๋ฏํ์ง๋ง ์คํ๋ ค ๊ฒฐ๊ณผ๋ฅผ ์๋ชป๋๊ฒ ๋์ถํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ์ด๋ ํต๊ณ๋ถ์์์ ์ ํ ํจ์์ ๋ ๋ฆฝ๋ณ์๊ฐ ๋ง๋ค๊ณ ํด์ ์ข ์๋ณ์์ ๊ธฐ๋๊ฐ์ ์ ํ๋๊ฐ ๋ฌด์กฐ๊ฑด ์ฌ๋ผ๊ฐ์ง ์๋ ์ด์ ๋ผ๊ณ ๋ ํ ์ ์๋ค. ์ฆ, ๋จธ์ ๋ฌ๋์ ์ฑ๋ฅ์ ์ด๋ค ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ๋์ง๊ฐ ๊ต์ฅํ ์์กด์ ์ด๋ค. ๊ฐ์ฅ ์ด์์ ์ธ ์ ๋ ฅ ๋ฐ์ดํฐ๋ ๋ถ์กฑํ์ง๋ ๊ณผํ์ง๋ ์์ ์ ํํ ์ ๋ณด๋ง์ ํฌํจ๋ ๋์ด๋ค. ๊ทธ๋์ Feature engineering๋จ๊ณ๋ฅผ ๊ฑฐ์ณ ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ถ์ถํด์ผํ๋ค.
Feature engineering์ ์ค์์ฑ
๋ฐ์ดํฐ์ ํน์ฑ์ ์ฌ์ฉํ๋ ์์ธก ๋ชจ๋ธ๊ณผ ๋ชฉํํ๋ ๊ฒฐ๊ณผ์ ์ง์ ์ ์ผ๋ก ์ํฅ์ ๋ฏธ์น๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์์ ๋ ๋์ ํน์ฑ์ ์ถ์ถํ ํ์๊ฐ ์๋ค.
1. Better features means flexibility. The flexibility of good features will allow you to use less complex models that are faster to run, easier to understand and easier to maintain.
2. Better features means simpler models. With well engineered features, you can choose “the wrong parameters” (less than optimal) and still get good results, for much the same reasons. You do not need to work as hard to pick the right models and the most optimized parameters. With good features, you are closer to the underlying problem and a representation of all the data you have available and could use to best characterize that underlying problem.
3. Better features means better results. As already discussed, in machine learning, as data we will provide will get the same output. So, to obtain better results, we must need to use better features.
โ์ด๋ป๊ฒ ๋ณํ์ ํ๋์?
์ฌ์ดํท๋ฐ์ ์ด์ฉํ์ฌ ์ฌ์ดํท๋ฐ์ ํด๋์ค์ธ ๋ณํ๊ธฐ๋ฅผ ๋ถ๋ฅธ๋ค. ๋ณธ ํฌ์คํ ์์ ์ฌ์ฉํ ๋ณํ๊ธฐ๋ PolynominalFeatures ํด๋์ค์ด๋ค. (๋ณํ๊ธฐ๋ ํ๊น ๋ฐ์ดํฐ ์์ด ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๋ณํํ๋ค.)
์๋ ์ฝ๋์ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์. 2๊ฐ์ ํน์ฑ([2, 3])์ ํ๋ จ์ํค๊ณ ๋ณํ์ํค๋ฉด, [1. 2. 3. 4. 6. 9]๋ผ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ณผ ์ ์๋ค. ์ด ๊ฒฐ๊ณผ๊ฐ ์ฆ 2๊ฐ์ ํน์ฑ์ ๋ณํํ ๊ฐ์ด๋ค. ๊ฒฐ๊ณผ๋ 2์ 3์ ์ด์ฉํ์ฌ ๊ฐ ํน์ฑ์ ์ ๊ณฑํ ํญ๊ณผ ํน์ฑ๋ผ๋ฆฌ ์๋ก ๊ณฑํ ํญ์ ์ถ๊ฐํ์๋ค. 1์ ์ ํ ๋ฐฉ์ ์์ ์ ํธ์ ํญ์ ๊ณฑํด์ง๋ ๊ณ์๋ผ๊ณ ๋ณผ ์ ์๋ค.
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures()
poly.fit([[2,3]])
print(poly.transform([[2,3]]))
#[[1. 2. 3. 4. 6. 9.]]
(์ฌ์ดํท๋ฐ ๋ชจ๋ธ์ ์๋์ผ๋ก ํน์ฑ์ ์ถ๊ฐ๋ ์ ํธ ํญ์ ๋ฌด์ํ์ง๋ง, ํท๊ฐ๋ฆฐ๋ค๋ฉด ๋ช ์์ ์ผ๋ก 1์ ์์จ ์ ์๋ค. 1์ ์์ ๋ ๋ฐฉ๋ฒ์ include_bias=False๋ฅผ ์ง์ ํ๋ฉด ๋๋ค. ๋ง์ฝ include_bias=True๋ผ๋ฉด ๊ฑฐ๋ญ์ ๊ณฑ ํญ์ ์ ์ธ๋๊ณ ํน์ฑ ๊ฐ์ ๊ณฑ์ ํญ๋ง ์ถ๊ฐ๋๋ค. ๊ธฐ๋ณธ๊ฐ์ False์ด๋ค.)
#include_bias=False ์ง์
poly = PolynomialFeatures(include_bias=False)
#[[1. 2. 3. 4. 6. 9.]]
์์ ์ค๋ช ํ ๋ด์ฉ์ด์ง๋ง, ๋ณํํ๋ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํ์๋ฉด
1๏ธโฃ PolynominalFeatures ํด๋์ค๋ฅผ ์ํฌํธํ๋ค.
2๏ธโฃ ๋ณํ๊ธฐ ํด๋์ค๊ฐ ์ ๊ณตํ๋ fit(), transform() ๋ฉ์๋๋ฅผ ์ฐจ๋ก๋๋ก ํธ์ถํ๋ค. (๋ณํ)
3๏ธโฃ ์ ๋ณํ๋์๋์ง ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ๋ก ํ์ธํ๋ค. shape() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ก ํ์ธํ๋ฉด ๋๋ค.
(42, 9)๋ฅผ ๋ณด๋ฉด 9๊ฐ์ ํน์ฑ์ ๋ง๋ค์๋ค.(3๊ฐ์ ํน์ฑ์ ์ฌ์ฉํ์๋ค. train_input์์ 3๊ฐ์ ํน์ฑ์ ๋ฃ์์) 9๊ฐ์ ํน์ฑ์ด ๊ฐ๊ฐ ์ด๋ค ์ ๋ ฅ์ ์กฐํฉ์ผ๋ก ๋ง๋ค์ด์ก๋์ง ์๊ณ ์ถ๋ค๋ฉด get_feature_names()๋ฉ์๋๋ฅผ ์ด์ฉํ๋ฉด ๋๋ค.
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(include_bias=False)
poly.fit(train_input)
train_poly = poly.transform(train_input)
print(train_poly.shape) #ํ๋ จ๋ฐ์ดํฐ
#(42, 9)
#ํ
์คํธ ๋ฐ์ดํฐ
test_poly = poly.transform(test_input)
#(14, 9)
#9๊ฐ์ ํน์ฑ์ด ์ด๋ค ์กฐํฉ์ผ๋ก ์ด๋ฃจ์ด์ก๋์ง
poly.get_feature_names()
#['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2', 'x2^2']
๐Transformations: The transformation step of feature engineering involves adjusting the predictor variable to improve the accuracy and performance of the model. For example, it ensures that the model is flexible to take input of the variety of data; it ensures that all the variables are on the same scale, making the model easier to understand. It improves the model's accuracy and ensures that all the features are within the acceptable range to avoid any computational error.
๐ฅ๊ท์ (regularization)
๊ท์ (regularization)๋ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ํ๋ จ ์ธํธ๋ฅผ ๋๋ฌด ๊ณผ๋ํ๊ฒ ํ์ตํ์ง ๋ชปํ๋๋ก ํผ๋ฐฉํ๋ ๊ฒ์ ๋งํ๋ค. ์ฆ ๋ชจ๋ธ์ด ํ๋ จ์ธํธ์ ๊ณผ๋์ ํฉ๋์ง ์๋๋ก ๋ง๋๋ ๊ฒ์ด๋ค. ์ ํ ํ๊ท ๋ชจ๋ธ์ ๊ฒฝ์ฐ ํน์ฑ์ ๊ณฑํด์ง๋ ๊ณ์(๋๋ ๊ธฐ์ธ๊ธฐ)์ ํฌ๊ธฐ๋ฅผ ์๊ฒ ๋ง๋๋ ์ผ์ด๋ค. ํ๋จ์ ๊ทธ๋ฆผ์์ ์ข์ธก์ ํ๋ จ์ธํธ๋ฅผ ๊ณผ๋ํ๊ฒ ํ์ตํ ๊ทธ๋ํ์ด๊ณ ์ฐ์ธก์ ๊ท์ ๋ฅผ ํตํด ๋ณดํธ์ ์ธ ํจํด์ผ๋ก ํ์ตํ ๊ฒ์ด๋ค.
โํน์ฑ์ ์ค์ผ์ผ ์ ๊ทํ
ํน์ฑ์ ์ค์ผ์ผ์ด ์ ๊ทํ๋์ง ์๋๋ค๋ฉด ๊ณฑํด์ง๋ ๊ณ์ ๊ฐ๋ ์ฐจ์ด๊ฐ ๋๊ฒ ๋๊ธฐ ๋๋ฌธ์ ๊ท์ ๋ฅผ ํ๊ธฐ ์ ์ ์ ๊ทํ๋ฅผ ํด์ฃผ์ด์ผ ํ๋ค. ์ ๊ทํ๋ฅผ ํด์ฃผ๋ ๋ฐฉ๋ฒ ์ค ํ๋๋ ์ฌ์ดํท๋ฐ์ ๋ณํ๊ธฐ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
โ์ ๊ทํ๋ฅผ ํ๋ ๋ฐฉ๋ฒ
1๏ธโฃ์ฌ์ดํท๋ฐ์์ ์ ๊ณตํ๋ StandardScaler ํด๋์ค๋ฅผ ์ํฌํธ ํ ํด๋์ค์ ๊ฐ์ฒด ss๋ฅผ ๋ง๋ ๋ค.
2๏ธโฃPolynominalFeatures ํด๋์ค๋ก ๋ง๋ (๋ณํ์ํจ) train_poly๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด๋ฅผ ํ๋ จ์ํจ๋ค.
3๏ธโฃํ๋ จ ์ธํธ์ ์ ์ฉํ๋ ๋ณํ๊ธฐ๋ก ํ ์คํธ ์ธํธ์๋ ์ ์ฉํ์ฌ ํ์ค์ ์๋ก ๋ณํํด ์ค๋ค.
*) ํ์ค์ ์(z์ ์)๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉํ๋ ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ ์ค ํ๋์ด๋ค.
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_poly)
#ํ์ค์ ์๋ก ๋ณํํ ํ๋ จ์ธํธ์ ํ
์คํธ ์ธํธ
train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)
์ ํ ํ๊ท ๋ชจ๋ธ์ ๊ท์ ๋ฅผ ์ถ๊ฐํ ๋ชจ๋ธ์ ๋ฆฟ์ง(ridge)์ ๋์(lasso)๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋ ๋ชจ๋ธ์ ๊ท์ ๋ฅผ ๊ฐํ๋ ๋ฐฉ๋ฒ์ด ๋ค๋ฅด๋ค. ๋ฆฟ์ง๋ ๊ณ์๋ฅผ ์ ๊ณฑํ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ท์ ๋ฅผ ์ ์ฉํ๊ณ , ๋ผ์๋ ๊ณ์์ ์ ๋๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ท์ ๋ฅผ ์ ์ฉํ๋ค. ๋ ์๊ณ ๋ฆฌ์ฆ ๋ชจ๋ ๊ณ์์ ํฌ๊ธฐ๋ฅผ ์ค์ด์ง๋ง ๋ผ์๋ ์์ ๊ณ์๋ฅผ 0์ผ๋ก ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ ๋ฆฟ์ง๋ฅผ ์ผ๋ฐ์ ์ผ๋ก ์กฐ๊ธ ๋ ์ ํธํ๋ ํธ์ด๋ค.
๐ฅ๋ฆฟ์ง ํ๊ท (L2 Regression, Ridge regression)
๋ฆฟ์ง ํ๊ท๋ ๊ท์ ๊ฐ ์๋ ์ ํ ํ๊ท ๋ชจ๋ธ ์ค ํ๋์ด๋ฉฐ, ์ ํ ๋ชจ๋ธ์ ๊ณ์๋ฅผ ์๊ฒ ๋ง๋ค์ด ๊ณผ๋์ ํฉ์ ์ํ์ํจ๋ค. ๋ฆฟ์ง๋ ๋น๊ต์ ํจ๊ณผ๊ฐ ์ข์ ๋๋ฆฌ ์ฌ์ฉํ๋ ๊ท์ ๋ฐฉ๋ฒ์ด๋ค.
* ๊ท์ ์ ๊ฐ๋๋ฅผ ์์๋ก ์กฐ์ ํ๊ธฐ ์ํด alpha ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค. alpha ๊ฐ์ด ํด์๋ก ๊ท์ ๊ฐ ์ธ์ง๊ณ ๊ธฐ๋ณธ๊ฐ์ 1์ด๋ค. ์ ์ ํ alpha๊ฐ์ ์ฐพ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ alpha๊ฐ์ ๋ํ R²๊ฐ์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆฌ๋ ๊ฒ์ด๋ค. ํ๋ จ์ธํธ์ ํ ์คํธ ์ธํธ์ ์ ์๊ฐ ๊ฐ์ฅ ๊ฐ๊น์ด ์ง์ ์ด ์ต์ ์ alpha๊ฐ์ด ๋๋ค.
(* ํ์ดํผ ํ๋ผ๋ฏธํฐ : ๋จธ์ ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด ํ์ตํ์ง ์๋ ํ๋ผ๋ฏธํฐ์ด๋ค. ์ด๋ฐ ํ๋ผ๋ฏธํฐ๋ ์ฌ๋์ด ์ฌ์ ์ ์ง์ ํด์ผ ํ๋ค. ๋ํ์ ์ผ๋ก ๋ฆฟ์ง์ ๋ผ์์ ๊ท์ ๊ฐ๋ alpha ํ๋ผ๋ฏธํฐ์ด๋ค. ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ํน์ฑํด์ ํ์ตํ ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ์๋ ์ ๋ฐ๋์ ๊ฐ๋ ์ด๋ค.)
โ์ ์ ํ alpha๊ฐ์ ์ฐพ๊ธฐ ์ํด R²๊ฐ์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆฌ๊ธฐ
alpha๊ฐ์ ๋ฐ๊ฟ ๋๋ง๋ค score() ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค๊ณ alpha๊ฐ์ 10๋ฐฐ์ฉ ๋๋ ค๊ฐ๋ฉฐ ๋ฆฟ์ง ํ๊ท ๋ชจ๋ธ ํ๋ จ์ ํ๋ค. ๊ทธ ํ ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ์ ์ ์๋ฅผ ํ์ด์ฌ ๋ฆฌ์คํธ์ ์ ์ฅํ๋ค.
#ridge๋ชจ๋ธ ํ๋ จ
from sklearn.linear_model import Ridge
ridge = Ridge()
ridge.fit(train_scaled, train_target)
#alpha๊ฐ์ ๋ฐ๊ฟ ๋๋ง๋ค score() ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ
import matplotlib.pyplot as plt
train_score = []
test_score = []
#alpha๊ฐ์ 0.001์ ์ 100๊น์ง 10๋ฐฐ์ฉ ๋๋ ค๊ฐ๋ฉฐ ๋ฆฟ์ง ํ๊ท ๋ชจ๋ธ ํ๋ จ
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²')
plt.show()
์๋ ํ๋ จ ์ธํธ ๊ทธ๋ํ, ์๋๋ ํ ์คํธ ์ธํธ ๊ทธ๋ํ์ด๋ค. ์ ์ ํ alpha๊ฐ์ ๋ ๊ทธ๋ํ๊ฐ ๊ฐ์ฅ ๊ฐ๊น๊ณ ํ ์คํธ ์ ์๊ฐ ๊ฐ์ฅ ๋์ -1, ์ฆ 10โป¹=0.1์ด๋ค.
๐ฅ๋ผ์ ํ๊ท (L1 Regression, Lasso regression)
Lasso๋ ๊ท์ ๊ฐ ์๋ ํ๊ท ์๊ณ ๋ฆฌ์ฆ์ธ ๋ผ์ ํ๊ท ๋ชจ๋ธ์ ํ๋ จํ๋ค. ์ด ํด๋์ค๋ ์ต์ ์ ๋ชจ๋ธ์ ์ฐพ๊ธฐ ์ํด ์ขํ์ถ์ ๋ฐ๋ผ ์ต์ ํ๋ฅผ ์ํํด๊ฐ๋ ์ขํ ํ๊ฐ๋ฒ(coordinate descent)์ ์ฌ์ฉํ๋ค. ๋ฆฟ์ง์ ๋ฌ๋ฆฌ ๊ณ์ ๊ฐ์ ์์ 0์ผ๋ก ๋ง๋ค ์๋ ์๋ค.
โ์ ์ ํ alpha๊ฐ์ ์ฐพ๊ธฐ ์ํด R²๊ฐ์ ๊ทธ๋ํ๋ฅผ ๊ทธ๋ฆฌ๊ธฐ
Lasso ๋ชจ๋ธ์ ํ๋ จํ๋ ๊ฒ์ Ridge์ ๋งค์ฐ ๋น์ทํ๋ค. Ridge๋ชจ๋ธ๊ณผ ๊ฐ์ด Lasso ๋ํ ์ ์ ํ alpha๊ฐ์ ๋ฐ๊พธ์ด๊ฐ๋ฉฐ ๊ท์ ์ ๊ฐ๋๋ฅผ ์กฐ์ ํ๋ค.
#lasso ๋ชจ๋ธ ํ๋ จ
from sklearn.linear_model import Lasso
lasso = Lasso()
lasso.fit(train_scaled, train_target)
train_score = []
test_score = []
alpha_list = [0.001, 0.01, 0.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²')
plt.show()
Lasso ๋ชจ๋ธ์์ ์ต์ ์ alpha๊ฐ์ 1, ์ฆ 10¹=10 ์ด๋ค.
โ๋ผ์ ๋ชจ๋ธ์ด ๋ฆฟ์ง์ ๋ฌ๋ฆฌ ๊ณ์ ๊ฐ์ ์์ 0์ผ๋ก ๋ง๋ค ์๋ ์๋ค๋ ๊ฒ์ ๋ฌด์จ ๋ป์ธ๊ฐ์?
#๋ผ์ ๋ชจ๋ธ ๊ณ์ ์ค 0์ธ ๊ฒ ์ถ๋ ค๋ด๊ธฐ
print(np.sum(lasso.coef_ == 0))
#40
๋ผ์ ๋ชจ๋ธ์ ๊ณ์๋ coef_์์ฑ์ ์ ์ฅ๋์ด ์๋ค. ์ด ์ค 0์ธ ๊ฒ์ ํค์๋ฆฌ๋ฉด 40๊ฐ๊ฐ ๋๋ค๋ ๊ฒ์ ์ ์ ์๋ค. 55๊ฐ์ ํน์ฑ์ ๋ชจ๋ธ์ ์ฃผ์ ํ์ง๋ง ๋ผ์ ๋ชจ๋ธ์ด ์ฌ์ฉํ ํน์ฑ์ 15๊ฐ๋ฐ์ ๋์ง ์๋๋ค. ์ด์ฒ๋ผ ๋ผ์ ๋ชจ๋ธ์ ๊ณ์ ๊ฐ์ ์์ 0์ผ๋ก ๋ง๋ค์ด ๋ผ ์ ์๋ค. ์ด๋ฐ ํน์ง ๋๋ฌธ์ ๋ผ์ ๋ชจ๋ธ์ ์ ์ฉํ ํน์ฑ์ ๊ณจ๋ผ๋ด๋ ์ฉ๋๋ก๋ ์ฌ์ฉํ ์ ์๋ค.
* ) ๋ผ์ ํ๊ท๋ ํ๋ผ๋ฏธํฐ์ ํฌ๊ธฐ์ ๊ด๊ณ์์ด ๊ฐ์ ์์ค์ Regularization์ ์ ์ฉํ๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ 0์ผ๋ก ๋ง๋ค์ด ํด๋น ๋ณ์๋ฅผ ์ญ์ ํ๊ณ ๋ฐ๋ผ์ ๋ชจ๋ธ์ ๋จ์ํ๊ฒ ๋ง๋ค์ด์ฃผ๊ณ ํด์์ ์ฉ์ดํ๊ฒ ๋ง๋ค์ด์ค๋ค.
๐ก๋ค์ค ํ๊ท(multiple regression)
์ฌ๋ฌ ๊ฐ์ ํน์ฑ์ ์ฌ์ฉํ ์ ํ ํ๊ท ๋ชจ๋ธ์ด๋ค. ํน์ฑ์ด ๋ง์ผ๋ฉด ์ ํ ๋ชจ๋ธ์ ๊ฐ๋ ฅํ ์ฑ๋ฅ์ ๋ฐํํ๋ค. ๊ณ ๋ คํด์ผํ๋ ๋ณ์๊ฐ ๋ง๊ธฐ ๋๋ฌธ์ ์ธ๊ฐ์ ์๊ฐ๊ณผ ์์์ผ๋ก๋ ๋ถ๊ฐ๋ฅํ๋ค. ํ๋จ์ ์ด๋ฏธ์ง์ ๊ฐ์ด ํน์ฑ 2๊ฐ๋ง์ ์ฌ์ฉํ์ฌ 3์ฐจ์ ๊ณต๊ฐ์ ํ์ฑํ ์์์ง๋ง, ๊ทธ ์ด์์ ๋ถ๊ฐ๋ฅํ๊ธฐ์ ๋ค์ค ํ๊ท๋ฅผ ์ด์ฉํ๋ค.
* )๋ค์ค ์ ํ ํ๊ท์ ์์ธก ํจ์์ด๋ค. ํน์ฑ์ ์ด p+1๊ฐ, ๊ทธ์ ๋ฐ๋ผ ๊ฐ์ค์น๋ p+1๊ฐ์ด๋ค. ์ฃผ์ด์ง ์ฌ๋ฌ ์ํ๋ค์ p+1๊ฐ์ ํน์ง(x[0]~x[p])๊ณผ ๋ผ๋ฒจ๊ฐ(y) ์ฌ์ด์ ๊ด๊ณ๋ฅผ ์ ๋ํ๋ด์ฃผ๋ w์ b๋ฅผ ์ฐพ์์ผ ํ๋ค. ํน์ง์ด 1๊ฐ์ธ ์ ํํ๊ท์์ ๋ชจ๋ธ์ด ์ง์ ์ด์์ง๋ง, 2๊ฐ๋ฉด ํ๋ฉด์ด ๋๊ณ , ๊ทธ ์ด์์ด๋ฉด ์ดํ๋ฉด(hyperplane)์ด ๋๋ค.
+) ๋คํฅํ๊ท(polynomial regression) : ๋คํญ์์ ์ฌ์ฉํ์ฌ ํน์ฑ๊ณผ ํ๊น ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ํ๊ท. ๋ค์คํ๊ท์ ๋คํญํ๊ท๋ ์์ฐํ ๋ค๋ฅด๊ฒ ๋๋ฌธ์ ํท๊ฐ๋ฆฌ์ง ๋ง๋๋ก ํ์.
๐กํ๋ค์ค(pandas)
ํ๋ค์ค๋ ์ ๋ช ํ ๋ฐ์ดํฐ ๋ถ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค. ๋ฐ์ดํฐํ๋ ์(dataframe)์ ํ๋ค์ค์ ํต์ฌ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ด๋ค. ๋ค์ค ํ๊ท์์ ํน์ฑ์ด ๋ง์ ๋, ๋์ด๋ ๋ฐ์ดํฐ๋ฅผ ๋ณต๋ถํ๋ ๊ฒ์ ๊ต์ฅํ ๋ฒ๊ฑฐ๋กญ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํ๋ค์ค๋ฅผ ์ด์ฉํ์ฌ ์ฝ๊ฒ ๋ํ์ด ๋ฐฐ์ด ๋๋ ๋ค์ฐจ์ ๋ฐฐ์ด๋ก ์์ฝ๊ฒ ๋ฐ๊พธ๋ฉด ์ถ์ด ์คํํด์ง ๊ฒ์ด๋ค.
read_csv() ํจ์์ ๋ฐ์ดํฐ ์ฃผ์๋ฅผ ๋ฃ๊ณ ๋ฐ์ดํฐํ๋ ์์ ๋ง๋ ๋ค. ๊ทธ ๋ค์์ to_numpy() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ํ์ด ๋ฐฐ์ด๋ก ๋ฐ๊พธ๋ฉด ๋๋ค.
import pandas as pd
df = pd.read_csv('https://bit.ly/perch_csv_data') #๋ฐ์ดํฐํ๋ ์ ๋ง๋ค๊ธฐ
perch_full = df.to_numpy() #๋ํ์ด ๋ฐฐ์ด๋ก ๋ณํ
print(perch_full)
๐ก์ฌ์ดํท๋ฐ API์ ์ธ ๊ฐ์ง ์ ํ
1๏ธโฃ์ถ์ ๊ธฐ(estimator)
- ์ฃผ์ด์ง ๋ฐ์ดํฐ์ ๊ณผ ๊ด๋ จ๋ ํน์ ํ๋ผ๋ฏธํฐ ๊ฐ๋ค์ ์ถ์ ํ๋ ๊ฐ์ฒด
- fit() ๋ฉ์๋ ํ์ฉ: ํน์ ํ๋ผ๋ฏธํฐ ๊ฐ์ ์ ์ฅํ ์์ฑ์ด ์ ๋ฐ์ดํธ๋ ๊ฐ์ฒด ์์ ๋ฐํ
2๏ธโฃ๋ณํ๊ธฐ(transformer)
- fit() ๋ฉ์๋์ ์ํด ํ์ต๋ ํ๋ผ๋ฏธํฐ๋ฅผ ์ด์ฉํ์ฌ ์ฃผ์ด์ง ๋ฐ์ดํฐ์ ๋ณํ transform() ๋ฉ์๋ ํ์ฉ
- fit() ๋ฉ์๋์ transform() ๋ฉ์๋๋ฅผ ์ฐ์ํด์ ํธ์ถํ๋ fit_transform() ๋ ํ์ฉ ๊ฐ๋ฅ
3๏ธโฃ์์ธก๊ธฐ(predictor)
- ์ฃผ์ด์ง ๋ฐ์ดํฐ์ ๊ณผ ๊ด๋ จ๋ ๊ฐ์ ์์ธกํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ์ถ์ ๊ธฐ
- predict() ๋ฉ์๋ ํ์ฉ
- fit() ๊ณผ predict() ๋ฉ์๋๊ฐ ํฌํจ๋์ด ์์ด์ผ ํจ
- predict() ๋ฉ์๋๊ฐ ์ถ์ ํ ๊ฐ์ ์ฑ๋ฅ์ ์ธก์ ํ๋ score() ๋ฉ์๋๋ ํฌํจ
- ์ผ๋ถ ์์ธก๊ธฐ๋ ์ถ์ ์น์ ์ ๋ขฐ๋๋ฅผ ํ๊ฐํ๋ ๊ธฐ๋ฅ๋ ์ ๊ณต
[์ฝ๋]
์ฌ์ดํท๋ฐ์ ๋ณํ๊ธฐ
#์ฌ์ดํท๋ฐ์ ๋ณํ๊ธฐ
from sklearn.preprocessing import PolynomialFeatures
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() #ํผ์ณ ์์ง๋์ด๋ง ์กฐํฉ ํ์ธ
#['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2', 'x2^2']
test_poly = poly.transform(test_input) #ํ๋ จ์ธํธ์ ์ ์ฉํ๋ ๋ณํ๊ธฐ๋ก ํ
์คํธ ์ธํธ ๋ณํ
print(test_poly.shape)
#(14, 9)
๋ค์ค ํ๊ท ๋ชจ๋ธ ํ๋ จํ๊ธฐ (๊ณผ๋์ ํฉ ๋ฌธ์ )
55๊ฐ์ ํน์ฑ์ด ์๋ฏธํ๋ ๋ฐ : ์ํ ๊ฐ์๋ณด๋ค ํน์ฑ์ด ๋ง๋ค → ๊ณผ๋์ ํฉ ๋ฌธ์ .
#๋ค์ค ํ๊ท ๋ชจ๋ธ ํ๋ จํ๊ธฐ
from sklearn.linear_model import LinearRegression #์ ํํ๊ท
lr = LinearRegression()
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target)) #ํ๋ จ ์ธํธ score ์ถ๋ ฅ
#0.9903183436982124
print(lr.score(test_poly, test_target)) #ํ
์คํธ ์ธํธ score ์ถ๋ ฅ
#0.9714559911594132
#ํ
์คํธ ์ธํธ์ ๋ํ ์ ์๋ฅผ ๋์ด๊ธฐ ์ํด ํน์ฑ ์ถ๊ฐ
poly = PolynomialFeatures(degree=5, include_bias=False) #degree ๋งค๊ฐ๋ณ์ ์ฌ์ฉ : ์ต๋ ์ฐจ์ ๊ฒฐ์
poly.fit(train_input)
train_poly = poly.transform(train_input)
test_poly = poly.transform(test_input)
print(train_poly.shape)
#(42, 55) 55๊ฐ์ ํน์ฑ ํ์ธ
#ํ๋ จ์ธํธ์ ๋นํด ํ
์คํธ ์ธํธ์ ์ ์๋ ์์ -> ๊ณผ๋์ ํฉ
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))
#0.9999999999991096
print(lr.score(test_poly, test_target))
#-144.40579242335605
[์ฐธ๊ณ ์๋ฃ]
ํน์ฑ๊ณตํ์ ๋ํด์ ํ๊ตญ์ด๋ก ์ค๋ช ๋์ด์์. ๊ฐ๋จํ๊ฒ ์ค๋ช ๋์ด ์์ด์ ๊ฐ๋ณ๊ฒ ์ฝ๊ธฐ ์ข๋ค.
https://itwiki.kr/w/%ED%8A%B9%EC%84%B1_%EA%B3%B5%ED%95%99
ํน์ฑ๊ณตํ ์ด๋ฏธ์ง ์ฌ์ฉ, ์์ธํ ์ค๋ช .
https://www.javatpoint.com/feature-engineering-for-machine-learning
ํน์ฑ๊ณตํ์ ๋ํ ์์ธํ ์ค๋ช . ๋ฐ๋ก ์์ ์๋ฃ์ ๋ณํํด์ ์ฝ์ด๋ ๊ด์ฐฎ๋ค.
ํ๊ตญ์ด๋ก ๋์ด์์ด์ ์ฝ๊ธฐ ํธํจ.
https://velog.io/@guide333/%EC%95%84%EC%9D%B4%ED%9A%A8-Feature-Engineering
ํน์ฑ๊ณตํ์ ํ์์ฑ์ ๋ํด์ ์ ์ค๋ช ํด์ฃผ์ ๋ค.
http://www.incodom.kr/%EA%B8%B0%EA%B3%84%ED%95%99%EC%8A%B5/feature_engineering
๋ค์ค์ ํํ๊ท ์ด๋ฏธ์ง ์ฐธ๊ณ
https://hleecaster.com/ml-multiple-linear-regression-example/
์ฌ์ดํท๋ฐ์ API ์ธ ๊ฐ์ง ์ ํ ์ฐธ๊ณ
https://codingalzi.github.io/handson-ml2/slides/handson-ml2-02b-slides.pdf
๋ค์ค์ ํํ๊ท์ ๋ํด์ ์ฝ๊ฒ ์ค๋ช ๋์ด์๋ค. + ๋ผ์
๋ผ์์ ๋ฆฟ์ง์ ๋ํด ๋ ์์ธํ ์๊ณ ์ถ๋ค๋ฉด?
'Study > AI & ML' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๊ท ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ชจ๋ธ ๊ท์ (2) - ์ ํ ํ๊ท (4) | 2024.03.15 |
---|---|
ํ๊ท ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ชจ๋ธ ๊ท์ (1) - K-์ต๊ทผ์ ์ด์ ํ๊ท (3) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (3) (1) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (2) (0) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (1) (0) | 2024.03.15 |