์์ง ์ฐ์ฃผ์ ์ ์๋ ์ํ์ง๋ง, ๋ธ๋ก๊ทธ์ ์ ๋ฆฌํ๋ฉด์ ์กฐ๊ธ ๋ ์ดํดํ ์ ์์ง ์์๊น... ํ๋ ์๊ฐ์ด๋ค.
๋๊ตฌ์๊ฒ ์ ๋ณด๋ฅผ ์ฃผ๊ณ ์ ์ฐ๋ ๊ธ๋ ์๋๊ณ ๋จ์ํ ์ผ์ง์ด๋ ๊ฐ๋ณ๊ฒ ๋ด์ฃผ์๊ธธใ ใ (ํ๋ฆฐ ์ ๋ณด ์ง์ ์ ๋ํ์ํฉ๋๋ค)
๋จธ์ ๋ฌ๋
: ์ธ๊ณต์ง๋ฅ(AI)์ ํ ๋ถ์ผ๋ก, ๋ฐ์ดํฐ ์์์ ํจํด(๊ท์น)์ ์ฐพ์๋ด์ด ํ์ตํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ๋ ๋ถ์๋ฐฉ๋ฒ.์ฌ๋์ด ์ผํ๋ฉด ๋ฌ๋๋จธ์ / ๊ธฐ๊ณ๊ฐ ์ผํ๋ฉด ๋จธ์ ๋ฌ๋ ← ์ด๊ฑฐ ์๊ฒผ๋ค...^^
๋จธ์ ๋ฌ๋์ ๋ค์ํ ํ์ต๋ฐฉ๋ฒ
์ง๋ํ์ต(supervised Learning)
- '์ ๋ต์ด ์๋ ๋ฐ์ดํฐ'๋ฅผ ํ์ฉํด ๋ฐ์ดํฐ๋ฅผ ํ์ต์ํจ๋ค.
- ํ๋ จ๋ฐ์ดํฐ(์ /์ถ๋ ฅ ๋ฐ์ดํฐ)๋ฅผ ํตํด ํ๋ จ.
- ๋ฐ๋ผ์ ์
๋ ฅ๊ฐ(
X data)์ด ์ฃผ์ด์ง๋ฉด ๊ทธ์ ๋ํ ์ ๋ต(Y data)์ ๋ฐ์ดํฐ์์ ์ง์ ํด์ฃผ์ด์ผ ํ๋ค.
๋ถ๋ฅ(classfication)๊ณผ ํ๊ท(regression)
- ๋ถ๋ฅ: ์ด์ง๋ถ๋ฅ(True/False), ๋ค์ค๋ถ๋ฅ
- ํ๊ท: ์ด๋ค ๋ฐ์ดํฐ๋ค์ ํน์ง์ ํ ๋๋ก ๊ฐ์ ์์ธกํ๋๊ฒ.
ex) Q: ์ด๋ ๋๋ค์ ์ด๋ค ํ์ ์ํํธ๋ฉด ์ง ๊ฐ์ด ์ด๋์ ๋์ผ?
A: ์ด๋ ๋๋ค์ 24ํ์ด๋ฉด ์ผ๋ง, ์ด๋ ๋๋ค์ 32ํ์ด๋ฉด ์ผ๋ง, ์ด๋ ๋๋ค์ 45ํ์ด๋ฉด ์ผ๋ง์ ๋๋ค.
๋น์ง๋ํ์ต(Unsupervised Learning)
- '์ ๋ต ๋ผ๋ฒจ์ด ์๋ ๋ฐ์ดํฐ'๋ฅผ ํ๋ จ์ ํตํด ๋น์ทํ ํน์ง๋ผ๋ฆฌ ๊ตฐ์งํํ์ฌ ์๋ก์ด ๋ฐ์ดํฐ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ์์ธกํ๋ค.
- ์ ๋ ฅ ๋ฐ์ดํฐ๋ฅผ ํ์ตํ ๋ค, ๊ด๋ จ์ฑ์ด ์๊ณ ํ์ต ๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ์ฌ์ฉํด ํจํด๊ณผ ์๊ด๊ด๊ณ๋ฅผ ์ธ์ํ๋ค.
- ๋จธ์ ๋ฌ๋ ๊ธฐ์ค '์ด์ฉ ๊ฐ๋ฅํ ์ ๋ ฅ ๋ฐ์ดํฐ์ ์' = '๊ฒฝํ' ์ด๋ค.
- ๋๋ฌธ์ ๋ฐ์ดํฐ์ ์, ๋ฐ์ดํฐ์ ์ง์ด ์ค์ํ๋ค.
- ์๋ฉด์ธ์, ์ ์ ์ ์์ด ๋ถ์, ์์ฅ ์กฐ์ฌ, ์ฌ์ด๋ฒ ๋ณด์ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ์ฐ์ธ๋ค.
๊ตฐ์ง(Clustering)
: ์๋ก ์ ์ฌํ ์ ๋์ ๋ฐ๋ผ ๋ค์์ ๊ฐ์ฒด๋ฅผ ๊ตฐ์ง์ผ๋ก ๋๋๋ ์์ / ์ด์ ๊ธฐ๋ฐํ ๋ถ์
- ๊ณ์ธตํ ํด๋ฌ์คํฐ๋ง / ๋น๊ณ์ธตํ ํด๋ฌ์คํฐ๋ง
- K-means Clustering: ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉ์๊ฐ ์ง์ ํ K๊ฐ์ ๊ตฐ์ง์ผ๋ก ๋๋.
- Hierarchical Clustering(๊ณ์ธต์ ๊ตฐ์ง๋ถ์): ๋๋ฌด ๋ชจ์์ ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ํ์ฑํด๋๊ฐ๋ ๋ฐฉ๋ฒ
- DBSCAN: k๊ฐ๋ฅผ ์ค์ ํ ํ์์์ด ๊ตฐ์งํํ ์ ์๋ ๋ฐฉ๋ฒ
๊ฐํํ์ต(Reinforcement Learning)
: ๋จธ์ ๋ฌ๋์ ๊ฝ! ์ด๋ผ ํ๋ค.
- ๋ถ๋ฅํ ์ ์๋ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋๊ฒ๋ ์๋๊ณ , ๋ฐ์ดํฐ๊ฐ ์์ด๋ ๋ฐ๋ก ์ ๋ต์ด ์ ํด์ ธ์์ง๋ ์๋ค.
- ์์ ์ด ํ ํ๋์ ๋ํด ๋ณด์(reward)์ ๋ฐ์ผ๋ฉฐ ํ์ตํ๋๊ฒ.
์์ ์ Ford์๋์ฐจ ์ฐ๊ตฌ์๋์ ๊ฐ์ฐ์ ๋ค์ ์ ์ด ์์๋๋ฐ, ์์จ์ฃผํ ์๋น์ค์ ๊ฐํํ์ต์ ์ฌ์ฉํ์ จ๋ค๋ ๋ง์์ ํ์ จ๋ค.(์๋ง๋)
'๋ณด์'์ด๋ผ ํ๋ ๋ ์ค๋ฅด๋ ๊ธฐ์ต ใ ใ
์ค์ง๋ํ์ต(Semi-Supervised Learning)
- ๋ผ๋ฒจ๋ง ๋ฐ์ดํฐ ์ค์ ๊ฒฐ์ธก์น๊ฐ ์์๋ ์ฌ์ฉ.
๋จธ์ ๋ฌ๋ ๊ฐ๋ฐ ์์
๋ฌด์์ ๋ฐ๋ผํ๊ธฐ ์ค์ต!
1. ๋ฐ์ดํฐ import
CSVํ์ผ ์ฝ์ด๋ค์ด๊ธฐ, ํจ์ ํธ์ถ(์ฌ์ดํท๋ฐ ๋ฑ), Zipํ์ผ๋ก ์์ถ๋ ํ์ผ ์ฝ๊ธฐ, APIํธ์ถ ๋ฑ ๋ฐฉ๋ฒ์ ๋ค์ํ๋ค.
์ค๋ ์ค์ต์์๋ ์ฌ์ดํท๋ฐ์ ์ด์ฉํด ํ์ดํ๋ ๋ฐ์ดํฐ์
์ ํธ์ถํ๋ค.
from sklearn.datasets import fetch_openml
# fetch_openml์ ์ฌ์ฉํ์ฌ ํ์ดํ๋ ๋ฐ์ดํฐ์
์ ๋ถ๋ฌ์ต๋๋ค.
titanic = fetch_openml('titanic', version=1, as_frame=True)
# ๋ฐ์ดํฐ ํ๋ ์์ผ๋ก ๋ณํ
titanic_data = titanic.frame
2. ๋ฐ์ดํฐ ํ์ธ
describe()๋ display()ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
# ๋ฐ์ดํฐ์ ์ฒ์ 5ํ์ ์ถ๋ ฅํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ดํด๋ด
๋๋ค.
print(titanic_data.head())
# ๋ฐ์ดํฐ์
์ ํต๊ณ์ ์์ฝ์ ์ถ๋ ฅํฉ๋๋ค.
print("<์์ฝ>")
print(titanic_data.describe())
# ๊ฒฐ์ธก์น๊ฐ ์๋์ง ํ์ธํฉ๋๋ค.
print("<๊ฒฐ์ธก์น ํ์ธ>")
print(titanic_data.isnull().sum())
3. ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ
์ค์ํ ํํธ๋ค.
<๊ฒฐ์ธก์น ์ฒ๋ฆฌ>
๋ง์ฝ 1300๊ฐ ์ค 250๊ฐ์ ๊ฐ์ด ๊ฒฐ์ธก์น๋ผ๋ฉด?
(1) ๋ฐ์ดํฐ ์ ๊ฑฐ
> ์ฝ 20%์ ๋ฐ์ดํฐ ์์ค์ด ์ผ์ด๋๋ค. ๋ชจ๋ธ ์ฑ๋ฅ์ด ๋จ์ด์ง ์ ์๋ค.
(2) ๋ฐ์ดํฐ ๋์ฒด
> ๊ฐ์ ์ ๋ชจ๋ฅด๋ ์ํ์์ ๋์ฒดํ๋ค๋ฉด(์ด๋ฆฐ๋ค๋ฉด), 1300๊ฐ๋ฅผ ์จ์ ํ ์ธ ์ ์์ผ๋ ๋ฐ์ดํฐ ์์ฒด๋ ํ๋ณด๋ ์
์ด๋ค.
ํ์ง๋ง ์ ๋น์ฑ์ด ๋จ์ด์ง ์ ์๋ค.
=> ์ค์ง๋ํ์ต ๋ค๋ฅธ ๋ฐ์ดํฐ์ ๊ธฐ๋ฐํด์ ์ถ์ ํด๋ณด์!
๋๋ ์๋ก์ด ๋ณ์๊ฐ ์๋์ง ์๊ฐํด๋ณด์.
import pandas as pd
# ('age')๋ณ์์ ํ๊ท ๊ฐ์ผ๋ก null๊ฐ์ ์ฑ์๋ผ => ๊ธฐ์กด ๋ฐ์ดํฐ์ ์
๋ฐ์ดํธ ํด๋ผ
titanic_data['age'].fillna(titanic_data['age'].mean(), inplace=True)
# ์ฑ๋ณ ์ธ์ฝ๋ฉ์ ํด์ค์ผ ๋ถ์ํ๊ธฐ ํธํ๋ค. ๋จ์๋ 0 ์ฌ์๋ 1๋ก ์ธ์ฝ๋ฉํด์ค.
titanic_data['sex'] = titanic_data['sex'].map({'male': 0, 'female': 1})
# ์ด์ ๋ํด์ ์ ๊ฑฐ
titanic_data = titanic_data.drop(['name', 'ticket', 'cabin', 'embarked', 'boat', 'body', 'home.dest'], axis=1)
print(titanic_data.info())

