โ๐ป WIDA_4์ฃผ์ฐจ
- ํ์ด์ฌ์ผ๋ก ๋ชจ๋ธ ๋ถ๋ฌ์์ ๊ฐ๋จํ๊ฒ ๋ชจ๋ธ ๋๋ ค๋ณด๊ณ accuracy ์ธก์ ํด๋ณด๊ธฐ (decision tree ์ ์ธ ํ๊ฐ์ง ๊ณจ๋ผ์)
- ๊ทธ ๋ชจ๋ธ์ ํ์ดํผํ๋ผ๋ฏธํฐ ๋ถ์ํ๊ธฐ
- ํ๊ฐ ๋ฐฉ๋ฒ ์์๋ณด๊ธฐ(log loss ํฌํจ 2๊ฐ์ง)
๋๋คํฌ๋ ์คํธ ๋ชจ๋ธ ์คํ
์ฝ๋
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
# Random Forest ๋ชจ๋ธ ๊ฐ์ ธ์ค๊ธฐ
rf_clf = RandomForestClassifier()
bag_clf = BaggingClassifier(rf_clf)
# training dataset ๋ถ๋ฌ์ค๊ธฐ
train_data = pd.read_csv("drive/MyDrive/Colab Notebooks/train.csv")
# ๋ง์ถฐ์ผ ํ๋ ๊ฒ์ type์ด๊ธฐ ๋๋ฌธ์ type๊ณผ ๋๋จธ์ง ๋ฐ์ดํฐ๋ค์ ๋ถ๋ฆฌํด์ค (์ฌ๋ผ์ด์ฑ)
X = train_data.iloc[:, 2:]
y = train_data.iloc[:, 1] #type ์ด
# training dataset๊ณผ test dataset์ผ๋ก ์ชผ๊ฐ๊ธฐ
# training๊ณผ test์ ๋น์จ์ 0.3 [7:3์ผ๋ก ์ชผ๊ฐ ๋ค]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=11)
# ๋๋ค ํฌ๋ ์คํธ ํ์ต ๋ฐ ๋ณ๋์ ํ
์คํธ ์ธํธ๋ก ์์ธก ์ฑ๋ฅ ํ๊ฐ
rf_flf = RandomForestClassifier(criterion='entropy', bootstrap=True, random_state=42, max_depth=5)
rf_clf.fit(X_train, y_train)
pred = rf_clf.predict(X_test)
accuracy = accuracy_score(y_test, pred)
print('๋๋ค ํฌ๋ ์คํธ ์ ํ๋: {0:.4f}'.format(accuracy))
**>>> ๋๋ค ํฌ๋ ์คํธ ์ ํ๋: 0.8767**
์ ํ๋๋ 87.7%์๋ค.
? ๊ถ๊ธํ๋ ๊ฑด random_state๊ฐ ๋ํ๋ด๋ ๋ฐ์ ์ซ์ ์ง์ ์ ์ด๋ป๊ฒ ํด์ผํ ์ง์๋ค.
์๋๋ ์ต์ ์ max_depth๋ฅผ ์ฐพ๋ ์ฝ๋์ด๋ค.
**##์ต์ ์ max_depth ์ฐพ๊ธฐ**
from sklearn.model_selection import KFold
cv = KFold(n_splits=5) #ํด์๋ก ์ค๋๊ฑธ๋ฆผ
accuracies = list()
max_attributes = X_test.shape[1]
depth_range = range(1, max_attributes)
#max_depth๋ฅผ 1๋ถํฐ max attributes๊น์ง
for depth in depth_range:
fold_accuracy = []
rand_clf = RandomForestClassifier(max_depth = depth)
# print("Current max depth: ", depth, "\\n")
for train_fold, valid_fold in cv.split(train_data):
f_train = train_data.loc[train_fold] # Extract train data with cv indices
f_valid = train_data.loc[valid_fold] # Extract valid data with cv indices
model = rand_clf.fit(X_train, y_train)
valid_acc = model.score(X_test, y_test)
fold_accuracy.append(valid_acc)
avg = sum(fold_accuracy)/len(fold_accuracy)
accuracies.append(avg)
print("Accuracy per fold: ", fold_accuracy, "\\n")
df = pd.DataFrame({"Max Depth": depth_range, "Average Accuracy": accuracies})
df = df[["Max Depth", "Average Accuracy"]]
print(df.to_string(index=False))
ํ์ดํผํ๋ผ๋ฏธํฐ ๋ถ์
์ถ์ฒ: https://sevillabk.github.io/RandomForest/
- n_estimators: ๋๋ค ํฌ๋ ์คํธ์์ ๊ฒฐ์ ํธ๋ฆฌ์ ๊ฐ์ ์ง์ . ์ฆ, ํธ๋ฆฌ๋ฅผ ๋ช ๊ฐ ๋ง๋ค ๊ฒ์ธ์ง (int, default=10). ํธ๋ฆฌ ๊ฐฏ์๋ฅผ ๋๋ฆด์๋ก ํ์ต ์ํ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆผ
- max_features: ์ ํํ feature์ ๊ฐ์, ๋ณดํต default๊ฐ์ผ๋ก ์ (default='auto'). ๊ฒฐ์ ํธ๋ฆฌ์ ์ฌ์ฉ๋ max_features ํ๋ผ๋ฏธํฐ์ ๊ฐ์. ๋จ, ‘None’์ด ์๋ ‘auto’(=’sqrt’)์ ๊ฐ์
- criterion: gini ๋๋ entropy ์ค ์ ํ
- min_samples leaf: ๋ฆฌํ๋ ธ๋๊ฐ ๋๊ธฐ ์ํ ์ต์ํ์ ์ํ ๋ฐ์ดํฐ ์. ๋ถ๊ท ํ ๋ฐ์ดํฐ์ ๊ฒฝ์ฐ ํน์ ํด๋์ค ๋ฐ์ดํฐ๊ฐ ๊ทน๋๋ก ์ ์ ์ ์์ผ๋ฏ๋ก ์์ ๊ฐ์ผ๋ก ์ค์ ํ์. (default : 1)
- min_samples_split: ๋ ธ๋๋ฅผ ๋ถํ ํ๊ธฐ ์ํ ์ต์ํ์ ์ํ ๋ฐ์ดํฐ ์. → ๊ณผ์ ํฉ์ ์ ์ดํ๋๋ฐ ์ฌ์ฉ๋๋ค. ๊ฐ์ด ์์์๋ก ๋ถํ ๋ ธ๋๊ฐ ๋ง์์ ธ ๊ณผ์ ํฉ ๊ฐ๋ฅ์ฑ์ด ์ฆ๊ฐํจ. (default : 2)
- max_depth: ํธ๋ฆฌ์ ๊น์ด (int, default=None → ์๋ฒฝํ๊ฒ ํด๋์ค ๊ฐ์ด ๊ฒฐ์ ๋ ๋๊น์ง ๋ถํ ). ๊ฒฐ์ ํธ๋ฆฌ์์์ ๊ณผ์ ํฉ์ ๊ฐ์ ํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ํ๋ผ๋ฏธํฐ๊ฐ ๋๋ค ํฌ๋ ์คํธ์๋ ๋๊ฐ์ด ์ ์ฉ๋ ์ O
- bootstrap: True์ด๋ฉด ์ ์ฒด feature์์ ๋ณต์์ถ์ถํด์ ํธ๋ฆฌ ์์ฑ (default=True)
ํ๊ฐ๋ฐฉ๋ฒ
๋ถ๋ฅ์ ํ๊ฐ๋ฐฉ๋ฒ์ ์ผ๋ฐ์ ์ผ๋ก๋ ์ค์ ๊ฒฐ๊ณผ ๋ฐ์ดํฐ์ ์์ธก ๊ฒฐ๊ณผ ๋ฐ์ดํฐ๊ฐ ์ผ๋ง๋ ์ ํํ๊ณ ์ค๋ฅ๊ฐ ์ ๊ฒ ๋ฐ์ํ๋๊ฐ์ ๊ธฐ๋ฐํ์ง๋ง, ๋จ์ํ ์ ํ๋๋ฅผ ๊ฐ์ง๊ณ ํ๋จํ๋ ๊ฑธ ๋์ด ๋ค๋ฅธ ์ฑ๋ฅ ํ๊ฐ ์งํ๋ ๋ณตํฉ์ ์ผ๋ก ๋ค๋ฃจ์ด์ผ ํ๋ค.
1. log loss
(์ถ์ฒ: https://seoyoungh.github.io/machine-learning/ml-logloss/)
DEF) ๋ถ๋ฅ ๋ชจ๋ธ ์ฑ๋ฅ ํ๊ฐ ์ ์ฌ์ฉ ๊ฐ๋ฅํ ์งํ
- Loss fuction(์์ค ํจ์, cross-entropy): ๋ชจ๋ธ์ ์ถ๋ ฅ๊ฐ๊ณผ ์ ๋ต์ ์ค์ฐจ๋ฅผ ์ ์ํ๋ ํจ์
- logloss๊ฐ ๋ฎ์์๋ก ์ข์ ์งํ
- M: ํด๋์ค ์
- Y: ํ ๋ฐ์ดํฐ i๊ฐ ํด๋์ค m์ ์ํ ๊ฒฝ์ฐ1, ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ 0
- P: ํ ๋ฐ์ดํฐ i๊ฐ ํด๋์ค m์ ์ํ๋ ์์ธก ํ๋ฅ
- ํ๋ฅ ๊ฐ์ ์์ logํจ์์ ๋ฃ์ด ๋ณํ์ ์ํจ ๊ฐ์ผ๋ก ํ๊ฐ. (์๋ชป ์์ธกํ ์๋ก ํจ๋ํฐ๋ฅผ ๋ถ์ฌ๋๋ ๋ฐฉ์)
- ex) 100% ํ๋ฅ = -log(1.0) = 0 / 80% ํ๋ฅ = -log(0.8) = 0.22314 / 60% ํ๋ฅ = -log(0.6) = 0.51082
- ํ๋ฅ ์ด ๋ฎ์์ง ์๋ก log loss ๊ฐ์ด ๊ธฐํ๊ธ์์ ์ผ๋ก ์ฆ๊ฐ
- ์ฌ์ฉ ์ด์
- ์ต์ข ์ ์ผ๋ก ๋ง์ถ ๊ฒฐ๊ณผ๋ง ๊ฐ์ง๊ณ ์ฑ๋ฅ์ ํ๊ฐํ ๊ฒฝ์ฐ, ์ผ๋งํผ์ ํ๋ฅ ๋ก ํด๋น ๋ต์ ์ป์๊ฑด์ง ํ๊ฐ ๋ถ๊ฐ๋ฅ
- ๋ณด์์ ์ํด ํ๋ฅ ๊ฐ์ ํ๊ฐ ์งํ๋ก ์ฌ์ฉ. Log loss๋ ๋ชจ๋ธ์ด ์์ธกํ ํ๋ฅ ๊ฐ์ ์ง์ ์ ์ผ๋ก ๋ฐ์ํ์ฌ ํ๊ฐํจ.
- ์ค์ ๋ต์์ ํด๋นํ๋ ํ๋ฅ ๊ฐ์ ์์ ๋ก๊ทธ๋ฅผ ์ทจํด ๋ชจ๋ ๋ํ๊ณ 1/nํด์ ํ๊ท
from sklearn.metrics import log_loss
#๋ฐ์ดํฐ ์คํ๋ฆฟ์ผ๋ก y_valid์ ๋ชจ๋ธ ์์ธก์ผ๋ก y_pred_proba๋ฅผ ๊ตฌํ ํ ์คํํด์ผ ํ๋ค๊ณ ํ๋ค.
multi_logloss = log_loss(y_valid, y_pred_proba)
print(multi_logloss)
- logloss๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด์๋ ํ๋ฅ ์์ธก๊ฐ(predict_proba)์ด ํ์
2. Precision (์ ๋ฐ๋)
DEF) ์์ธก์ positive๋ก ํ ๋์ ์ค ์์ธก๊ณผ ์ค์ ๊ฐ์ด positive๋ก ์ผ์นํ ๋ฐ์ดํฐ์ ๋น์จ
True Positives / ( True Positives + False Positives )
TP / (TP + FP)
⇒ TP + FP: ์์ธก์ positive๋ก ํ ๋ชจ๋ ๋ฐ์ดํฐ ๊ฑด์
⇒ TP: ์์ธก๊ณผ ์ค์ ๊ฐ์ด positive๋ก ์ผ์นํ ๋ฐ์ดํฐ ๊ฑด์
- ์ฃผ๋ก FP๋ฅผ ๋ฎ์ถ๋ ๋ฐ ์ด์ ์ ๋ง์ถค.
- ์ฌํ์จ(recall)๊ณผ ์ํธ ๋ณด์์ ์ธ ์งํ.
- ํ์ธ
from sklearn.metrics import precision_score
labels = [1, 0, 0, 1, 1, 1, 0, 1, 1, 1]
guesses = [0, 1, 1, 1, 1, 0, 1, 0, 1, 0]
print(precision_score(labels, guesses))
'๐ก WIDA > DACON ๋ถ๋ฅ-ํ๊ท' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[DACON/์ต๋ค์] ๋ถ๋ฅ ๋ชจ๋ธ ๋ฏ์ด๋ณด๊ธฐ, ๋ถ๋ฅ๋ชจ๋ธ ํ๊ฐ๋ฐฉ์ (0) | 2023.03.30 |
---|---|
[DACON/์กฐ์์] ๋ถ๋ฅ ๋ชจ๋ธ ๋ฏ์ด๋ณด๊ธฐ, ๋ถ๋ฅ๋ชจ๋ธ ํ๊ฐ๋ฐฉ์ (svm ๋ชจ๋ธ๋ ์ถ๊ฐํ ์์ ) (0) | 2023.03.30 |
[DACON/๊น๊ท๋ฆฌ] ๋ถ๋ฅ ๋ชจ๋ธ ์์๋ณด๊ธฐ (1) | 2023.03.24 |
[DACON/์กฐ์์] ๋ถ๋ฅ ๋ชจ๋ธ ์์๋ณด๊ธฐ (0) | 2023.03.24 |
[DACON/์ต๋ค์] ๋ถ๋ฅ ๋ชจ๋ธ ์์๋ณด๊ธฐ (0) | 2023.03.23 |