์๋ ์ฒจ๋ถํ ๊ธ์ ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ ๊ฐ๋ ์ ๋ํด ์์ฑํ ๊ธ์ ๋๋ค.
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 04-2. ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ (1)
์ ์ง์ ์ธ ํ์ต์ ์ํ ๋ฌธ์ ์ธ์ ๋ชจ๋ธ์ด ๋งค๋ฒ ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์๋กญ๊ฒ ํ๋ จํ๋ ๋ฐ์๋ ์๋์ ๊ฐ์ ๋ฌธ์ ๋ค์ด ์์ต๋๋ค. ํ๋ จ ๋ฐ์ดํฐ๊ฐ ํ ๋ฒ์ ์ค๋น๋๋ ๊ฒ์ด ์๋๋ผ ์กฐ๊ธ์ฉ ์ ๋ฌ๋๋ค๋ฉด, ๊ณ
avoc-o-d.tistory.com
์๋ ์์ฑํ ๊ธ์ ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ ๊ฐ๋ ๋ฐ ์ค์ต ๊ณผ์ ์ ๋ํด ์์ฑํ ๊ธ์ ๋๋ค. ๐
๋ฐ์ดํฐ ์ค๋นํ๊ธฐ
๋ค์ค ๋ถ๋ฅ๋ฅผ ์ํ ๋ฐ์ดํฐ ์ค๋นํ๋ ๋ฐฉ๋ฒ์ ์ฐธ๊ณ ํฉ๋๋ค.
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 04-1. ๋ก์ง์คํฑ ํ๊ท
๐ ๋ก์ง์คํฑ ํ๊ท ์ ํ ๋ฐฉ์ ์์ ์ฌ์ฉํ ๋ถ๋ฅ ์๊ณ ๋ฆฌ์ฆ ์ ํ ํ๊ท์ ๋ฌ๋ฆฌ, ์๊ทธ๋ชจ์ด๋ ํจ์๋ ์ํํธ๋งฅ์ค ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ํด๋์ค ํ๋ฅ ์ ๊ตฌํจ ๐๋ชฉํ! ์ฌ๋ฌ ์ข ๋ฅ์ ์์ ์ด ์์ ๋, ํด๋น ์์
avoc-o-d.tistory.com
import pandas as pd
fish = pd.read_csv("https://bit.ly/fish_csv_data")
# Species ์ด์ ์ ์ธํ ๋๋จธ์ง ์ด์ ์
๋ ฅ ๋ฐ์ดํฐ๋ก, Species ์ด์ ํ๊น ๋ฐ์ดํฐ๋ก ๋ฐฐ์ด ๋ณํ
fish_input = fish[["Weight","Length","Diagonal","Height","Width"]].to_numpy()
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) # ๊ผญ ํ๋ จ ์ธํธ์์ ํ์ตํ ํต๊ณ ๊ฐ์ผ๋ก ํ
์คํธ ์ธํธ๋ ๋ณํ
์ด๋ ๊ฒ ํน์ฑ๊ฐ์ ์ค์ผ์ผ์ ๋ง์ถ ๋ ๋ํ์ด ๋ฐฐ์ด๊น์ง ์ค๋น๋ฅผ ๋ง์ณค์ต๋๋ค.
๊ทธ๋ผ ์ด์ ํ๋ จ์ ํ๊ฒ ์ต๋๋ค.
๐ SGDClassifier
๐ ์ฌ์ดํท๋ฐ์ SGDClassifier : ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ์ ๊ณตํ๋ ๋ํ์ ์ธ ๋ถ๋ฅ์ฉ ํด๋์ค
- ๋งค๊ฐ๋ณ์ loss : ์์คํจ์์ ์ข ๋ฅ
- ๋งค๊ฐ๋ณ์ max_iter : ์ํํ ์ํฌํฌ ํ์
- loss = "log" ๋ก ์ง์ ํ์ฌ ๋ก์ง์คํฑ ์์ค ํจ์๋ฅผ ์ง์ ํ์์ต๋๋ค.
- max_iter = 10 ๋ก ์ง์ ํ์ฌ ์ ์ฒด ํ๋ จ ์ธํธ๋ฅผ 10ํ ๋ฐ๋ณตํ๊ฒ ์ต๋๋ค.
from sklearn.linear_model import SGDClassifier
# loss ์์ค ํจ์์ ์ข
๋ฅ ์ง์
sc = SGDClassifier(loss='log', max_iter=10, random_state=42)
sc.fit(train_scaled, train_target)
๐ค ์ ํ๋๊ฐ ๋ฎ์ต๋๋ค..? ํ๋ จ ํ์๊ฐ ์ ์ ๊ฒ ๊ฐ์ต๋๋ค.
๐ก ํด๊ฒฐ ! ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ์ ์ง์ ํ์ต์ด ๊ฐ๋ฅํฉ๋๋ค. ์ฆ, ํ์ฌ ํ๋ จํ ๋ชจ๋ธ์ ์ถ๊ฐ๋ก ์ด์ด์ ๋ ํ๋ จํด๋ด ์๋ค.
+) ๐ค ์๋ฌธ? train_scaled, train_target์ ํ ๋ฒ์ ๋ชจ๋ ์ฌ์ฉํ์ผ๋ ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ด ์๋๋ผ ๋ฐฐ์น ๊ฒฝ์ฌ ํ๊ฐ๋ฒ(์ ์ฒด ์ํ์ ์ฌ์ฉํ๋ ๋ฐฉ์)์ด ์๋๊ฐ์?
๐ก ๋๋ต ! ์๋๋๋ค. SGDClassifier์ ํ ๋ฒ์ ํ๋ จ ์ธํธ ์ ์ฒด๋ฅผ ์ ๋ฌํ๊ธด ํ์ง๋ง, ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ฌ๋ฐ์ ํ๋ จ ์ธํธ์์ 1๊ฐ์ฉ ์ํ์ ๊บผ๋ด์ด ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ์ํํฉ๋๋ค.
๐ SGDClassifier์ partial_fit() : 1 ์ํฌํฌ์ฉ ์ด์ด์ ํ๋ จํ๋ ํจ์
- fit() ๊ณผ ์ฌ์ฉ๋ฒ์ด ๊ฐ์ง๋ง, ํธ์ถํ ๋๋ง๋ค 1 ์ํฌํฌ์ฉ ์ด์ด์ ํ๋ จํ ์ ์์ต๋๋ค.
sc.partial_fit(train_scaled, train_target)
์ ํ๋๊ฐ ํฅ์๋์์ต๋๋ค! ์ด ๋ชจ๋ธ์ ์ฌ๋ฌ ์ํฌํฌ์์ ๋ ํ๋ จํด๋ณผ ํ์๊ฐ ์์ด๋ณด์ ๋๋ค.
๐ค ์๋ฌธ? ์ผ๋ง๋ ๋ ํ๋ จํด์ผ ํ๋์?
๐ก ๋๋ต ! ๊ทธ ๊ธฐ์ค์ ์ดํด๋ณด๊ธฐ ์ํด, ์ํฌํฌ์ ๊ณผ๋/๊ณผ์์ ํฉ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
๐ ์ํฌํฌ์ ๊ณผ๋/๊ณผ์์ ํฉ
๐ ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ์ฌ์ฉํ ๋ชจ๋ธ์ ์ํฌํฌ ํ์์ ๋ฐ๋ผ ๊ณผ์์ ํฉ์ด๋ ๊ณผ๋์ ํฉ์ด ๋ ์ ์์ต๋๋ค.
- ์ํฌํฌ ํ์๊ฐ ์ ์ผ๋ฉด, ๋ชจ๋ธ์ด ํ๋ จ ์ธํธ๋ฅผ ๋ ํ์ตํฉ๋๋ค. โถ๏ธ ๊ณผ์์ ํฉ๋ ๋ชจ๋ธ์ผ ๊ฐ๋ฅ์ฑ
- ์ํฌํฌ ํ์๊ฐ ์ถฉ๋ถํ ๋ง์ผ๋ฉด, ๋ชจ๋ธ์ด ํ๋ จ ์ธํธ๋ฅผ ์์ ํ ํ์ตํฉ๋๋ค. โถ๏ธ ๊ณผ๋์ ํฉ๋ ๋ชจ๋ธ์ผ ๊ฐ๋ฅ์ฑ
๐ ์กฐ๊ธฐ ์ข ๋ฃ : ๊ณผ๋์ ํฉ(์ํฌํฌ๊ฐ ์งํ๋ ์๋ก ํ๋ จ ์ธํธ ์ ์๋ ๊พธ์คํ ์ฆ๊ฐํ์ง๋ง, ํ ์คํธ ์ธํธ ์ ์๊ฐ ๊ฐ์ํ๊ธฐ ์์ํ๋ ์๊ฐ)์ด ์์ํ๊ธฐ ์ ์ ํ๋ จ์ ๋ฉ์ถ๋ ๊ฒ
๊ทธ๋ผ ์ฐ๋ฆฌ์ ๋ฐ์ดํฐ๋ก ์์ ๊ฐ์ ๊ทธ๋ํ๋ฅผ ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
๐ fit() ๋ฉ์๋๋ ์ฌ์ฉํ์ง ์๊ณ , partial_fit() ๋ฉ์๋๋ง ์ฌ์ฉํ๊ธฐ ์ํด ํ๋ จ ์ธํธ์ ์๋ ์ ์ฒด ํด๋์ค์ ๋ ์ด๋ธ์ ์ ๋ฌํด์ผ ํฉ๋๋ค. ๋ฐ๋ผ์, ํ๋ จ ์ธํธ์ ์๋ 7๊ฐ ์์ ์ข ๋ฅ class๋ฅผ ์ค๋นํฉ๋๋ค.
import numpy as np
sc = SGDClassifier(loss="log", random_state=42)
# ์ํฌํฌ๋ง๋ค ํ๋ จ ์ธํธ์ ํ
์คํธ ์ธํธ์ ๋ํ ์ ์๋ฅผ ๊ธฐ๋ก
train_score = []
test_score = []
# ํ๋ จ ์ธํธ์ ์๋ 7๊ฐ ์์ ์ข
๋ฅ class๋ฅผ ์ค๋น
classes = np.unique(train_target)
300๋ฒ ์ํฌํฌ ๋์ ํ๋ จ์ ๋ฐ๋ณตํ์ฌ ์งํํ๊ฒ ์ต๋๋ค.
for _ in range(0, 300):
sc.partial_fit(train_scaled, train_target, classes = classes)
# ํ๋ จ ์ธํธ, ํ
์คํธ ์ธํธ ์ ์ ๊ณ์ฐ
train_score.append(sc.score(train_scaled, train_target))
test_score.append(sc.score(test_scaled, test_target))
ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ์ ๋ํ ์ ์๋ฅผ ๊ทธ๋ํ๋ก ๊ทธ๋ฆฌ๊ฒ ์ต๋๋ค.
import matplotlib.pyplot as plt
plt.plot(train_score)
plt.plot(test_score)
plt.xlabel("epoch")
plt.ylabel("accuracy")
plt.show()
์ด๊ธฐ์๋ ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ ๋ ๋ค ์ ์๊ฐ ๋ฎ์ ๊ณผ์์ ํฉ๋ ๊ฒ์ ํ์ธํ ์ ์๊ณ ,
100๋ฒ์งธ ์ํฌํฌ ์ดํ๋ถํฐ ํ๋ จ ์ธํธ์ ํ ์คํธ ์ธํธ ์ ์๊ฐ ์กฐ๊ธ์ฉ ๋ฒ์ด์ง๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
=> 100๋ฒ์งธ ์ํฌํฌ๊ฐ ์ ์ ํ ๋ฐ๋ณต ํ์์ธ ๊ฒ ๊ฐ์ต๋๋ค. ๐
๊ทธ๋ผ, SGDClassifier ์ ๋ฐ๋ณต ํ์๋ฅผ 100์ผ๋ก ๋ง์ถ๊ณ ๋ค์ ํ๋ จํ๊ฒ ์ต๋๋ค.
๐ SGDClassifier์ ๋งค๊ฐ๋ณ์ tol : ์ ๋ฐ๋, ํฅ์๋ ์ต์๊ฐ์ ์ง์
- SGDClassifier๋ ์ผ์ ์ํฌํฌ ๋์ ์ฑ๋ฅ์ด ํฅ์๋์ง ์์ผ๋ฉด ๋ ํ๋ จํ์ง ์๊ณ ์๋์ผ๋ก ๋ฉ์ถฅ๋๋ค.
- None์ผ๋ก ์ง์ ํ๋ฉด ์๋์ผ๋ก ๋ฉ์ถ์ง ์๊ณ max_iter์ ์ง์ ํ ๋งํผ ๋ฌด์กฐ๊ฑด ๋ฐ๋ณตํฉ๋๋ค.
sc = SGDClassifier(loss="log", max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)
์ต์ข ์ ์๊ฐ ์์ฃผ ์ข์ต๋๋ค~! ํ๋ จ ์ฑ๊ณต~! โจโจ
๐ SGDClassifier์ loss ๋งค๊ฐ๋ณ์
- ๊ธฐ๋ณธ๊ฐ : hinge
- ํ์ง ์์ค : ์ํฌํธ ๋ฒกํฐ ๋จธ์ ์ ์ํ ์์ค ํจ์
'๐ป My Work > ๐ง AI' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 07-1. ์ธ๊ณต ์ ๊ฒฝ๋ง (2) (0) | 2023.01.01 |
---|---|
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 07-1. ์ธ๊ณต ์ ๊ฒฝ๋ง (1) (0) | 2022.12.17 |
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 04-2. ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ (1) (0) | 2022.12.09 |
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 04-1. ๋ก์ง์คํฑ ํ๊ท (2) | 2022.12.08 |
[์ธ๊ณต์ง๋ฅ/ํผ๊ณต๋จธ์ ] 03-3. ํน์ฑ ๊ณตํ๊ณผ ๊ท์ (0) | 2022.12.07 |