'fare'์ปฌ๋ผ์ ๊ฒฐ์ธก์น๋ ์ ๊ฑฐํด์ฃผ์.
titanic_data['fare'].fillna(titanic_data['fare'].mean(), inplace=True)
print(titanic_data.info())

๊ฒฐ์ธก์น๊ฐ ์ ์ ๊ฑฐ๋๊ฒ์ ํ์ธํ ์ ์๋ค.
4. ๋ฐ์ดํฐ ๋ถํ
: ๋ฐ์ดํฐ๋ฅผ ์ํ ์ข์ฐ๋ก ๋๋๋ ๊ฒ. ์ด๋ฅผ ๋๋์ด ์ ํ๋๋ฅผ ํ๊ฐํ๊ฑฐ๋ ๋ค์ํ ์ผ์ด์ค๋ก ๋น๊ตํด๋ณด๋๊ฒ์ด ๋ชฉ์ ์ด๋ค.
๋ณดํต์ ์ ํ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ํ๊ฐ๋ฅผ ํ์ง๋ง ๊ธฐ์ค์ ๋ค์ํ๋ฉฐ, ํ ์คํธ ๋ฐ์ดํฐ์๋ ์ ๋ train ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ์์ง ์๊ฒ ์ฃผ์ํด์ผํฉ๋๋ค. ๋ง์ฝ 100%๊ฐ๊น์ด ์ ํ๋๋ฅผ train data๋ฅผ ์ ํฉํ์๋ ๋ณด์ด์ง๋ง test์์๋ ๋ฎ์ ์ฑ๋ฅ์ด ๋์จ๋ค๋ฉด ๊ณผ์ ํฉ์ ์์ฌํด์ผํฉ๋๋ค.
from sklearn.model_selection import train_test_split
# ์
๋ ฅ ๋ณ์์ ํ๊ฒ ๋ณ์ ๋ถ๋ฆฌ
X = titanic_data.drop(['survived'], axis=1) # 'survived' ์ปฌ๋ผ ์ ์ธ # X์๋ ํ๊ฒ์ด ์์ผ๋ฉด ์๋จ!
y = titanic_data['survived'] # ํ๊ฒ ๋ณ์ # y์๋ง ์ ๋ต์ด ์์ด์ผํ๋ค.
# ๋ฐ์ดํฐ ๋ถํ : ํ๋ จ ์ธํธ 80%, ํ
์คํธ ์ธํธ 20%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # random_state -> ๊ณ ์ ๋ ๊ฐ์ผ๋ก ๋ถํ ์ด ๊ฐ๋ฅ
5. ์๊ณ ๋ฆฌ์ฆ ์ ํํ๊ธฐ
๋๋ถ๋ถ์ Sklearn์ด๋ XGBoost๋ฑ์ ํ์ฉํ์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์ ๋ด์ฅ๋์ด์๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ค.
์ค์ต์์๋ ์ฌ์ดํท๋ฐ์ ๋๋ค ํฌ๋ ์คํธ๋ฅผ ์ฌ์ฉํ๋ค.
(๋๋ค ํฌ๋ ์คํธ๋ ์์๋ธ ์๊ณ ๋ฆฌ์ฆ ์ค ๋ํ๊ฒฉ. ๋ํ์์ด๋ผ๊ณ ํ๋๋ฐ ๋๋ ์ ๋ชจ๋ฅธ๋ค!)
from sklearn.ensemble import RandomForestClassifier
# ๋๋ค ํฌ๋ ์คํธ ๋ถ๋ฅ๊ธฐ ์ธ์คํด์ค ์์ฑ
model = RandomForestClassifier(random_state=42)
6. ํ์ต
: ๋ฐ์ดํฐ์ ๋ชจ๋ธ์ด ๋ชจ๋ ์ค๋น๋ ์ํ. fitํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ธ์ ํ์ตํ๋ค.
model.fit(X_train, y_train)

