๋ชฉํ
์ฌ๋ก ๋์งํธ ์ฒ์ฒด ๊ด์ธก ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์ฒ์ฒด์ ํ์ ์ ๋ถ๋ฅํด๋ด๋ ๊ฒ์ ๋ชฉํ๋ก ํ๋ค.
์ด๋ฅผ ์ํด์ train data๋ก ํ์ต์ ํ๊ณ test data๋ก ํ์ธ์ ํ๋ ๊ณผ์ ์ ๊ฑฐ์น๋ค.
EDA (Exploratory Data Analysis : ํ์์ ๋ฐ์ดํฐ ๋ถ์)
์์งํ ๋ฐ์ดํฐ๋ฅผ ๋ค์ํ ๊ฐ๋์์ ๊ด์ฐฐํ๊ณ ์ดํดํ๋ ๊ณผ์ ์ด๋ค.
# ํ์ํ ํจํค์ง import
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score
import seaborn as sns
# ๋ฐ์ดํฐ ๋ก๋
train_data = pd.read_csv("train.csv")
train_data.shape
train_data.head()
train_data.tail()
train_data.info()
train_data.isnull().sum()
fiberMag_g ๋ถํฐ modelMag_z๊น์ง null ๊ฐ์ด ํ๋์ฉ ์กด์ฌํ๋ค.
train_data.describe()
train_data.median()
id์ fiberID๋ฅผ ์ ์ธํ ์ปฌ๋ผ์์์ ์ค์๊ฐ์ด ์๋ก ๋น์ทํ๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
train_data.var()
psfMag_g์ fiberMag_r์ ๋ถ์ฐ์ด ํฐ ๊ฒ์ ํ์ธํ ์ ์๋ค.
train_data['type'].unique()
train_data['type'].value_counts()
QSO์ ์ข ๋ฅ๊ฐ ๊ฐ์ฅ ๋ง๊ณ SERENDIPITY_MANUAL์ ์ข ๋ฅ๊ฐ ๊ฐ์ฅ ์ ์ ๊ฒ์ ์ ์ ์๋ค.
sns.countplot(y='type', data=train_data)
# ์ด์์น ํ์ธ
train_data.boxplot(figsize=(30,10))
์ด์์น๊ฐ ๋ง์ง๋ ์์ง๋ง ์กด์ฌํ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
→ ์ด์์น๋ฅผ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊ฒ์ธ๊ฐ์ ๋ํด ๊ณ ๋ฏผํด๋ณด์์ผ ํ๋ค.
๋ชจ๋ธ๋ง
[ KNN ์๊ณ ๋ฆฌ์ฆ ]
์ฒ์ฒด ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํ๊ธฐ ์ํด์ KNN ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ค.
K-Nearest Neighbors(KNN) ์๊ณ ๋ฆฌ์ฆ์ ์ง๋ํ์ต(Supervised Learning)์ ์ผ์ข ์ผ๋ก, ๋ถ๋ฅ(Classification)์ ํ๊ท(Regression) ๋ฌธ์ ์ ๋ชจ๋ ์ฌ์ฉ๋ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๋ฐ์ดํฐ ์ ๋ค ๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ์ฌ ๊ฐ์ฅ ๊ฐ๊น์ด ์ด์๋ค์ ์ฐพ์๋ด๋ ์๊ณ ๋ฆฌ์ฆ์ ๋งํ๋ค. ์ด๋ ๊ฒ ์ฐพ์๋ธ ์ด์๋ค์ ๋ ์ด๋ธ์ ๋ถ๋ฅ ๋ฌธ์ (Classification)์์๋ ๋ค์๊ฒฐ ํฌํ๋ฅผ ํตํด, ํ๊ท ๋ฌธ์ (Regression)์์๋ ์ด์๋ค์ ํ๊ท ๊ฐ์ ๊ณ์ฐํ์ฌ ์์ธกํ๋ค.
KNN ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋จํ๋ฉด์๋ ๋ถ๋ฅ ๋ฌธ์ ์์ ๋์ ์ ํ๋๋ฅผ ๋ณด์ด๋ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ด๋ค. ๊ทธ๋ฌ๋ ๋ฐ์ดํฐ ํฌ์ธํธ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ์ ์ฐจ์์ด ๋์ด๋ ์๋ก ๊ณ์ฐ ๋น์ฉ์ด ์ฆ๊ฐํ๋ฉฐ, ์ด์์น(Outlier)์ ๋ฏผ๊ฐํด์ง๋ค๋ ๋จ์ ์ด ์๋ค.
KNN์ ๋ชจ๋ธ์ ํ์ต์ํค๋ ๊ณผ์ ์ด ์๊ธฐ ๋๋ฌธ์, ์ค์๊ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฅํ๊ฑฐ๋ ์์ธกํ๋ ๋ฐ์ ์ ํฉํ๋ค.
[ KNN์ ํ์ดํผํ๋ผ๋ฏธํฐ ๋ถ์ ]
ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ ๋จธ์ ๋ฌ๋์์ ์ด๋ ํ ์์์ ๋ชจ๋ธ์ ํ์ต์ํฌ ๋, ์ฌ๋์ด ์ง์ ์ค์ ํด์ผํ๋ ๋ณ์๋ฅผ ๋งํ๋ค. ๋ชจ๋ธ์ ์ต์ ํํ๊ธฐ ์ํด ํ์ดํผ ํ๋ผ๋ฏธํฐ ํ๋์ ์งํํด์ผ ํ๋ค.
1. KNN์์ ์ ์ผ ์ค์ํ ํ๋ผ๋ฏธํฐ๋ K์ด๋ค. K๋ ์ด์์ ์๋ฅผ ๋งํ๋๋ฐ ์ด๋ฅผ ์ด๋ป๊ฒ ์ค์ ํ๋๋์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง๋ค.
- K๊ฐ์ด ์์์๋ก, ๊ฒฝ๊ณ์ ์ด ๋ฏผ๊ฐํด์ง๋ฉฐ ๋ ์ ํํ ์์ธก์ ํ ์ ์๋ค. ํนํ ๋ฐ์ดํฐ๊ฐ ์ ๊ตฌ๋ถ๋์ง ์๋ ๊ฒฝ์ฐ์ ์ ์ฉํ๋ค. ๋ฐ๋ฉด, train ๋ฐ์ดํฐ์ ๊ณผ๋ํ๊ฒ ๋ง์ถ์ด์ ธ ์๋ก์ด ๋ฐ์ดํฐ์ ๋ํ ์ผ๋ฐํ(generalization)๊ฐ ์ ํ๋๋ ๊ณผ์ ํฉ(overfitting)์ด ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋๋ค. ๋ํ, ์ด์์น(outlier) ๋ฐ์ดํฐ์ ์ํฅ์ ํฌ๊ฒ ๋ฐ์ ์ ์๋ค.
- K๊ฐ์ด ํด์๋ก, ๋ชจ๋ธ์ ๋ณต์ก๋๊ฐ ๋ฎ์์ ธ ๋ ์ผ๋ฐํ๋ ๋ชจ๋ธ์ ์ป์ ์ ์์ผ๋ฉฐ ์ด์์น ๋ฐ์ดํฐ์ ์ํฅ์ ์ค์ผ ์ ์๋ค. ๋ฐ๋ฉด, ์์ ๊ตฐ์ง(cluster)์ ๋ถ๋ฅํ๋๋ฐ ์ด๋ ค์์ด ์์ ์ ์์ผ๋ฉฐ ๊ณผ์์ ํฉ (underfitting)์ด ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋๋ค.
- ๋ฐ๋ผ์ ์ ์ ํ K๊ฐ์ ์ฐพ์ ๋์๋ ๊ต์ฐจ ๊ฒ์ฆ(Cross-validation)์ ์ฌ์ฉํ์ฌ ์ต์ ์ K ๊ฐ์ ์ฐพ๋ ๊ฒ์ด ์ข๋ค.
2. ๋ค์ ํ๋ผ๋ฏธํฐ๋ ๊ฑฐ๋ฆฌ(Distance)์ด๋ค. ๊ฑฐ๋ฆฌ ํ๋ผ๋ฏธํฐ๋ ๋ฐ์ดํฐ ํฌ์ธํธ ๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ๋ ๋ฐฉ๋ฒ์ ์ ์ํ๋ ํ๋ผ๋ฏธํฐ์ด๋ค. ์ฃผ๋ก ์ ํด๋ฆฌ๋ ๊ฑฐ๋ฆฌ(Euclidean distance)์ ๋งจํํ ๊ฑฐ๋ฆฌ(Manhattan distance)๋ฅผ ์ฌ์ฉํ๋ค.
- ์ ํด๋ฆฌ๋์ ๊ฑฐ๋ฆฌ๋ ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ๊ฑฐ๋ฆฌ๋ก, n์ฐจ์์์์ ๋ ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ํตํด ๊ณ์ฐํ๋ค. ํํ ํผํ๊ณ ๋ผ์ค ์ ๋ฆฌ๋ผ๊ณ ๋ถ๋ฆฌ๋ ๊ฒ์ด๋ค. ๋ ์ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ฅผ ์ ํํ๊ฒ ๊ณ์ฐํ์ง๋ง, ์ฐจ์์ด ๋์์ง๊ฑฐ๋ ์ด์์น(outlier)๊ฐ ์กด์ฌํ ๊ฒฝ์ฐ ๊ฑฐ๋ฆฌ ์ธก์ ์ด ์๊ณก๋ ์ ์๋ค.
- ๋งจํํผ ๊ฑฐ๋ฆฌ๋ ๋ ์ ์ฌ์ด์ ๊ฐ๋ก์ถ๊ณผ ์ธ๋ก์ถ์ผ๋ก ์ด๋ฃจ์ด์ง ๊ฑฐ๋ฆฌ๋ก ์ ํ๋ ์กฐ๊ฑด ํ์์ ์ ํด์ง ๋ฃจํธ๋ฅผ ํตํด ๋๋ฌํ ์ ์๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋งํ๋ค. ์ ํด๋ฆฌ๋์ธ ๊ฑฐ๋ฆฌ๋ณด๋ค ๊ณ์ฐ ๋น์ฉ์ด ๋ฎ๊ณ , ํนํ ์ฐจ์์ด ๋งค์ฐ ํฐ ๊ฒฝ์ฐ์ ๋ ํจ์จ์ ์ด๋ค. ๋ํ, ์ ํด๋ฆฌ๋์ธ ๊ฑฐ๋ฆฌ๋ณด๋ค ์ด์์น(Outlier)์ ๋ ๋ฏผ๊ฐํ๋ค.
- ์ผ๋ฐ์ ์ผ๋ก๋ ์ฐจ์์ด ํฌ๊ฑฐ๋ ์ด์์น๊ฐ ๋ง์ ๊ฒฝ์ฐ์๋ ๋งจํํผ ๊ฑฐ๋ฆฌ๊ฐ ์ ํฉํ๊ณ , ์ฐจ์์ด ์๊ณ ์ด์์น๊ฐ ์ ์ ๊ฒฝ์ฐ์๋ ์ ํด๋ฆฌ๋์ธ ๊ฑฐ๋ฆฌ๊ฐ ์ ํฉํ๋ค. ์ด ์ธ์๋ ํ์คํ ๊ฑฐ๋ฆฌ, ๋งํ ๋ผ๋ ธ๋น์ค ๊ฑฐ๋ฆฌ, ์ฒด๋น์ ฐํ ๊ฑฐ๋ฆฌ, ๋ฏผ์ฝฅ์คํค ๊ฑฐ๋ฆฌ, ์บ๋ฒ๋ผ ๊ฑฐ๋ฆฌ ๋ฑ ๋ค์ํ ๊ฑฐ๋ฆฌ๊ฐ ์กด์ฌํ๋ค.
[ ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ ]
KNN ์๊ณ ๋ฆฌ์ฆ์์๋ ํ๋ผ๋ฏธํฐ๋ฅผ ์กฐ์ ํ์ฌ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ๊ฐ์ ํ ์ ์๋ค. ์ต์ ์ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ๊ทธ๋ฆฌ๋ ํ์(Grid Search)์ด๋ ๋๋ค ํ์(Random Search)๊ณผ ๊ฐ์ ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋ ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ค.
๊ทธ๋ฆฌ๋ ํ์์ ๊ฐ๋ฅํ ๋ชจ๋ ํ์ดํผํ๋ผ๋ฏธํฐ ์กฐํฉ์ ๋ง๋ค์ด์ ์กฐํฉ๋ค์ ์๋ํด๋ณด๋ ๋ฐฉ๋ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, KNN ์๊ณ ๋ฆฌ์ฆ์์ k ๊ฐ์ด 1, 3, 5, 7์ด๊ณ , ๊ฑฐ๋ฆฌ ์ธก์ ๋ฐฉ๋ฒ์ด ์ ํด๋ฆฌ๋์ ๊ฑฐ๋ฆฌ์ ๋งจํํ ๊ฑฐ๋ฆฌ ๋ ๊ฐ์ง๊ฐ ์๋ค๋ฉด, ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค ํด๋ณด๋ฉด์ ์ต์ ์ ์กฐํฉ์ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด ๋ฐฉ๋ฒ์ ๊ฐ๋ฅํ ๋ชจ๋ ์กฐํฉ์ ๋ค ์๋ํ๊ธฐ ๋๋ฌธ์ ๋์ ์ ํ๋๋ฅผ ๋ณด์ฅํ์ง๋ง, ๊ณ์ฐ ๋น์ฉ์ด ๋งค์ฐ ๋์์ง ์ ์๋ค.
๋ฐ๋ฉด์, ๋๋ค ํ์์ ์ฃผ์ด์ง ํ์ดํผํ๋ผ๋ฏธํฐ ๊ฐ์ ๋ฒ์ ๋ด์์ ๋๋ค์ผ๋ก ์กฐํฉ์ ์ ํํด์ ๋ชจ๋ธ์ ํ์ตํ๊ณ , ์ฑ๋ฅ ์งํ๋ฅผ ํ๊ฐํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, KNN ์๊ณ ๋ฆฌ์ฆ์์ k ๊ฐ์ด 1์์ 10 ์ฌ์ด์ ์ ์ ์ค ๋๋คํ๊ฒ ์ ํ๋๊ณ , ๊ฑฐ๋ฆฌ ์ธก์ ๋ฐฉ๋ฒ๋ ๋๋คํ๊ฒ ์ ํ๋๋ ๊ฒฝ์ฐ์ด๋ค. ์ด ๋ฐฉ๋ฒ์ ๊ทธ๋ฆฌ๋ ํ์์ ๋นํด ๋ ๋น ๋ฅด๊ฒ ํ์ดํผํ๋ผ๋ฏธํฐ ๊ณต๊ฐ์ ํ์ํ ์ ์๋ค. ๊ทธ๋ฌ๋ ๋๋ค ํ์์ ์ต์ ์ ํ์ดํผํ๋ผ๋ฏธํฐ ๊ฐ์ ์ฐพ์ง ๋ชปํ ๊ฐ๋ฅ์ฑ์ด ์๋ค.
๋ฐ๋ผ์, ํ์ดํผํ๋ผ๋ฏธํฐ ๊ณต๊ฐ์ด ๋งค์ฐ ํฐ ๊ฒฝ์ฐ ๋๋ค ํ์์ ์ฌ์ฉํ ์ ์๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ ๊ทธ๋ฆฌ๋ ํ์์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
[ KNN ์๊ณ ๋ฆฌ์ฆ ๊ตฌํํ๊ธฐ ]
null ๊ฐ์ด ์กด์ฌํ๋ฉด ๋ชจ๋ธ๋ง ๊ณผ์ ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. ๋ฐ๋ผ์ null ๊ฐ์ ์ฑ์์ฃผ์ด์ผ ํ๋ค. ๊ทธ๋ฐ๋ฐ ์์ง ์ด๋ ํ ๋ฐฉ๋ฒ์ผ๋ก null ๊ฐ์ ์ฑ์ฐ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ธ์ง ์ฐพ์ง ๋ชปํ์ฌ ์ผ๋จ์ null ๊ฐ์ ์ญ์ ํ ์ํ๋ก ๋ชจ๋ธ๋ง์ ์งํํด๋ณด์๋ค.
# null ๊ฐ์ด ์กด์ฌํ๋ฉด ๋ชจ๋ธ๋ง ๊ณผ์ ์์ ์ค๋ฅ ๋ฐ์
train_data = train_data.dropna()
# type๊ณผ ๋๋จธ์ง ๋ฐ์ดํฐ๋ค์ ๋ถ๋ฆฌํด์ค
X = train_data.iloc[:, 2:]
y = train_data.iloc[:, 1]
# ๋ฐ์ดํฐ์
๋ถํ (ํ์ต์ฉ ๋ฐ์ดํฐ์ ๊ฒ์ฆ์ฉ ๋ฐ์ดํฐ)
# training๊ณผ test์ ๋น์จ์ 0.3
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
train_test_split()์ ๊ธฐ๋ณธ์ ์ผ๋ก ํ๋ จ๋ฐ์ดํฐ ์ธํธ๋ฅผ 75:25์ ๋น์จ๋ก ๋๋๋ค. ์ด ๋น์จ์ test_size ๋งค๊ฐ๋ณ์์ ํ ์คํธ ์ธํธ์ ๋น์จ์ ์ ๋ฌํ์ฌ ์กฐ์ ํ ์ ์๋ค. ๋ฐ์ดํฐ ์ธํธ์ 30%๋ฅผ ํ ์คํธ ์ธํธ๋ก ๋๋๊ธฐ ์ํด 0.3์ ์ ๋ฌํ๋ค.
train_test_split()๋ ๋ฐ์ดํฐ๋ฅผ ๋ฌด์์๋ก ์์ ๋ค, ๋ฐ์ดํฐ ์ ์ ๋๋๊ธฐ ๋๋ฌธ์ ํจ์๋ฅผ ํธ์ถํ ๋๋ง๋ค ๋ค๋ฅธ ๊ฒฐ๊ณผ๋ก ๋ถํ ์ด ๋๋ค. ์ด๋ random_state๋ฅผ ํน์ ์ซ์๋ก ์ง์ ํ๋ฉด ํญ์ ๋์ผํ๊ฒ ๋ถํ ํ ์ ์๋ค. ์ค์ ์ํฉ์์๋ ๊ฑฐ์ ํ์ ์์ง๋ง, ๋ค๋ฅธ ์ฌ๋๋ค๊ณผ ๊ฒฐ๊ณผ๋ฅผ ๊ณต์ ํ๊ฑฐ๋ ์คํ ๊ฒฐ๊ณผ๋ฅผ ๋๊ฐ์ด ์ฌํํด์ผ ํ ๋๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ๋ค.
[ ์ต์ ์ K๊ฐ ์ฐพ๊ธฐ ]
# ์ต์ ์ k๊ฐ ์ฐพ๊ธฐ
k_values = []
accuracy_values = []
for k in range(1, 11):
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)
score = knn.score(X_test, y_test)
k_values.append(k)
accuracy_values.append(score)
n_neighbors๋ ๊ฐ์ฅ ๊ฐ๊น์ด ์ด์์ ๋ช ๊ฐ ๊ณ ๋ฅผ์ง์ ๋ํ ํ๋ผ๋ฏธํฐ์ด๋ค.
# KNN ์๊ฐํ
plt.plot(k_values, accuracy_values, 'o-') # ๋ฐ์ดํฐ ํฌ์ธํธ์ ์ (o)๊ณผ ์ (-)์ด ํจ๊ป ํ์
plt.xlabel('k')
plt.ylabel('Accuracy')
plt.title('Accuracy for Different Values of k')
plt.xticks(k_values) # ๋๊ธ ์ค์
plt.show()
์๊ฐํ๋ฅผ ํตํด k๊ฐ 5์ผ ๋ ์ ํ๋๊ฐ ๊ฐ์ฅ ๋๋ค๋ ๊ฒ์ ํ์ธํ ์ ์๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ต์ ์ k ๊ฐ์ 5๊ฐ ๋๋ค.
# ์ต์ ์ k ๊ฐ์ ์ด์ฉํ์ฌ ๋ชจ๋ธ ์์ฑ, ํ์ต, ๊ฒ์ฆ
best_k = 5
model = KNeighborsClassifier(n_neighbors=best_k)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
๋ฐ์ดํฐ์์ ์ด์์น๋ฅผ ์ด๋ป๊ฒ ์ฒ๋ฆฌํ ๊ฒ์ธ๊ฐ, null ๊ฐ์ ์ด๋ ํ ๋ฐฉ๋ฒ์ผ๋ก ์ฑ์์ผ ํ๋๊ฐ, ์ด๋ค ๊ฑฐ๋ฆฌ๋ฅผ ์ด์ฉํด์ผ ํ ๊น์ ๋ํ ๊ณ ๋ฏผ์ ํตํด ํ์ฌ์ ์ ํ๋๋ณด๋ค ๋ ๋์ ํ๋ฅ ์ด ๋์ค๋๋ก ํด์ผํ๋ค.
'๐ก WIDA > DACON ๋ถ๋ฅ-ํ๊ท' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[DACON/๊น๋ฏผํ] ์ฒ์ฒด ๋ถ๋ฅ ๊ฒฝ์ง๋ํ (5) | 2023.05.06 |
---|---|
[DACON/์กฐ์์] ์ฒ์ฒด ๋ถ๋ฅ ๊ฒฝ์ง๋ํ (4) | 2023.05.06 |
[DACON/๊น๊ฒฝ์] ํ๋ก์ ํธ ์์ธ์ด (4) | 2023.05.05 |
[DACON/๊น์ธ์ฐ] ํ๋ก์ ํธ ์์ธ์ด (4) | 2023.05.05 |
[DACON/๊น๊ท๋ฆฌ] ํ๋ก์ ํธ ์์ธ์ด (4) | 2023.05.05 |