๐2์ฃผ์ฐจ 220117 ~ 220123 ๊ณต๋ถ๊ธฐ๋ก
๐ ๋ณธ ํฌ์คํ ์ <ํผ์ ๊ณต๋ถํ๋ ๋จธ์ ๋ฌ๋+๋ฅ๋ฌ๋> ์ฑ ์ ๋ฐํ์ผ๋ก ์์ฑํจ์ ์๋ฆฝ๋๋ค.
โญ Ch. 03(03-1) 2๋ฒ ๋ฌธ์ ์ถ๋ ฅ ๊ทธ๋ํ
knr = KNeighborsRegressor()
x = np.arange(5, 45).reshape(-1, 1)
for n in [1, 5, 10]:
knr.n_neighbors = n
knr.fit(train_input, train_target)
prediction = knr.predict(x)
plt.scatter(train_input, train_target)
plt.plot(x, prediction)
plt.title('n_neighbors = {}'.format(n))
plt.xlabel('length')
plt.ylabel('weight')
plt.show()
โญ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ์ ๋ํด ์ค๋ช ํ๊ธฐ
๋ชจ๋ธ ํ๋ผ๋ฏธํฐ๋ ์ ํ ํ๊ท๊ฐ ์ฐพ์ ๊ฐ์ค์น์ฒ๋ผ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ํน์ฑ์์ ํ์ตํ ํ๋ผ๋ฏธํฐ๋ฅผ ๋งํ๋ค.
์ฆ, ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ด ๋ฐ์ดํฐ(ํน์ฑ)์ ๊ฐ์ง๊ณ ๋ด๋ถ์์ ์ ํ๋ ๋ณ์๋ฅผ ๋งํ๋ค.
A model parameter is a configuration variable that is internal to the model and whose value can be estimated from data. OR A model parameter is a variable of the selected model which can be estimated by fitting the given data to the model. In the above plot, these two parameters(m and c) are estimated by fitting a straight line to the data by minimizing the RMSE. Hence, these parameters are called the model parameters.
โ Ch.03-1 K-์ต๊ทผ์ ์ด์ ํ๊ท
์ง๋ ํ์ต ์๊ณ ๋ฆฌ์ฆ์ ํฌ๊ฒ ๋ถ๋ฅ์ ํ๊ท๋ก ๋๋๋๋ฐ, ์ค๋ ๊ณต๋ถํ ๊ฒ์ "ํ๊ท(regression)"์ด๋ค.
- ๋ถ๋ฅ : ์ํ์ ๋ช ๊ฐ์ ํด๋์ค ์ค ํ๋๋ก ๋ถ๋ฅ → ์ด์์ ๋ ์ด๋ธ ๊ฐ์๋ฅผ ํ์ธ ํ ๋ค์๊ฒฐ
- ํ๊ท : ์์์ ์ด๋ค ์ซ์๋ฅผ ์์ธกํ๋ ๋ฌธ์ → ์ด์๋ค์ ํ๊ท
๐ฅ๊ฒฐ์ ๊ณ์(R²)
๊ฒฐ์ ๊ณ์(R²)๋ ๋ํ์ ์ธ ํ๊ท ๋ฌธ์ ์ ์ฑ๋ฅ ์ธก์ ๋๊ตฌ์ด๋ค.
(0 ≤ R² ≤ 1) : 1์ ๊ฐ๊น์ธ์๋ก ์ข๊ณ , 0์ ๊ฐ๊พธ์ธ์๋ก ์ฑ๋ฅ์ด ๋์ ๋ชจ๋ธ์ด๋ค. (์์ธก์ด ํ๊ท ์ ๋๋ฅผ ์์ธกํ๋ค๋ฉด 1์ด ๋์ด์ ๊ฒฐ์ ๊ณ์๋ 0์ ๊ฐ๊น์์ง๋ค. ๋ฐ๋๋ก, ์์ธก์ด ํ๊น์ ๊ฐ๊น์์ง์๋ก ๋ถ์๊ฐ 0์ ๊ฐ๊น์์ง๊ธฐ ๋๋ฌธ์, ๊ฒฐ์ ๊ณ์๋ 1์ ๊ฐ๊น์์ง๋ค.)
#K-์ต๊ทผ์ ์ด์ ํ๊ท ๋ชจ๋ธ ํ๋ จ
knr.fit(train_input, train_target)
print(knr.score(test_input, test_target))
#0.992809406101064
KNN ํ๊ท ๋ชจ๋ธ์ ํ๋ จ์ํจ ํ score๋ก ํ ์คํธ์ธํธ์ ์ฑ๋ฅ์ ํ์ธํ ์ ์๋ค. ๋ถ๋ฅ์ ๊ฒฝ์ฐ๋ ์ ํํ๊ฒ ๋ถ๋ฅํ ๊ฐ์์ ๋น์จ์ ์ถ๋ ฅํ๋ค. ์ฆ, ์ ํ๋์ด๋ค. ํ๊ท๋ ์์์ ์ซ์๋ฅผ ์์ธกํ๋ ๋ฌธ์ ์ด๊ธฐ ๋๋ฌธ์ ์ ํํ๊ฒ ์ซ์๋ ๊ฐ์๋ฅผ ๋งํ๋ค๋ ๊ฒ์ ๊ฑฐ์ ๋ถ๊ฐ๋ฅ์ ๊ฐ๊น๋ค. ๊ฒฐ์ ๊ณ์๋ ํ๊ท์์ด ์ผ๋ง๋ ์ ํํ์ง๋ฅผ ๋ํ๋ด๋ ์ซ์์ด๋ค.
๐ฅ๊ณผ๋์ ํฉ VS ๊ณผ์์ ํฉ
Regression์์ (1)๋ฒ ์ฌ์ง์ ๊ณผ์์ ํฉ(underfitting)์ด๋ค. ๋นจ๊ฐ์(ํ๋ จ)๋ณด๋ค ์ด๋ก์(ํ ์คํธ)์ ์ ์๊ฐ ๋๊ฑฐ๋ ๋ ์ ์ ๋ชจ๋๊ฐ ๋๋ฌด ๋ฎ์ ๊ฒฝ์ฐ์ด๋ค. ๊ณผ์์ ํฉ์ ๋ชจ๋ธ์ด ๋๋ฌด ๋จ์ํ๊ฑฐ๋ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ์์์ ๋ฐ์ดํฐ์ ๋ด์ฌ๋ ๊ตฌ์กฐ๋ฅผ ํ์ตํ์ง ๋ชปํ ๋ ๋ฐ์ํ๋ค. ๋ชจ๋ธ์ด ๋๋ฌด ๋จ์ํ์ฌ ํ๋ จ ์ธํธ์ ์ ์ ํ ํ๋ จ๋์ง ์์์ ๋ปํ๋ค.
(3)๋ฒ ์ฌ์ง์ ๊ณผ๋์ ํฉ(overfitting)์ด๋ค. ์ด๋ก์(ํ๋ จ)์ด ๋นจ๊ฐ์(ํ ์คํธ)๋ณด๋ค ์ ์๊ฐ ๋ ์๋์ค๋ ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ์ฆ ํ๋ จ ์ธํธ์๋ง ์ ๋ง๋ ๋ชจ๋ธ์ด๋ผ์ ํ ์คํธ ์ธํธ์ ํ์ ์ค์ ์์๋ ์ ์๋ํ์ง ์๋๋ค. (๋ชจ๋ธ ์ด์์ ๋ณต์ก๋๊ฐ ํ์ ์ด์์ผ๋ก ๋๋ค. ์ฆ, ์ง๋์น๊ฒ ์ ๋ง์์ ํ ์คํธ ์ธํธ์์ ๋์ ์ฑ๋ฅ์ ๋ณด์ฌ์ฃผ๊ธฐ ์ด๋ ต๋ค.)
๐ ๊ณผ์์ ํฉ ํด๊ฒฐ ๋ฐฉ๋ฒ
- ๋ชจ๋ธ์ด ๋จ์ํด์ ์๊ธด ๋ฌธ์ ์ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ธ์ ์กฐ๊ธ ๋ ๋ณต์กํ๊ฒ ๋ง๋ ๋ค. (๋ณต์ก๋๊ฐ ๋ ๋์ ๋ชจ๋ธ ์ฌ์ฉ)
- (๊ฐ์ค์น ๊ท์ ์ํ) K-NN ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ชจ๋ธ์ ๋ ๋ณต์กํ๊ฒ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ด์์ ๊ฐ์K๋ฅผ ์ค์ด๋ ๊ฒ์ด๋ค. (์ด์์ ๊ฐ์๋ฅผ ์ค์ด๋ฉด ํ๋ จ ์ธํธ์ ์๋ ๊ตญ์ง์ ์ธ ํจํด์ ๋ฏผ๊ฐํด์ง๊ณ , ์ด์์ ๊ฐ์๋ฅผ ๋๋ฆฌ๋ฉด ๋ฐ์ดํฐ ์ ๋ฐ์ ์๋ ์ผ๋ฐ์ ์ธ ํจํด์ ๋ฐ๋ฅด๊ธฐ ๋๋ฌธ)
๐ ๊ณผ๋์ ํฉ ํด๊ฒฐ ๋ฐฉ๋ฒ
- ๋ชจ๋ธ์ ๋ณต์ก๋๋ฅผ ๋ฎ์ถ๋ค. (ํ๋ จ ์ํ์ ๋ ๋ชจ์ ์ ์๋ ๊ฒฝ์ฐ, ๋ชจ๋ธ์ด ํ๋ จ ์ธํธ์ ์ง์ฐฉํ์ง ์๋๋ก ๊ฐ์ค์น๋ฅผ ์ ํ)
- ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ๋ ๋ง์ด ๋ชจ์๋ค.
- ์ ๊ทํ(์ ๋นํ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ ๋ชจ๋ธ์ ์๋์ ์ผ๋ก ์ฐพ์์ฃผ๋ ๊ธฐ๋ฒ)
๐ฅscikit-learn
- KNeighborsRegrssor : K-์ต๊ทผ์ ์ด์ ํ๊ท ๋ชจ๋ธ์ ๋ง๋๋ ์ฌ์ดํท๋ฐ ํด๋์ค์ด๋ค. (๋ถ๋ฅ๋ชจ๋ธ์ KNeighborsClassfier)
from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor()
- mean_absolute_error : ํ๊ท ๋ชจ๋ธ์ ํ๊ท ์ ๋๊ฐ ์ค์ฐจ๋ฅผ ๊ณ์ฐํ๋ค. ๊ฒฐ์ ๊ณ์๋ฅผ ๊ตฌํ ๋, ์ถ๊ฐ์ ์ผ๋ก ํ๊น๊ณผ ์์ธกํ ๊ฐ ์ฌ์ด์ ์ฐจ์ด๋ฅผ ๊ตฌํ๋ฉด ์ด๋ ์ ๋ ์์ธก์ด ๋ฒ์ด๋ฌ๋์ง ๊ฐ๋ ์ด ์ฝ๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ. mean_absolute_error๋ ํ๊น๊ณผ ์์ธก์ ์ ๋๊ฐ ์ค์ฐจ๋ฅผ ํ๊ท ํ์ฌ ๋ฐํํ๋ค.
from sklearn.metrics import mean_absolute_error
#ํ
์คํธ ์ธํธ์ ๋ํ ์์ธก ๋ง๋ค๊ธฐ
test_prediction = knr.predict(test_input)
#ํ
์คํธ ์ธํธ์ ๋ํ ํ๊ท ์ ๋๊ฐ ์ค์ฐจ๋ฅผ ๊ณ์ฐ
mae = mean_absolute_error(test_target, test_prediction)
print(mae)
* ์ฌ์ดํท๋ฐ์ ์ฌ์ฉํ ํ๋ จ ์ธํธ๋ 2์ฐจ์ ๋ฐฐ์ด์ด์ด์ผ ํ๋ค. ๊ทธ ์ด์ ๋ ์ฌ์ดํท๋ฐ์์ ๊ธฐ๋ณธ์ ์ผ๋ก ์์ ์ ์ธํ X๊ฐ 2d๋ก ๋ค์ด์ฌ ๊ฒ์ ์์ ํ๊ณ ์๋ค.
X : {array-like, sparse matrix}, shape (n_samples, n_features)
Input data, where n_samples is the number of samples and n_features is the number of features.
๐ฅnumpy
- reshape : ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ฐ๊พธ๋ ๋ฉ์๋์ด๋ค. ๋ฐ๊พธ๊ณ ์ ํ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๋ค. (๋จ, ๋ฐ๊พธ๊ธฐ ์ ํ์ ๋ฐฐ์ด ์์ ๊ฐ์๋ ๋์ผํด์ผ ํ๋ค.) ์ฆ, ๋ฐฐ์ด ์ฐจ์(dimension)์ ์ฌ๊ตฌ์กฐํ ๋ฐ ๋ณ๊ฒฝํ๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ค.
#reshape() ๋ฉ์๋ ์ฐ์ต
test_array = np.array([1, 2, 3, 4])
test_array = test_array.reshape(2, 2)
print(test_array)
"""
[[1 2]
[3 4]]
"""
*๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์๋์ผ๋ก ์ง์ ํ๋ ๊ธฐ๋ฅ : ํฌ๊ธฐ์ -1์ ์ง์ ํ๋ค. -1๋ก ์ง์ ํ๋ฉด, ๋๋จธ์ง ์์ ๊ฐ์๋ก ๋ชจ๋ ์ฑ์ฐ๋ผ๋ ์๋ฏธ
- reshape(-1, ์ ์) : ์ด ๊ฐ์๋งํผ ์๋์ผ๋ก ๊ตฌ์กฐํ
- reshape(์ ์, -1) : ํ์ ์ ์๋งํผ ํ์ด ์์ฑ๋์ด์ ์๋์ผ๋ก ๊ตฌ์กฐํ
- reshape(-1) : -1๋ง ๋จ๋ ์ผ๋ก ์์ ๊ฒฝ์ฐ 1์ฐจ์ ๋ฐฐ์ด์ ๋ฐํ
[์ฐธ๊ณ ์๋ฃ]
๊ธฐ๊ณํ์ต ์ด๋ฏธ์ง ์ฐธ๊ณ
ํ๊ท์์ ๊ฒฐ์ ๊ณ์๊ฐ ๊ถ๊ธํ๋ค๋ฉด?
https://math100.tistory.com/120
๊ณผ๋์ ํฉ, ๊ณผ์์ ํฉ์ ๋ํด์ ์์ ํ ์ดํด๊ฐ ๊ฐ๋ฅ
https://m.blog.naver.com/qbxlvnf11/221324122821
๋ณธ ์คํฐ๋์ ๋ด์ฉ์ ๋ํด ์์ธํ ์ค๋ช ๊ณผ ๊น๋ํ ์ ๋ฆฌ
https://velog.io/@arittung/DeepLearningStudyDay4
์ฌ์ดํท๋ฐ์ ์ฌ์ฉํ ํ๋ จ๋ฐ์ดํฐ๊ฐ 2์ฐจ์ ๋ฐฐ์ด์ด์ด์ผ ํ๋ ์ด์
https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html
์ ํํ๊ท์์ 2์ฐจ์ ๋ฐฐ์ด์ ์จ์ผํ๋ ์ด์ : ์ผ์ฐจ์์ ๊ณ์ฐํ ๋ 2์ฐจ์ ๋ฒกํฐ๋ ํ๋ ฌ์ ์ฌ์ฉํ๊ณ , 2์ฐจ์ ํ๋ ฌ์ ํ๋ จ ๋ฐ์ดํฐ๋ก ์ฐ๋ฉด ์ญํ๋ ฌ์ ์จ์ ํ๊ท์ ์ ๊ธฐ์ธ๊ธฐ์ ์ ํธ์ ๊ตฌํ๊ธฐ ์ฝ๋ค.
reshape() ๋ฉ์๋์ ๋ํด ์์ ์ ์ค๋ช ๋์ด ์์.
https://domybestinlife.tistory.com/149
๋ชจ๋ธ ํ๋ผ๋ฏธํฐ์ ์๋ฏธ๊ฐ ๊ถ๊ธํ๋ค๋ฉด?
https://www.geeksforgeeks.org/difference-between-model-parameters-vs-hyperparameters/
๋ชจ๋ธ ํ๋ผ๋ฏธํฐ์ ํ์ดํผํ๋ผ๋ฏธํฐ์ ์ฐจ์ด์ ์ด ๊ถ๊ธํ๋ค๋ฉด?
https://machinelearningmastery.com/difference-between-a-parameter-and-a-hyperparameter/
'Study > AI & ML' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๊ท ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ชจ๋ธ ๊ท์ (3) - ํน์ฑ ๊ณตํ๊ณผ ๊ท์ (0) | 2024.03.15 |
---|---|
ํ๊ท ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ชจ๋ธ ๊ท์ (2) - ์ ํ ํ๊ท (4) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (3) (1) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (2) (0) | 2024.03.15 |
๋์ ์ฒซ ๋จธ์ ๋ฌ๋&๋ฐ์ดํฐ ๋ค๋ฃจ๊ธฐ (1) (0) | 2024.03.15 |