7. ์์ธก
# ํ
์คํธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ predict(์์ธก)ํ๋ค.
predictions = model.predict(X_test)
8. ํ๊ฐ
์ค์ ๊ฐ๊ณผ ์์ธก๋๊ฐ์ด ์ค์ ๋ก ์ ์ผ์นํ๋์ง ์ ๊ฒ! → ์ ํ๋
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, predictions) # ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋น๊ตํด์ค.
print(f"Accuracy: {accuracy}") # ๋ ๋ฐ์ดํฐ๊ฐ ์ผ๋ง๋ ์ผ์นํ๋์ง ์ ๊ฒ
# ์ถ๋ ฅ
# Accuracy: 0.7862595419847328
์ด์ ๋๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค...
(1) EDA๋ก ๋ค์ ๋์๊ฐ์ ์ฒ์๋ถํฐ ์งํ! → 78% ๋ง์์ ์๋ค์ด → 90%(์์์ , ํ์์ )
(2) ๋๋ ์ด ์ฑ๋ฅ์ ๋ง์กฑํ๋๊น ํ์ดํผํ๋ผ๋ฏธํฐ ํ๋!
>> ์ค์ ๋ก๋ 1๋ฒ์ ํ 10๋ฒํ๊ณ 2๋ฒ์ ๋งจ ๋ง์ง๋ง์ ํ๋๊ฒ ํ์ค์ด๋ผ๊ณ ํ๋คใ
ใ
import matplotlib.pyplot as plt
# ๋ณ์ ์ค์๋ ์ถ์ถ
feature_importances = model.feature_importances_
# ๋ณ์ ์ด๋ฆ๊ณผ ์ค์๋๋ฅผ ๋งคํ
feature_names = X_train.columns
feature_importance_dict = dict(zip(feature_names, feature_importances))
# ์ค์๋์ ๋ฐ๋ผ ๋ณ์ ์ ๋ ฌ
sorted_importance = sorted(feature_importance_dict.items(), key=lambda x: x[1], reverse=True)
# ์ค์๋ ์๊ฐํ
plt.figure(figsize=(10, 8))
plt.barh([item[0] for item in sorted_importance], [item[1] for item in sorted_importance])
plt.xlabel('Importance')
plt.ylabel('Feature')
plt.title('Feature Importances in Random Forest Model')
plt.gca().invert_yaxis() # ๋์ ์ค์๋๊ฐ ์๋ก ์ค๊ฒ ์ ๋ ฌ
plt.show()

# pclass, sibsp, parch๋ฅผ ํฉ์น๊ฐ์ด ์์ ๊ฐ๋ณด๋ค ๋์์ผ ๊ฐ์น๊ฐ ์๋ ๋ฐ์ดํฐ๋ค.
# ๊ทธ๋ฌ๋ฏ๋ก ์ฌ์ค ์ด ๋ฐ์ดํฐ๋ ํ๋ฆฐ ๋ฐ์ดํฐ์.
9. ํ๋
์ด๋์ ๋์ ์ ํ๋๊ฐ ๋์๋ค๋ฉด ํ๋์ผ๋ก ํ์ด๊ฐ ์ ์๋ค.
์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ ํํ๊ฑฐ๋ ํ๋ผ๋ฏธํฐ ์กฐ์ , ํน์ง๊ฐ ์ต์ ํ ๋ฑ ๋ค์ํ ๋ฐฉ๋ฒ๋ก ์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ ์ด๊ฑด ๊ฐ์ธ์ ๋ชซ.
from sklearn.model_selection import GridSearchCV
param_grid = {'n_estimators': [50, 100, 200], 'max_depth': [5, 10, 20]} # 1000~2000๋ฒ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌ๋น!
grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_train, y_train)
predictions_grid = grid_search.predict(X_test)
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, predictions_grid) # ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋น๊ตํด์ค.
print(f"Accuracy: {accuracy}") # ๋ ๋ฐ์ดํฐ๊ฐ ์ผ๋ง๋ ์ผ์นํ๋์ง ์ ๊ฒ
# ์ถ๋ ฅ
# Accuracy: 0.7748091603053435 ← ํฐ ์ฐจ์ด๋ ์์ง๋ง ๋ณํ๊ฐ ์๋ค.
๋จธ์ ๋ฌ๋์ ์ฌ์ฉํ ๋ ๊ณ ๋ คํด์ผํ ์ฌํญ๋ค
- ๊ธฐ์กด๋ณด๋ค ์ฑ๋ฅ์ด ์ข์์ก๋๊ฐ?(์ค์) → ๋ฌด์์ ํ๋๊ฐ์ ๊ธฐ์กด๋ณด๋ค ์ข์์ผ ์ฑ๊ณผ
- ๋ณ์ ์ค์๋๋ ๊ณ ๋ฅด๊ฒ ์ ๊ตฌ์ฑ๋์๋๊ฐ? → ๊ณ๋จ์์ผ๋ก ๊ตฌ์ฑ๋์ด์ผํจ
- ์๋ก์ด ๋ณ์๋ก ์ฌ์ฉํ ๋งํ ๊ฒ์ ์๋๊ฐ?
- ๋ชจ๋ธ ๋น๊ต๋ ์ถฉ๋ถํ๊ฒ ํ๋์ง?
- ๊ณผ์ ํฉ์ด ๋ฐ์ํ์ง ์์๋๊ฐ?(์ค์)
- Train๊ณผ Test๊ฐ ์ฑ๋ฅ์ฐจ์ด๊ฐ 10% ์ด์ ์ฐจ์ด๋์ง๋ ์๋๊ฐ?
- ๋ชจ๋ธ์ ๋ํ ์ค๋ช ์ด ๊ฐ๋ฅํ๊ฐ?
๊ณผ์ ํฉ
: ํ์ต๋ ๋ฐ์ดํฐ๋ง ์ ๋ง์ถ๋๊ฒ์ ์๋ฏธํ๋ค. ๋ณดํต ํ์ต๊ณผ ํ๊ฐ๊ฐ์ 10%์ด์ ์ฐจ์ด๊ฐ ๋ฐ์ํ๋ฉด ๊ณผ์ ํฉ์ด๋ผ ํ์ ํ๋ค.
๊ทธ๋ฆฌ๊ณ ํ๊ท๋ถ์ ํํธ๋ก ๋์ด๊ฐ๋ค. ๋๋ ์ฐ์ฃผ๋ฅผ ๋์ด ๊ทธ ์ด๋๊ฐ๋ก ํฅํ๊ธฐ ์์ํ๋ค...(๊ฐ์ฌ๋์ ์ต๊ณ ์ จ๋ค)
์ฌ์ค ํ๊ท ํํธ์์๋ ๋๋ฌด ํผ๋ฏธํ๊ธฐ ๋๋ฌธ์... ๋ณต์ตํ ์๊ฐ์ด ๋ ํ์ํ๋ค.
๊ธฐ์ต๋๋ ๋ถ๋ถ์ '์ค์ฆ๋น'์ ๋ํด์๋ง ์ ๋ฆฌํด๋ณด๊ฒ ๋ค.
๋๋จธ์ง ๋ถ๋ถ์ ๋ณต์ต์ ํ ๋ค์ ์ถ๊ฐ๋ก ์ ์ด๋ฃ๊ฒ ๋ค.
์ค์ฆ๋น(Odds Ratio, OR, ๊ต์ฐจ๋น, ์น์ฐ๋น)
: ์ด๋ค ์ฌ๊ฑด์ด ์ผ์ด๋ ํ๋ฅ (P)์ ์ฌ๊ฑด์ด ์ผ์ด๋์ง ์์ ํ๋ฅ (1-P)๋ก ๋๋ ๊ฐ.

์๋ฌดํผ ๋ฐ์ดํฐ์ ์ธ๊ณ๋ ๋๋ค.
https://colab.research.google.com/drive/18v2HYocFraQ_9pg8z_OOHk-JB3NaGYCk?usp=sharing
240123_๋จธ์ ๋ฌ๋_๋ฌด์์ ๋ฐ๋ผํ๊ธฐ.ipynb
Colaboratory notebook
colab.research.google.com
https://colab.research.google.com/drive/1M_5yezOd0C8LoL4Um64rIr8bq8HjRdeQ?usp=sharing
240123_๋จธ์ ๋ฌ๋_ํ๊ท.ipynb
Colaboratory notebook
colab.research.google.com

์ฐจ์์ด ๋ค๋ฅธ ์ฐ์ฃผ์๋ค... ์ด๋ฒ์ฃผ๋ง์๋ ์ ๋ง ๋ณต์ตํด์ผ๊ฒ ๋ค... ํ์ดํ ...!!!!!!