Ver5.0 ๐ค ๋จธ์ ๋ฌ๋ ์ ๋ฌธ๋ถํฐ ์ค์ ๊น์ง: Scikit-learnยทTensorFlowยทPyTorch๋ก ๋ง๋๋ ํ์ด์ฌ AI ๋ชจ๋ธ ๊ฐ๋ฐ ๐

๐ค ๋จธ์ ๋ฌ๋ ์ ๋ฌธ๋ถํฐ ์ค์ ๊น์ง: Scikit-learnยทTensorFlowยทPyTorch๋ก ๋ง๋๋ ํ์ด์ฌ AI ๋ชจ๋ธ ๊ฐ๋ฐ ๐
โAI ๋ชจ๋ธ ๋ง๋ ๋คโ๋ ๋ง, ๋ง์ ๋ค์ผ๋ฉด ๊ฑฐ์ฐฝํ์ง? ๊ทผ๋ฐ ๋ฏ์ด๋ณด๋ฉด ๋ฐ์ดํฐ โ ๋ชจ๋ธ โ ํ์ต โ ํ๊ฐ โ ๋ฐฐํฌ๋ผ๋ ๊ฝค ์ ์งํ ํ๋ฆ์ด์ผ. ์ค๋์ ์น๊ตฌํํ ์ปคํผ ํ ์ ์ฌ์ฃผ๋ฉด์ ์ค๋ช ํ๋ฏ, ํ์ด์ฌ 3๋์ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๊ทธ ํ๋ฆ์ ํ๋์ฉ ๊ฐ์ด ๊ฑธ์ด๊ฐ ๋ณด์ โ
๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ ๋ชจ๋ธ๋ก ํ์ต๋๊ณ ์์ธก์ด ๋์ค๋ ํ๋ฆ, ๊ทธ๋ฆฌ๊ณ ์ด๋ฅผ ๋ฐ์ณ์ฃผ๋ ํ์ด์ฌ 3๋ ๋๊ตฌ
1. ๋จธ์ ๋ฌ๋, ๋์ฒด ์ ์ฒด๊ฐ ๋ญ์ผ? ๐ง
๋จผ์ ์คํด ํ๋๋ถํฐ ํ๊ณ ๊ฐ์. ๋จธ์ ๋ฌ๋์ ์ปดํจํฐ๊ฐ โ์ค์ค๋ก ์๊ฐํ๋โ ๋ง๋ฒ์ด ์๋์ผ. ์ ํํ ๋งํ๋ฉด ๋ฐ์ดํฐ์์ ๊ท์น(ํจ์)์ ์๋์ผ๋ก ์ฐพ์๋ด๋ ๊ธฐ์ ์ด์ผ.
์ ํต์ ์ธ ํ๋ก๊ทธ๋๋ฐ์ ์ฌ๋์ด ๊ท์น์ ์ง์ ์ง. โ๋ฉ์ผ ์ ๋ชฉ์ โ๋ฌด๋ฃโ์ โ๋น์ฒจโ์ด ์์ผ๋ฉด ์คํธโ ์ด๋ฐ ์์ผ๋ก ๋ง์ด์ง. ๋จธ์ ๋ฌ๋์ ๋ฐ๋๋ก ๊ฐ. ์คํธ ๋ฉ์ผ ์์ฒ ๊ฐ์ ์ ์ ๋ฉ์ผ ์์ฒ ๊ฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ฉด, ์ปดํจํฐ๊ฐ โ์ด๋ฐ ํจํด์ด๋ฉด ์คํธ์ผ ํ๋ฅ ์ด ๋๋คโ ํ๋ ๊ท์น์ ํต๊ณ์ ์ผ๋ก ์ถ์ ํด ๋ด๋ ๊ฑฐ์ผ.
์ํ์ ์ผ๋ก ์ฐ๋ฉด ์์ฃผ ๋จ์ํด. ์ ๋ ฅ x์ ์ ๋ต y๊ฐ ์์ ๋, y โ f(x)๊ฐ ๋๋๋ก ํ๋ ํจ์ f๋ฅผ ์ฐพ๋ ๊ฒ. ๊ทธ๋ฆฌ๊ณ ๊ทธ f๋ฅผ ์ฐพ๋ ๊ณผ์ ์ ํ์ต(training), ์ฐพ์๋ธ f๋ฅผ ๋ชจ๋ธ(model)์ด๋ผ๊ณ ๋ถ๋ฌ. f์ ๋ชจ์์ ๊ฒฐ์ ํ๋ ์ซ์๋ค(์ง์ ์ด๋ผ๋ฉด ๊ธฐ์ธ๊ธฐ์ ์ ํธ)์ ํ๋ผ๋ฏธํฐ๋ผ๊ณ ํ๊ณ , ์ฌ๋์ด ํ์ต ์ ์ ์ ํด์ฃผ๋ ์ค์ ๊ฐ(ํ์ต๋ฅ , ํธ๋ฆฌ ๊น์ด ๋ฑ)์ ํ์ดํผํ๋ผ๋ฏธํฐ๋ผ๊ณ ๊ตฌ๋ถํด.
1-1. ํ์ต ๋ฐฉ์ 3์ด์ฌ
์์ฆ์ ์ฌ๊ธฐ์ ์๊ธฐ์ง๋ํ์ต(Self-supervised)๋ ์์ฃผ ๋ฑ์ฅํด. ๋ฌธ์ฅ์ ๋ค์ ๋จ์ด๋ฅผ ๋งํ๊ฑฐ๋ ๊ฐ๋ ค์ง ๋จ์ด๋ฅผ ๋ณต์ํ๋ ์์ผ๋ก, ๋ฐ์ดํฐ ์ค์ค๋ก ์ ๋ต์ ๋ง๋ค์ด ํ์ตํ๋ ๋ฐฉ์์ด์ผ. GPTยทBERT ๊ฐ์ ์ธ์ด ๋ชจ๋ธ์ ์ฌ์ ํ์ต์ด ๋ฐ๋ก ์ด ์๋ฆฌ๋ผ์, ์ฌ์ค์ ํ๋ AI ๋ถ์ ์์ง์ด๋ผ๊ณ ๋ด๋ ๋ผ.
1-2. ์ ํํ ํ์ด์ฌ์ด์ผ?
๋จธ์ ๋ฌ๋์ C++์ด๋ ์๋ฐ๋ก๋ ํ ์ ์์ด. ๊ทธ๋ฐ๋ฐ ์
๊ณ ํ์ค์ด ํ์ด์ฌ์ด ๋ ๋ฐ์๋ ์ด์ ๊ฐ ์์ง.
์ฒซ์งธ, ๋ฌธ๋ฒ์ด ๊ฐ๊ฒฐํด์ ์คํ์ ๋นจ๋ฆฌ ๋๋ ค๋ณผ ์ ์์ด. ๋์งธ, NumPyยทpandasยทMatplotlib ๊ฐ์ ๊ณผํ ๊ณ์ฐ ์ํ๊ณ๊ฐ ์ค๋์ ๋ถํฐ ํํํ์ด. ์
์งธ, ๊ฒ์ ํ์ด์ฌ์ด์ง๋ง ์(๋ฌด๊ฑฐ์ด ํ๋ ฌ ์ฐ์ฐ)์ C/C++ยทCUDA๋ก ๋์๊ฐ์ ์๋ ์ํด๊ฐ ์๊ฐ๋ณด๋ค ์ ์ด. ๊ฒฐ๊ตญ โ์ฌ๋์ ํธํ๊ฒ, ๊ณ์ฐ์ ๋น ๋ฅด๊ฒโ๋ผ๋ ์กฐํฉ์ด ๋จนํ ๊ฑฐ์ผ.
2. ๋ชจ๋ธ ๊ฐ๋ฐ์ ํฐ ๊ทธ๋ฆผ: 7๋จ๊ณ ํ์ดํ๋ผ์ธ ๐บ๏ธ
๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋ญ๋ ๊ฐ์, AI ๋ชจ๋ธ ๊ฐ๋ฐ์ ๊ฑฐ์ ๊ฐ์ ์์๋ก ์งํ๋ผ. ์ด ์ง๋๋ฅผ ๋จธ๋ฆฌ์ ๋ฃ์ด๋๋ฉด ์ด๋ค ์ฝ๋๋ฅผ ๋ด๋ โ์, ์ง๊ธ ๋ช ๋จ๊ณ๊ตฌ๋โ ํ๊ณ ๊ฐ์ด ์.
describe(), value_counts()๊ฐ ๋จ๊ณจ์ด์ผ.3. Scikit-learn: ์ ํต ๋จธ์ ๋ฌ๋์ ๊ตญ๋ฏผ ๋๊ตฌ ๐งฐ
Scikit-learn(์ฌ์ดํท๋ฐ)์ 2007๋ ๊ตฌ๊ธ ์๋จธ ์ค๋ธ ์ฝ๋ ํ๋ก์ ํธ์์ ์ถ๋ฐํด ์ปค๋ฎค๋ํฐ๊ฐ ํค์์จ ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. ์ ํ ํ๊ท, ๊ฒฐ์ ํธ๋ฆฌ, ๋๋ค ํฌ๋ ์คํธ, SVM, k-ํ๊ท , PCA ๊ฐ์ ๊ณ ์ ์๊ณ ๋ฆฌ์ฆ ๋๋ถ๋ถ๊ณผ ์ ์ฒ๋ฆฌยทํ๊ฐ ๋๊ตฌ๋ฅผ ํ๊ณณ์ ๋ชจ์๋จ์ด. NumPyยทSciPy ์์์ ๋์๊ฐ๊ณ , ๊ธฐ๋ณธ์ ์ผ๋ก CPU ๊ธฐ๋ฐ์ด์ผ.
3-1. ์ฌ์ดํท๋ฐ์ ๋ง๋ฒ ์ฃผ๋ฌธ: fit / predict / transform
์ฌ์ดํท๋ฐ์ด ์ฌ๋๋ฐ๋ ๊ฐ์ฅ ํฐ ์ด์ ๋ ์ผ๊ด๋ API์ผ. ๊ฑฐ์ ๋ชจ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๊ท์น์ ๋ฐ๋ฅด๊ฑฐ๋ .
| ๊ฐ์ฒด ์ข ๋ฅ | ํต์ฌ ๋ฉ์๋ | ์์ |
|---|---|---|
| Estimator (์ถ์ ๊ธฐ) | fit(X, y) | ๋ชจ๋ ๋ชจ๋ธยท๋ณํ๊ธฐ์ ๊ณตํต ๋ถ๋ชจ ๊ฐ๋ |
| Predictor (์์ธก๊ธฐ) | predict(X), predict_proba(X), score(X, y) | LogisticRegression, RandomForestClassifier |
| Transformer (๋ณํ๊ธฐ) | transform(X), fit_transform(X) | StandardScaler, OneHotEncoder, PCA |
์ด ๋๋ถ์ ๋๋ค ํฌ๋ ์คํธ๋ฅผ ์ฐ๋ค๊ฐ ๊ทธ๋๋์ธํธ ๋ถ์คํ ์ผ๋ก ๋ฐ๊พธ๊ณ ์ถ์ผ๋ฉด, ๋ณดํต import ํ ์ค๊ณผ ์์ฑ์ ํ ์ค๋ง ๋ฐ๊พธ๋ฉด ๋์ด์ผ. ์ด๊ฒ ๋ณ๊ฒ ์๋ ๊ฒ ๊ฐ์ง๋ง ์คํ ์๋๋ฅผ ์์ฒญ๋๊ฒ ๋์ด์ฌ๋ ค ์ค.
3-2. ์ฒซ ๋ชจ๋ธ ๋ง๋ค์ด๋ณด๊ธฐ: ๋ถ๊ฝ ๋ถ๋ฅ
๋จธ์ ๋ฌ๋๊ณ์ โHello, World!โ์ธ ๋ถ๊ฝ(Iris) ๋ฐ์ดํฐ๋ก ๊ฐ๋ณด์. ๊ฝ๋ฐ์นจยท๊ฝ์์ ๊ธธ์ด์ ๋๋น 4๊ฐ ํน์ฑ์ผ๋ก ํ์ข 3๊ฐ์ง๋ฅผ ๋ถ๋ฅํ๋ ๋ฌธ์ ์ผ.
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
X, y = load_iris(return_X_y=True)
# stratify=y : ํด๋์ค ๋น์จ์ ์ ์งํ๋ฉฐ ๋ถํ
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train) # ํ์ต
pred = model.predict(X_test) # ์์ธก
print(accuracy_score(y_test, pred))
print(classification_report(y_test, pred))
์ฝ๋ ๋ช ์ค๋ก ํ์ตยท์์ธกยทํ๊ฐ๊น์ง ๋! random_state๋ ๋์ ์๋๋ฅผ ๊ณ ์ ํด์ ์คํํ ๋๋ง๋ค ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๊ฒ ํด์ค. ์ฌํ์ฑ์ ์ค๋ฌด์์ ์๊ฐ๋ณด๋ค ํจ์ฌ ์ค์ํด. ๋๋ฃ๊ฐ โ๋ด ์ปดํจํฐ์์ ์ ์๊ฐ ๋ค๋ฅธ๋ฐ?โ๋ผ๊ณ ํ๋ ์๊ฐ ์ง์ฅ๋ฌธ์ด ์ด๋ฆฌ๊ฑฐ๋ ๐
3-3. Pipeline๊ณผ ColumnTransformer: ๋ฐ์ดํฐ ๋์ ๋ฐฉ์ง์ ํต์ฌ
์ค์ ๋ฐ์ดํฐ๋ ์ซ์, ๋ฒ์ฃผ, ๊ฒฐ์ธก์น๊ฐ ๋ค์์ฌ ์์ด. ์ด๊ฑธ ๋ฐ๋ก๋ฐ๋ก ์ฒ๋ฆฌํ๋ค ๋ณด๋ฉด ํํ๊ฒ ์ ์ง๋ฅด๋ ์ค์๊ฐ ์๋๋ฐ, ๋ฐ๋ก ๋ฐ์ดํฐ ๋์(Data Leakage)์ผ. ์๋ฅผ ๋ค์ด ์ ์ฒด ๋ฐ์ดํฐ๋ก ํ๊ท ยทํ์คํธ์ฐจ๋ฅผ ๊ตฌํด ์ค์ผ์ผ๋งํ ๋ค ํ์ต/ํ ์คํธ๋ฅผ ๋๋๋ฉด, ํ ์คํธ ์ธํธ ์ ๋ณด๊ฐ ํ์ต์ ๋ชฐ๋ ์์ฌ ๋ค์ด๊ฐ์ ์ ์๊ฐ ์ค์ ๋ณด๋ค ๋ถํ๋ ค์ ธ.
์ฌ์ดํท๋ฐ์ Pipeline์ ์ ์ฒ๋ฆฌ์ ๋ชจ๋ธ์ ํ๋๋ก ๋ฌถ์ด์, fitํ ๋๋ ํ์ต ๋ฐ์ดํฐ๋ก๋ง ํต๊ณ๋ฅผ ๊ณ์ฐํ๊ณ ์์ธกํ ๋๋ ๊ทธ ํต๊ณ๋ฅผ ๊ทธ๋๋ก ์ ์ฉํ๊ฒ ํด์ค.
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
num_cols = ["age", "income"]
cat_cols = ["city", "job"]
preprocess = ColumnTransformer([
("num", Pipeline([
("impute", SimpleImputer(strategy="median")),
("scale", StandardScaler()),
]), num_cols),
("cat", Pipeline([
("impute", SimpleImputer(strategy="most_frequent")),
("onehot", OneHotEncoder(handle_unknown="ignore")),
]), cat_cols),
])
clf = Pipeline([
("prep", preprocess),
("model", LogisticRegression(max_iter=1000)),
])
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))
handle_unknown="ignore"๋ ํ์ต ๋ ๋ชป ๋ณธ ๋ฒ์ฃผ(์: ์๋ก ์๊ธด ๋์)๊ฐ ๋ค์ด์๋ ์๋ฌ ์์ด ์ฒ๋ฆฌํ๊ฒ ํด์ฃผ๋ ์ต์
์ด์ผ. ์ด์ ํ๊ฒฝ์์ ์๊ทผํ ์๋ช
์ค์ด ๋ผ.
3-4. ๊ต์ฐจ ๊ฒ์ฆ๊ณผ ํ์ดํผํ๋ผ๋ฏธํฐ ํ์
ํ ์คํธ ์ธํธ ํ ๋ฒ ๋๋ ์ ํ๊ฐํ๋ฉด, ์ด๋ป๊ฒ ๋๋ด๋๋์ ๋ฐ๋ผ ์ด์ด ๊ฐ์ ํด. ๊ทธ๋์ K-๊ฒน ๊ต์ฐจ ๊ฒ์ฆ(K-Fold Cross Validation)์ ์จ. ๋ฐ์ดํฐ๋ฅผ K์กฐ๊ฐ์ผ๋ก ๋๋ K๋ฒ ๋์๊ฐ๋ฉฐ ํ ์กฐ๊ฐ์ ๊ฒ์ฆ์ฉ์ผ๋ก ์ฐ๊ณ , ์ ์์ ํ๊ท ๊ณผ ํ์คํธ์ฐจ๋ฅผ ๋ณด๋ ๊ฑฐ์ผ.
from sklearn.model_selection import cross_val_score, GridSearchCV
scores = cross_val_score(clf, X_train, y_train, cv=5, scoring="f1_macro")
print(scores.mean(), scores.std())
param_grid = {"model__C": [0.01, 0.1, 1, 10]}
search = GridSearchCV(clf, param_grid, cv=5, scoring="f1_macro", n_jobs=-1)
search.fit(X_train, y_train)
print(search.best_params_, search.best_score_)
ํ์ดํ๋ผ์ธ ์์ ํ๋ผ๋ฏธํฐ๋ ๋จ๊ณ์ด๋ฆ__ํ๋ผ๋ฏธํฐ๋ช
์ฒ๋ผ ์ธ๋์ค์ฝ์ด ๋ ๊ฐ๋ก ์ ๊ทผํด. ํ์ ๋ฒ์๊ฐ ๋์ผ๋ฉด RandomizedSearchCV๊ฐ GridSearch๋ณด๋ค ํจ์จ์ ์ธ ๊ฒฝ์ฐ๊ฐ ๋ง๊ณ , ๋ ๋๋ํ ํ์์ด ํ์ํ๋ฉด Optuna ๊ฐ์ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ ์ ์ด์ธ๋ ค.
3-5. ์ฌ์ดํท๋ฐ์ ํ๊ณ
์ฌ์ดํท๋ฐ์ ๋ฒ์ฉ GPU ๊ฐ์์ ๊ธฐ๋ณธ์ผ๋ก ์ง์ํ์ง ์๊ณ (์ผ๋ถ ๊ธฐ๋ฅ์ ์คํ์ Array API ์ง์์ ์์ด), ์ด๋ฏธ์งยท์์ฑยทํ ์คํธ ๊ฐ์ ๋น์ ํ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋ ๋๊ท๋ชจ ๋ฅ๋ฌ๋์ฉ์ผ๋ก ์ค๊ณ๋์ง ์์์ด. ์ ๊ฒฝ๋ง ๋ชจ๋ธ(MLPClassifier)์ด ์๊ธด ํ์ง๋ง ๊ฐ๋จํ ๋ค์ธต ํผ์ ํธ๋ก ์์ค์ด์ผ. ๊ทธ๋์ ์ฌ์ง ์ ๊ณ ์์ด๋ฅผ ์ฐพ๊ฑฐ๋ ๋ฌธ์ฅ์ ์์ฑํ๋ ค๋ฉด ๋ค์ ์ฃผ์, TensorFlow์ PyTorch๊ฐ ๋ฑํํ ์ฐจ๋ก์ผ.
4. ๋ฅ๋ฌ๋ ๊ธฐ์ด ์ฒด๋ ฅ: ์ ๊ฒฝ๋ง๊ณผ ๊ฒฝ์ฌํ๊ฐ๋ฒ โฐ๏ธ
TensorFlow์ PyTorch๋ฅผ ์ ๋๋ก ์ฐ๋ ค๋ฉด ๋ฅ๋ฌ๋์ด ์ด๋ป๊ฒ ํ์ตํ๋์ง ์๋ฆฌ๋ฅผ ์ก๊ณ ๊ฐ์ผ ํด. ๊ฑฑ์ ๋ง, ์์ ํญํ์ ์ ๋์ง๊ฒ.
4-1. ๋ด๋ฐ ํ๋์ ์ผ
์ธ๊ณต ๋ด๋ฐ ํ๋๋ ์ ๋ ฅ๊ฐ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํด ๋ํ๊ณ (ํธํฅ ํฌํจ), ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ์ฑํ ํจ์์ ํต๊ณผ์์ผ. ์์ผ๋ก ์ฐ๋ฉด ์ถ๋ ฅ = ํ์ฑํ(wโxโ + wโxโ + โฆ + b). ํ์ฑํ ํจ์๊ฐ ์์ผ๋ฉด ์ธต์ ์๋ฌด๋ฆฌ ์์๋ ๊ฒฐ๊ตญ ํ๋์ ์ ํ ๋ณํ๊ณผ ๊ฐ์์ ธ์, ๋ณต์กํ ํจํด์ ๋ชป ๋ฐฐ์. ๊ทธ๋์ ReLU(์์๋ 0, ์์๋ ๊ทธ๋๋ก), ์๊ทธ๋ชจ์ด๋, GELU ๊ฐ์ ๋น์ ํ ํจ์๊ฐ ํ์์ผ.
4-2. ์์ค ํจ์์ ๊ฒฝ์ฌํ๊ฐ๋ฒ
๋ชจ๋ธ์ด ์ผ๋ง๋ ํ๋ ธ๋์ง๋ฅผ ์ซ์ ํ๋๋ก ํํํ ๊ฒ ์์ค ํจ์(loss)์ผ. ํ๊ท๋ ์ฃผ๋ก ํ๊ท ์ ๊ณฑ์ค์ฐจ(MSE), ๋ถ๋ฅ๋ ๊ต์ฐจ ์ํธ๋กํผ(Cross-Entropy)๋ฅผ ์จ. ํ์ต์ ๋ชฉํ๋ ์ด ์์ค์ ์ต์ํํ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐพ๋ ๊ฑฐ๊ณ , ๊ทธ ๋ฐฉ๋ฒ์ด ๊ฒฝ์ฌํ๊ฐ๋ฒ(Gradient Descent)์ด์ผ.
์๊ฐ ๋ ์ฐ์์ ๋์ ๊ฐ๋ฆฌ๊ณ ๊ณจ์ง๊ธฐ๋ก ๋ด๋ ค๊ฐ๋ค๊ณ ์์ํด ๋ด. ๋ฐ๋ฐ ๊ฒฝ์ฌ(๊ธฐ์ธ๊ธฐ, gradient)๋ฅผ ๋๊ปด์ ๊ฐ์ฅ ๊ฐํ๋ฅด๊ฒ ๋ด๋ ค๊ฐ๋ ๋ฐฉํฅ์ผ๋ก ํ ๊ฑธ์์ฉ ์ฎ๊ธฐ๋ ๊ฑฐ์ง. ์ด๋ ํ ๊ฑธ์์ ํฌ๊ธฐ๊ฐ ํ์ต๋ฅ (learning rate)์ด์ผ.
์ผ์ชฝ์ ์ ์ ํ ํ์ต๋ฅ ๋ก ์ต์๊ฐ์ ๋ค๊ฐ๊ฐ๋ ๋ชจ์ต, ์ค๋ฅธ์ชฝ์ ํ์ต๋ฅ ์ด ์ปค์ ์์ค์ด ๋ค์ ์ปค์ง๋ ๋ชจ์ต
๊ทธ๋ผ ์๋ฐฑ๋ง, ์์ญ์ต ๊ฐ์ ํ๋ผ๋ฏธํฐ ๊ฐ๊ฐ์ ๊ธฐ์ธ๊ธฐ๋ ์ด๋ป๊ฒ ๊ตฌํ ๊น? ์ฌ๊ธฐ์ ์ญ์ ํ(Backpropagation)๊ฐ ๋์. ๋ฏธ๋ถ์ ์ฐ์ ๋ฒ์น(chain rule)์ ์ด์ฉํด ์ถ๋ ฅ์ธต์์ ์ ๋ ฅ์ธต ๋ฐฉํฅ์ผ๋ก ๊ธฐ์ธ๊ธฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ณ์ฐํ๋ ์๊ณ ๋ฆฌ์ฆ์ด์ผ. ๊ทธ๋ฆฌ๊ณ TensorFlow์ PyTorch์ ํต์ฌ ๋ฅ๋ ฅ์ด ๋ฐ๋ก ์ด๊ฑธ ์๋์ผ๋ก ํด์ฃผ๋ ์๋ ๋ฏธ๋ถ(Autograd)์ด์ง. ์ฐ๋ฆฌ๋ ์์ ํ(forward) ๊ณ์ฐ๋ง ์ฐ๋ฉด, ๊ธฐ์ธ๊ธฐ๋ ํ๋ ์์ํฌ๊ฐ ์์์ ๊ตฌํด์ค.
| ์ฉ์ด | ์ฝ๊ฒ ๋งํ๋ฉด |
|---|---|
| ๋ฐฐ์น(batch) | ํ ๋ฒ์ ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ณ์ฐํ๋ ๋ฐ์ดํฐ ๋ฌถ์. ์ ์ฒด๋ฅผ ํ ๋ฒ์ ์ฐ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํด์ ์ชผ๊ฐ ์ |
| ๋ฏธ๋๋ฐฐ์น SGD | ๋ฐฐ์น ๋จ์๋ก ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํด ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐฑ์ ํ๋ ๋ฐฉ์. ๋ฅ๋ฌ๋ ํ์ต์ ๊ธฐ๋ณธ |
| ์ํญ(epoch) | ์ ์ฒด ํ์ต ๋ฐ์ดํฐ๋ฅผ ํ ๋ฐํด ๋ค ๋ณธ ํ์ |
| ์ตํฐ๋ง์ด์ | ๋ณดํญ๊ณผ ๋ฐฉํฅ์ ์กฐ์ ํ๋ ์ ๋ต. SGD+๋ชจ๋ฉํ , Adam, AdamW ๋ฑ์ด ๋ํ์ |
| ํ ์(tensor) | ๋ค์ฐจ์ ๋ฐฐ์ด. ์ค์นผ๋ผ(0์ฐจ์)ยท๋ฒกํฐ(1์ฐจ์)ยทํ๋ ฌ(2์ฐจ์)์ ์ผ๋ฐํํ ๊ฐ๋ |
5. TensorFlow & Keras: ๊ตฌ๊ธ์ด ํค์ด ํ๋ก๋์ ๊ฐ์ ๐ญ
TensorFlow๋ ๊ตฌ๊ธ ๋ธ๋ ์ธ ํ์ด ๊ฐ๋ฐํด 2015๋ 11์ ์คํ์์ค๋ก ๊ณต๊ฐํ์ด. ์ด๊ธฐ 1.x ์์ ์ ์ฐ์ฐ ๊ทธ๋ํ๋ฅผ ๋จผ์ ์ ์ํ๊ณ ์ธ์ (Session)์ผ๋ก ์คํํ๋ ๋ฐฉ์์ด๋ผ ๋๋ฒ๊น ์ด ๊ฝค ๊ณ ํต์ค๋ฌ์ ๋๋ฐ, 2019๋ TensorFlow 2.0์์ ์ฆ์ ์คํ(Eager Execution)์ ๊ธฐ๋ณธ์ผ๋ก ๋ฐ๊พธ๊ณ ๊ณ ์์ค API์ธ Keras๋ฅผ ๊ณต์ ์ธํฐํ์ด์ค๋ก ์ฑํํ๋ฉด์ ํจ์ฌ ์น์ ํด์ก์ด.
tf.keras๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก Keras 3๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๊ณ , ์์ Keras 2 ๋์์ด ํ์ํ๋ฉด ๋ณ๋ ํจํค์ง(tf_keras)๋ฅผ ์ฐ๋ ์์ด์ผ. ๊ทธ๋์ ์ค๋๋ ๋ธ๋ก๊ทธ ์ฝ๋๊ฐ ์ต์ ํ๊ฒฝ์์ ์๋ฌ๊ฐ ๋๋ ๊ฒฝ์ฐ๊ฐ ์ข
์ข
์์ด. ๋ฒ์ ํ์ธ์ ์ต๊ด์ฒ๋ผ!
5-1. Keras๋ก ์๊ธ์จ ์ซ์ ๋ถ๋ฅํ๊ธฐ
๋ฅ๋ฌ๋๊ณ์ โHello, World!โ๋ MNIST์ผ. 28ร28 ํฝ์ ํ๋ฐฑ ์๊ธ์จ ์ซ์(0~9) ์ด๋ฏธ์ง 7๋ง ์ฅ(ํ์ต 6๋ง, ํ ์คํธ 1๋ง)์ผ๋ก ๊ตฌ์ฑ๋ผ ์์ง. ์์ ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNN)์ ๋ง๋ค์ด ๋ณด์.
import keras
from keras import layers
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train[..., None].astype("float32") / 255.0 # (60000, 28, 28, 1)
x_test = x_test[..., None].astype("float32") / 255.0
model = keras.Sequential([
keras.Input(shape=(28, 28, 1)),
layers.Conv2D(32, 3, activation="relu"),
layers.MaxPooling2D(),
layers.Conv2D(64, 3, activation="relu"),
layers.MaxPooling2D(),
layers.Flatten(),
layers.Dropout(0.3),
layers.Dense(10, activation="softmax"),
])
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"],
)
history = model.fit(
x_train, y_train,
batch_size=128, epochs=10,
validation_split=0.1,
callbacks=[keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True)],
)
model.evaluate(x_test, y_test)
Keras์ ์ฒ ํ์ compile โ fit โ evaluate ์ธ ๋ฐ์์ผ. ํ์ต ๋ฃจํ๋ฅผ ์ง์ ์งค ํ์ ์์ด, ์ตํฐ๋ง์ด์ ยท์์คยท์งํ๋ง ์ ํด์ฃผ๋ฉด ๋ฐฐ์น ๋๋๊ธฐ, ๊ธฐ์ธ๊ธฐ ๊ณ์ฐ, ํ๋ผ๋ฏธํฐ ๊ฐฑ์ , ์งํ๋ฅ ์ถ๋ ฅ๊น์ง ๋ค ํด์ค. ์ด ์ ๋ CNN์ด๋ฉด MNIST ํ ์คํธ ์ ํ๋๊ฐ ๋๋ต 99% ์ํ๊น์ง ๋์ค๋ ๊ฒ ์ผ๋ฐ์ ์ด์ผ.
์ฌ๊ธฐ์ sparse_categorical_crossentropy๋ ์ ๋ต์ด ์-ํซ ๋ฒกํฐ๊ฐ ์๋๋ผ ์ ์(0~9)์ผ ๋ ์ฐ๋ ์์ค์ด์ผ. ์ ๋ต์ ์-ํซ์ผ๋ก ๋ฐ๊ฟจ๋ค๋ฉด categorical_crossentropy๋ฅผ ์จ์ผ ํด. ์ด๊ฑฐ ํท๊ฐ๋ ค์ shape ์๋ฌ ๋ณด๋ ๊ฒ ์
๋ฌธ์ ๊ตญ๋ฃฐ์ด์ผ ๐
5-2. Keras ๋ชจ๋ธ์ ๋ง๋๋ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ
keras.Model์ ์์ํด call()์ ์ง์ ์ ์. ๊ฐ์ฅ ์์ ๋กญ์ง๋ง ์ฝ๋ ๊ด๋ฆฌ ์ฑ
์๋ ์ปค์ ธ.5-3. tf.data์ tf.function: ์๋๋ฅผ ์ํ ๋ ๋ฌด๊ธฐ
๋ฐ์ดํฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ๋ค ์ ๋ค์ด๊ฐ ๋งํผ ํฌ๋ฉด tf.data API๋ก ์ ๋ ฅ ํ์ดํ๋ผ์ธ์ ๋ง๋ค์ด. ํ์ผ์ ์ฝ๊ณ , ์๊ณ (shuffle), ๋ฐฐ์น๋ก ๋ฌถ๊ณ , ๋ค์ ๋ฐฐ์น๋ฅผ ๋ฏธ๋ฆฌ ์ค๋น(prefetch)ํ๋ ๊ณผ์ ์ GPU ํ์ต๊ณผ ๋ณ๋ ฌ๋ก ์ฒ๋ฆฌํด์ GPU๊ฐ ๋ ธ๋ ์๊ฐ์ ์ค์ฌ์ค.
import tensorflow as tf
ds = (tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10_000)
.batch(128)
.prefetch(tf.data.AUTOTUNE))
@tf.function ๋ฐ์ฝ๋ ์ดํฐ๋ ํ์ด์ฌ ํจ์๋ฅผ TensorFlow ๊ทธ๋ํ๋ก ๋ณํ(ํธ๋ ์ด์ฑ)ํด์ ์ต์ ํ๋ ํํ๋ก ์คํํด ์ค. ์ฆ์ ์คํ์ ํธ๋ฆฌํจ๊ณผ ๊ทธ๋ํ ์คํ์ ์๋๋ฅผ ๋ ๋ค ์ฑ๊ธฐ๋ ์ฅ์น์ผ. Keras์ fit()์ ๋ด๋ถ์ ์ผ๋ก ์ด๋ฏธ ์ด๊ฑธ ํ์ฉํ๊ณ ์์ด.
5-4. TensorFlow ์ํ๊ณ์ ์ง์ง ๋ฌด๊ธฐ: ๋ฐฐํฌ
TensorFlow๊ฐ ์ค๋ซ๋์ ๊ธฐ์ ์์ ์ฌ๋๋ฐ์ ์ด์ ๋ ๋ฐฐํฌ ๋๊ตฌ๊ฐ ํ๋ถํด์์ผ.
| ๋๊ตฌ | ์ฉ๋ |
|---|---|
| SavedModel | ๋ชจ๋ธ ๊ตฌ์กฐยท๊ฐ์ค์นยท์ฐ์ฐ ๊ทธ๋ํ๋ฅผ ํต์งธ๋ก ์ ์ฅํ๋ TensorFlow ํ์ค ํฌ๋งท |
| TensorFlow Serving | ์ ์ฅํ ๋ชจ๋ธ์ REST/gRPC API ์๋ฒ๋ก ๋์ฐ๋ ๊ณ ์ฑ๋ฅ ์๋น ์์คํ |
| TensorFlow Lite (LiteRT) | ๋ชจ๋ฐ์ผยท์๋ฒ ๋๋ ๊ธฐ๊ธฐ์ฉ ๊ฒฝ๋ ๋ฐํ์. ์์ํ๋ก ๋ชจ๋ธ ํฌ๊ธฐยท์ง์ฐ์๊ฐ ๊ฐ์. ๊ตฌ๊ธ์ ์ต๊ทผ ์ด ๋ฐํ์์ LiteRT๋ผ๋ ์ด๋ฆ์ผ๋ก ๋ฆฌ๋ธ๋๋ฉํ์ด |
| TensorFlow.js | ๋ธ๋ผ์ฐ์ ์ Node.js์์ ๋ชจ๋ธ ์คํ |
| TFX | ๋ฐ์ดํฐ ๊ฒ์ฆ๋ถํฐ ๋ฐฐํฌ๊น์ง ์๋ํฌ์๋ ML ํ์ดํ๋ผ์ธ ํ๋ซํผ |
6. PyTorch: ์ฐ๊ตฌ์ค์์ ์์ํด ์ ๊ณ ํ์ค์ด ๋ ์น๊ตฌ ๐ฅ
PyTorch๋ ํ์ด์ค๋ถ(ํ ๋ฉํ) AI ์ฐ๊ตฌํ์ด ๊ฐ๋ฐํด 2016๋ ๊ณต๊ฐํ์ด. 2022๋ ์๋ ๋ฆฌ๋ ์ค ์ฌ๋จ ์ฐํ PyTorch ์ฌ๋จ์ผ๋ก ์ด๊ด๋์ด ํน์ ๊ธฐ์ ์ด ์๋ ์ค๋ฆฝ ์ฌ๋จ์ด ๊ด๋ฆฌํ๊ณ ์์ง. ํน์ง์ ํ๋ง๋๋ก โ๊ทธ๋ฅ ํ์ด์ฌ์ฒ๋ผ ์ด๋คโ์ผ. ์ฒ์๋ถํฐ ์ฆ์ ์คํ(define-by-run) ๋ฐฉ์์ด๋ผ ์ฝ๋๊ฐ ์ฐ์ธ ์์๋๋ก ์คํ๋๊ณ , ์ผ๋ฐ ํ์ด์ฌ ๋๋ฒ๊ฑฐ๋ก ์ค๊ฐ๊ฐ์ ์ฐ์ด๋ณผ ์ ์์ด.
์ด ์ง๊ด์ฑ ๋๋ถ์ ํ๊ณ์์ ๋น ๋ฅด๊ฒ ํผ์ก๊ณ , ์ง๊ธ์ ์ฃผ์ AI ํํ ๋ ผ๋ฌธ ๊ตฌํ๊ณผ Hugging Face์ Transformers ์ํ๊ณ, ๋ํ ์ธ์ด ๋ชจ๋ธ(LLM) ํ์ต์์ ์ฌ์ค์ ์ฃผ๋ฅ ์๋ฆฌ๋ฅผ ์ฐจ์งํ๊ณ ์์ด. Papers with Code ๊ฐ์ ๋ ผ๋ฌธ ๊ตฌํ ํต๊ณ์์๋ PyTorch ๋น์ค์ด ์๋์ ์ผ๋ก ๋๊ฒ ๋ํ๋๊ณค ํ์ง.
6-1. ํ ์์ ์๋ ๋ฏธ๋ถ ๋ง๋ณด๊ธฐ
import torch
x = torch.tensor(3.0, requires_grad=True)
y = x**2 + 2*x + 1 # y = (x+1)^2
y.backward() # ์ญ์ ํ
print(x.grad) # dy/dx = 2x + 2 = 8.0
requires_grad=True๋ก ํ์ํ ํ
์๋ ์ฐ์ฐ ๊ธฐ๋ก์ด ๋จ๊ณ , backward()๋ฅผ ํธ์ถํ๋ฉด ๊ธฐ์ธ๊ธฐ๊ฐ .grad์ ์์ฌ. ์์ผ๋ก ๋ฏธ๋ถํ๋ฉด 2x+2๋๊น x=3์์ 8. ์ ํํ ๋ง์ง? ์ด๊ฒ ์์ญ์ต ํ๋ผ๋ฏธํฐ ๋ชจ๋ธ์์๋ ๋๊ฐ์ด ๋์๊ฐ๋ค๋ ๊ฒ ๋๋ผ์ด ํฌ์ธํธ์ผ.
6-2. PyTorch ๋ชจ๋ธ์ ๊ธฐ๋ณธ ๊ณจ๊ฒฉ
PyTorch๋ ๋ชจ๋ธ์ nn.Module์ ์์ํ ํด๋์ค๋ก ๋ง๋ค๊ณ , ํ์ต ๋ฃจํ๋ ์ง์ ์จ. ์ฒ์์ Keras๋ณด๋ค ์ฝ๋๊ฐ ๊ธธ์ด ๋ณด์ด์ง๋ง, ๋ฃจํ ์์์ ๋ญ๋ ํ ์ ์๋ค๋ ์์ ๊ฐ ์ฐ๊ตฌ์๋ค์ ์ฌ๋ก์ก์์ด.
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
device = "cuda" if torch.cuda.is_available() else "cpu"
tfm = transforms.ToTensor()
train_ds = datasets.MNIST("data", train=True, download=True, transform=tfm)
test_ds = datasets.MNIST("data", train=False, download=True, transform=tfm)
train_dl = DataLoader(train_ds, batch_size=128, shuffle=True)
test_dl = DataLoader(test_ds, batch_size=256)
class Net(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, 3), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(32, 64, 3), nn.ReLU(), nn.MaxPool2d(2),
)
self.head = nn.Sequential(
nn.Flatten(), nn.Dropout(0.3), nn.Linear(64 * 5 * 5, 10)
)
def forward(self, x):
return self.head(self.features(x))
model = Net().to(device)
loss_fn = nn.CrossEntropyLoss() # ๋ด๋ถ์ softmax ํฌํจ!
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(5):
model.train()
for xb, yb in train_dl:
xb, yb = xb.to(device), yb.to(device)
optimizer.zero_grad() # 1) ๊ธฐ์ธ๊ธฐ ์ด๊ธฐํ
loss = loss_fn(model(xb), yb) # 2) ์์ ํ + ์์ค
loss.backward() # 3) ์ญ์ ํ
optimizer.step() # 4) ํ๋ผ๋ฏธํฐ ๊ฐฑ์
model.eval()
correct = 0
with torch.no_grad(): # ํ๊ฐ ๋ ๊ธฐ์ธ๊ธฐ ๊ณ์ฐ ๋๊ธฐ
for xb, yb in test_dl:
pred = model(xb.to(device)).argmax(1)
correct += (pred == yb.to(device)).sum().item()
print(epoch, correct / len(test_ds))
ํ์ต ๋ฃจํ์ ํต์ฌ์ ๋ฑ 4๋ฐ์์ผ. zero_grad โ forward โ backward โ step. ์ด๊ฑฐ ํ๋๋ง ์ธ์๋ PyTorch ์ฝ๋์ 70%๋ ์ฝํ.
optimizer.zero_grad()๋ฅผ ๋นผ๋จน๊ธฐ โ PyTorch๋ ๊ธฐ์ธ๊ธฐ๋ฅผ ๋์ ํ๊ธฐ ๋๋ฌธ์ ํ์ต์ด ์ด์ํ๊ฒ ํ์ด.โก
nn.CrossEntropyLoss ์์ softmax๋ฅผ ๋ ๋ฃ๊ธฐ โ ์ด ์์ค ํจ์๋ ๋ด๋ถ์ ์ผ๋ก log-softmax๋ฅผ ๊ณ์ฐํ๋๊น ๋ชจ๋ธ ๋ง์ง๋ง์ raw ์ ์(logits)๋ฅผ ๋ด๋ณด๋ด์ผ ํด. Keras ์์ ์ ๋ฌ๋ฆฌ ๋ง์ง๋ง ์ธต์ softmax๊ฐ ์๋ ์ด์ ์ผ.โข
model.eval()๊ณผ model.train() ์ ํ์ ์๊ธฐ โ Dropout๊ณผ BatchNorm์ ํ์ต/์ถ๋ก ๋ชจ๋์์ ๋ค๋ฅด๊ฒ ๋์ํด์, ํ๊ฐ ์ ์๊ฐ ๋ค์ฅ๋ ์ฅํด์ ธ.
6-3. ์ฝ๋ ์ ์ซ์ 64*5*5๋ ์ด๋์ ์์๊น?
์ด๋ฐ ๋ํ ์ผ์ด ์ง์ง ์ค๋ ฅ์ด๋๊น ์ง๊ณ ๊ฐ์. ์ ๋ ฅ 28ร28์ 3ร3 ํฉ์ฑ๊ณฑ(ํจ๋ฉ ์์)์ ํ๋ฉด 26ร26, 2ร2 ํ๋ง์ผ๋ก 13ร13. ๋ค์ 3ร3 ํฉ์ฑ๊ณฑ์ด๋ฉด 11ร11, ํ๋งํ๋ฉด 5ร5(๋ด๋ฆผ). ์ฑ๋์ด 64๊ฐ๋๊น ํผ์น๋ฉด 64ร5ร5 = 1,600๊ฐ ํน์ฑ์ด ๋๋ ๊ฑฐ์ผ. ํฉ์ฑ๊ณฑ ์ถ๋ ฅ ํฌ๊ธฐ ๊ณต์์ (์ ๋ ฅ โ ์ปค๋ + 2รํจ๋ฉ) รท ์คํธ๋ผ์ด๋ + 1. shape ์๋ฌ๊ฐ ๋๋ฉด ์ด ๊ณต์์ผ๋ก ์๊ณ์ฐํด ๋ณด๋ ๊ฒ ์ ์ผ ๋นจ๋ผ.
6-4. PyTorch 2.x์ torch.compile
2023๋ ๊ณต๊ฐ๋ PyTorch 2.0์ ๊ฐํ ๊ธฐ๋ฅ์ torch.compile์ด์ผ. ๋ชจ๋ธ์ ํ ์ค๋ง ๊ฐ์ธ๋ฉด ํ์ด์ฌ ์ฝ๋๋ฅผ ๊ทธ๋ํ๋ก ์บก์ฒํ๊ณ ์ต์ ํ๋ ์ปค๋์ ์์ฑํด์ ์๋๋ฅผ ๋์ด์ฌ๋ ค ์ค. ์ฆ์ ์คํ์ ํธ๋ฆฌํจ์ ๊ทธ๋๋ก ๋๊ณ ์ฑ๋ฅ์ ์ปดํ์ผ๋ฌ๊ฐ ์ฑ๊ธฐ๋ ๋ฐฉ์์ด์ง. TensorFlow์ tf.function๊ณผ ๋น์ทํ ๋ชฉํ๋ฅผ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ํผ ์ ์ด์ผ.
model = torch.compile(model) # ๊ธฐ์กด ์ฝ๋๋ ๊ทธ๋๋ก, ์ด ํ ์ค ์ถ๊ฐ
๋ค๋ง ๋ชจ๋ ๋ชจ๋ธยทํ๊ฒฝ์์ ํญ์ ๋นจ๋ผ์ง๋ ๊ฑด ์๋๊ณ , ์ฒซ ์คํ ๋ ์ปดํ์ผ ์๊ฐ์ด ๋ค์ด. ์์ ์คํ๋ณด๋ค๋ ์ค๋ ๋๋ฆฌ๋ ํ์ต์์ ํจ๊ณผ๋ฅผ ๋ณด๋ ๊ฒฝ์ฐ๊ฐ ๋ง์.
6-5. PyTorch ์ํ๊ณ
ํนํ PyTorch Lightning์ ๋ฐ๋ณต๋๋ ํ์ต ๋ฃจํ ๋ณด์ผ๋ฌํ๋ ์ดํธ๋ฅผ ์ ๋ฆฌํด์, PyTorch์ ์์ ๋๋ ์ ์งํ๋ฉด์ Keras์ฒ๋ผ ๊น๋ํ๊ฒ ์ฐ๊ฒ ํด์ฃผ๋ ๋ํผ์ผ. โ๋ฃจํ ์ง์ ์ง๋ ๊ฑฐ ๊ท์ฐฎ์๋ฐ Keras๋ก ๊ฐ์ํ๊ธด ์ซ๋คโ๋ ์ฌ๋๋ค์๊ฒ ์ธ๊ธฐ๊ฐ ๋ง์.
7. 3๋์ฅ ํ๋์ ๋น๊ต โ๏ธ
| ํญ๋ชฉ | Scikit-learn | TensorFlow (Keras) | PyTorch |
|---|---|---|---|
| ์ฃผ ์ฉ๋ | ์ ํต ๋จธ์ ๋ฌ๋, ์ ํ ๋ฐ์ดํฐ | ๋ฅ๋ฌ๋ ํ์ตยท๋๊ท๋ชจ ๋ฐฐํฌ | ๋ฅ๋ฌ๋ ์ฐ๊ตฌยท๊ฐ๋ฐ, LLM |
| GPU ๊ฐ์ | ๊ธฐ๋ณธ ๋ฏธ์ง์(CPU ์ค์ฌ) | ์ง์(GPUยทTPU) | ์ง์(CUDA, ROCm, Apple MPS ๋ฑ) |
| ํ์ต ๋ฐฉ์ | fit() ํ ์ค | compile() + fit() | ํ์ต ๋ฃจํ ์ง์ ์์ฑ |
| ๋ฌ๋ ์ปค๋ธ | ๊ฐ์ฅ ์๋ง | Keras๋ ์๋ง, ์ ์์ค์ ๊ฐํ๋ฆ | ์ค๊ฐ(ํ์ด์ฌ์ ์ต์ํ๋ฉด ์์ฐ์ค๋ฌ์) |
| ๋๋ฒ๊น | ์ฌ์ | ์ฆ์ ์คํ์ผ๋ก ๊ฐ์ ๋จ | ํ์ด์ฌ ๋๋ฒ๊ฑฐ๋ก ์ง๊ด์ |
| ๋ฐฐํฌ ๋๊ตฌ | joblib/pickle, ONNX ๋ณํ | TF Serving, TFLite(LiteRT), TF.js | TorchServe, ExecuTorch, ONNX |
| ๋ํ ์ฌ์ฉ์ฒ | ์ ์ฉํ๊ฐ, ์์์์ธก, ์ดํ ์์ธก | ๋ชจ๋ฐ์ผ ๋น์ , ๊ธฐ์ ํ๋ก๋์ | ๋ ผ๋ฌธ ๊ตฌํ, ์์ฑํ AI, ํ์ธํ๋ |
8. ๋ชจ๋ธ ํ๊ฐ: ์ ํ๋๋ง ๋ฏฟ์ผ๋ฉด ํฐ์ผ ๋ ๐
์ ํ์๊ฐ 1%์ธ ๋ฐ์ดํฐ์์ โ๋ชจ๋ ์ ์โ์ด๋ผ๊ณ ์ฐ๋ ๋ชจ๋ธ์ ์ ํ๋๋? 99%์ผ. ๊ทธ๋ฐ๋ฐ ์ด ๋ชจ๋ธ์ ์ ํ์๋ฅผ ํ ๋ช ๋ ๋ชป ์ฐพ์. ๊ทธ๋์ ๋ถ๋ฅ ๋ฌธ์ ์์ ํผ๋ ํ๋ ฌ(Confusion Matrix)์ ๊ธฐ๋ฐ์ผ๋ก ์ฌ๋ฌ ์งํ๋ฅผ ํจ๊ป ๋ด์ผ ํด.
| ์งํ | ๊ณ์ฐ | ์ธ์ ์ค์ํด? |
|---|---|---|
| ์ ๋ฐ๋(Precision) | TP รท (TP + FP) | โ์์ฑ์ด๋ผ๊ณ ํ ๊ฒ ์ค ์ง์ง ๋น์จโ. ์คํธ ํํฐ์ฒ๋ผ ์คํ์ด ์น๋ช ์ ์ผ ๋ |
| ์ฌํ์จ(Recall) | TP รท (TP + FN) | โ์ง์ง ์์ฑ ์ค ์ก์๋ธ ๋น์จโ. ์ง๋ณ ์ง๋จยท์ฌ๊ธฐ ํ์ง์ฒ๋ผ ๋์น๋ฉด ์ ๋ ๋ |
| F1 ์ ์ | ์ ๋ฐ๋์ ์ฌํ์จ์ ์กฐํํ๊ท | ๋ ์ฌ์ด ๊ท ํ์ด ํ์ํ ๋, ๋ถ๊ท ํ ๋ฐ์ดํฐ |
| ROC-AUC | ์๊ณ๊ฐ ์ ์ฒด์ ๊ฑธ์น TPR-FPR ๊ณก์ ์๋ ๋ฉด์ | ์๊ณ๊ฐ๊ณผ ๋ฌด๊ดํ๊ฒ ์์ ๋งค๊ธฐ๋ ๋ฅ๋ ฅ ๋น๊ต |
| MAE / RMSE | ์ค์ฐจ ์ ๋๊ฐ ํ๊ท / ์ ๊ณฑ ํ๊ท ์ ์ ๊ณฑ๊ทผ | ํ๊ท ๋ฌธ์ . RMSE๋ ํฐ ์ค์ฐจ์ ๋ ๋ฏผ๊ฐ |
(TP: ์ง์์ฑ, FP: ์์์ฑ, FN: ์์์ฑ) ๊ทธ๋ฆฌ๊ณ ๋ถ๋ฅ ๋ชจ๋ธ์ ๋ณดํต ํ๋ฅ ์ ๋ด๋๊ณ ๊ธฐ๋ณธ ์๊ณ๊ฐ 0.5๋ก ์๋ฅด๋๋ฐ, ์ ๋ฌด ๋ชฉํ์ ๋ฐ๋ผ ์ด ์๊ณ๊ฐ์ ์กฐ์ ํ๋ ๊ฒ๋ง์ผ๋ก๋ ์ ๋ฐ๋ยท์ฌํ์จ ๊ท ํ์ด ํฌ๊ฒ ๋ฌ๋ผ์ ธ. ๋ชจ๋ธ์ ๋ค์ ํ์ตํ์ง ์์๋ ๋๋ ๊ณต์ง ํ๋์ด๋ ๊ผญ ์ฑ๊ฒจ.
8-1. ๊ณผ์ ํฉ๊ณผ ๊ณผ์์ ํฉ
๋ชจ๋ธ์ด ํ์ต ๋ฐ์ดํฐ๋ฅผ ๋๋ฌด ๋ฌ๋ฌ ์ธ์์ ์ ๋ฐ์ดํฐ์ ์ฝํด์ง๋ ๊ฑธ ๊ณผ์ ํฉ(Overfitting), ๋ฐ๋๋ก ๋๋ฌด ๋จ์ํด์ ํ์ต ๋ฐ์ดํฐ์กฐ์ฐจ ๋ชป ๋งํ๋ ๊ฑธ ๊ณผ์์ ํฉ(Underfitting)์ด๋ผ๊ณ ํด. ์ํ ๊ธฐ์ถ๋ฌธ์ ๋ต๋ง ์ธ์ด ์น๊ตฌ vs ๊ณต๋ถ๋ฅผ ์์ ์ ํ ์น๊ตฌ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ผ.
ํ์ต ์์ค์ ๊ณ์ ๋ด๋ ค๊ฐ๋๋ฐ ๊ฒ์ฆ ์์ค์ด ๋ค์ ์ค๋ฅด๊ธฐ ์์ํ๋ฉด ๊ณผ์ ํฉ ์ ํธ
๊ณผ์ ํฉ์ ๋ง๋ ๋ํ ๋ฌด๊ธฐ๋ค์ ์ ๋ฆฌํ๋ฉด ์ด๋.
9. ์ ์ด ํ์ต: ๊ฑฐ์ธ์ ์ด๊นจ ์์์ ์์ํ๊ธฐ ๐๏ธ
์์ฆ ์ค๋ฌด์์ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ โ์ฒ์๋ถํฐ(from scratch)โ ํ์ตํ๋ ๊ฒฝ์ฐ๋ ์๊ฐ๋ณด๋ค ๋๋ฌผ์ด. ImageNet ๊ฐ์ ๋๊ท๋ชจ ๋ฐ์ดํฐ๋ก ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ๊ฐ์ ธ์ ๋ด ๋ฌธ์ ์ ๋ง๊ฒ ๋๋ถ๋ถ๋ง ๋ฐ๊ฟ ํ์ตํ๋ ์ ์ด ํ์ต(Transfer Learning)์ด ํ์ค์ด์ผ. ์ฌ์ง ์๋ฐฑ ์ฅ์ผ๋ก๋ ์ธ ๋งํ ๋ถ๋ฅ๊ธฐ๋ฅผ ๋ง๋ค ์ ์๋ ๋น๊ฒฐ์ด์ง.
# PyTorch: ์ฌ์ ํ์ต ResNet18๋ก ๋ด ๋ฐ์ดํฐ(5๊ฐ ํด๋์ค) ๋ถ๋ฅ
import torch
from torch import nn
from torchvision import models
model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
for p in model.parameters(): # ๋ชธํต์ ์ผ๋ฆฌ๊ณ (freeze)
p.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, 5) # ๋จธ๋ฆฌ๋ง ๊ต์ฒดํด์ ํ์ต
# Keras: ๊ฐ์ ์์ด๋์ด
import keras
base = keras.applications.MobileNetV2(
input_shape=(224, 224, 3), include_top=False, weights="imagenet")
base.trainable = False
inputs = keras.Input(shape=(224, 224, 3))
x = keras.applications.mobilenet_v2.preprocess_input(inputs)
x = base(x, training=False)
x = keras.layers.GlobalAveragePooling2D()(x)
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)
๋จผ์ ๋จธ๋ฆฌ(๋ถ๋ฅ์ธต)๋ง ํ์ตํ ๋ค, ์ฑ๋ฅ์ด ์์ ๋๋ฉด ๋ชธํต์ ์๋ถ๋ถ ์ผ๋ถ๋ฅผ ํ์ด์(unfreeze) ์์ฃผ ์์ ํ์ต๋ฅ ๋ก ํจ๊ป ๋ฏธ์ธ์กฐ์ ํ๋ 2๋จ๊ณ ์ ๋ต์ด ํํ ์ฐ์ฌ. ํ์ต๋ฅ ์ด ํฌ๋ฉด ์ฌ์ ํ์ต์ผ๋ก ์ป์ ์ง์์ด ๋ง๊ฐ์ง ์ ์๊ฑฐ๋ . ๊ทธ๋ฆฌ๊ณ ์ฌ์ ํ์ต ๋ ์ด ๊ฒ๊ณผ ๋์ผํ ์ ์ฒ๋ฆฌ(์ ๊ทํ)๋ฅผ ์ ์ฉํ๋ ๊ฑธ ์์ผ๋ฉด ์ฑ๋ฅ์ด ๋ ๋จ์ด์ง๋ ์ฃผ์!
ํ ์คํธ ๋ถ์ผ์์๋ Hugging Face์ Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ด ์ญํ ์ ํด. BERT ๊ณ์ด ๋ชจ๋ธ์ ๊ฐ์ ธ์ ๊ฐ์ฑ ๋ถ๋ฅ๋ ๊ฐ์ฒด๋ช ์ธ์์ ๋ง์ถฐ ํ์ธํ๋ํ๋ ์์ ์ด ๋ช์ญ ์ค ์ฝ๋๋ก ๊ฐ๋ฅํด์ก๊ณ , ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฃผ๋ก PyTorch๋ฅผ ์ค์ฌ์ผ๋ก ์์ง์ด๊ณ ์์ด.
10. ๋ชจ๋ธ ์ ์ฅ๊ณผ ๋ฐฐํฌ: ๋ ธํธ๋ถ ๋ฐ์ผ๋ก ๋๊ฐ๊ธฐ ๐
์ฃผํผํฐ ๋ ธํธ๋ถ์์ ์ ํ๋ 98% ์ฐ๊ณ ๋๋๋ฉด ๊ทธ๊ฑด โ์คํโ์ด์ง โ์๋น์คโ๊ฐ ์๋์ผ. ๋ชจ๋ธ์ด ์ค์ ๋ก ๊ฐ์น๋ฅผ ๋ง๋ค๋ ค๋ฉด ์ ์ฅํ๊ณ , ๋ถ๋ฌ์ค๊ณ , ์๋น์ค์ ๋ถ์ฌ์ผ ํด.
10-1. ํ๋ ์์ํฌ๋ณ ์ ์ฅ ๋ฐฉ๋ฒ
# Scikit-learn
import joblib
joblib.dump(clf, "model.joblib")
clf = joblib.load("model.joblib")
# Keras 3
model.save("model.keras")
model = keras.models.load_model("model.keras")
# PyTorch (state_dict ์ ์ฅ์ด ๊ถ์ฅ ๋ฐฉ์)
torch.save(model.state_dict(), "model.pt")
model = Net()
model.load_state_dict(torch.load("model.pt"))
model.eval()
torch.load(..., weights_only=True) ์ต์
(์ต์ ๋ฒ์ ์์ ๊ธฐ๋ณธ๊ฐ)์ ํ์ฉํ๊ฑฐ๋ Hugging Face์ safetensors ํฌ๋งท์ ์ฐ๋ ๊ฒ ์์ ํด. ๋ ์ฌ์ดํท๋ฐ ๋ชจ๋ธ์ ์ ์ฅํ ๋์ ๊ฐ์ ๋ฒ์ ์์ ๋ถ๋ฌ์ค๋ ๊ฒ ์์น์ด์ผ.
10-2. ํ๋ ์์ํฌ๋ฅผ ๋๋๋๋ ๋ค๋ฆฌ, ONNX
ONNX(Open Neural Network Exchange)๋ ๋ชจ๋ธ์ ํํํ๋ ๊ณตํต ํฌ๋งท์ด์ผ. PyTorch๋ torch.onnx.export๋ก, ์ฌ์ดํท๋ฐ์ skl2onnx, TensorFlow๋ tf2onnx ๊ฐ์ ๋ณํ ๋๊ตฌ๋ก ONNX ํ์ผ์ ๋ง๋ค ์ ์์ด. ์ด๋ ๊ฒ ๋ณํํ ๋ชจ๋ธ์ ONNX Runtime์ผ๋ก ๋ค์ํ ์ธ์ด(C++, C#, Java, JavaScript ๋ฑ)์ ํ๋์จ์ด์์ ์คํํ ์ ์์ง. โํ์ต์ PyTorch๋ก, ์๋น์ค๋ C# ์๋ฒ์์โ์ฒ๋ผ ํ ์ํฉ์ด ๋ณต์กํ ๋ ์ ์ฉํด.
10-3. ๊ฐ๋จํ API ์๋ฒ ๋ง๋ค๊ธฐ
๊ฐ์ฅ ํํ ๋ฐฉ์์ FastAPI ๊ฐ์ ์น ํ๋ ์์ํฌ๋ก ๋ชจ๋ธ์ ๊ฐ์ธ REST API๋ฅผ ๋ง๋๋ ๊ฑฐ์ผ.
from fastapi import FastAPI
from pydantic import BaseModel
import joblib, pandas as pd
app = FastAPI()
model = joblib.load("model.joblib") # ์๋ฒ ์์ ์ ํ ๋ฒ๋ง ๋ก๋
class Customer(BaseModel):
age: float
income: float
city: str
job: str
@app.post("/predict")
def predict(c: Customer):
df = pd.DataFrame([c.model_dump()])
prob = model.predict_proba(df)[0, 1]
return {"churn_probability": float(prob)}
์ฌ๊ธฐ์ ํฌ์ธํธ๋ ๋ชจ๋ธ์ ์์ฒญ๋ง๋ค ๋ก๋ํ์ง ์๊ณ ์๋ฒ ์์ ์ ํ ๋ฒ๋ง ๋ถ๋ฌ์ค๋ ๊ฒ, ๊ทธ๋ฆฌ๊ณ ํ์ต ๋์ ๋๊ฐ์ ์ ์ฒ๋ฆฌ๋ฅผ ์ ์ฉํ๋ ๊ฒ์ด์ผ. ์์์ Pipeline์ผ๋ก ์ ์ฒ๋ฆฌ๊น์ง ๋ฌถ์ด ์ ์ฅํด ๋๋ค๋ฉด, ์๋ฒ์์๋ ์๋ณธ ๋ฐ์ดํฐ๋ง ๋ฃ์ผ๋ฉด ๋ผ์ ์ค์๊ฐ ํ ์ค์ด. ํ์ดํ๋ผ์ธ์ด ์ ์ค์ํ์ง ์ฌ๊ธฐ์ ๋ค์ ํ๋ฒ ๋น๋๋ ๊ฑฐ์ง โจ
10-4. MLOps: ๋ฐฐํฌ ์ดํ๊ฐ ์ง์ง ์์
์ธ์์ ๋ณํ๊ณ ๋ฐ์ดํฐ๋ ๋ณํด. ์ฝ๋ก๋ ์๊ธฐ ์๋น ํจํด์ด ๊ฐ์๊ธฐ ๋ฐ๋๋ฉด์ ๊ธฐ์กด ์์ ์์ธก ๋ชจ๋ธ๋ค์ด ํ๋ค๋ ธ๋ ๊ฒ์ฒ๋ผ, ์ ๋ ฅ ๋ฐ์ดํฐ ๋ถํฌ๊ฐ ํ์ต ๋์ ๋ฌ๋ผ์ง๋ ๋ฐ์ดํฐ ๋๋ฆฌํํธ๋ ๋ฐ๋์ ์. ๊ทธ๋์ ์ค๋ฌด์์๋ MLflow ๊ฐ์ ๋๊ตฌ๋ก ์คํยท๋ชจ๋ธ ๋ฒ์ ์ ๊ธฐ๋กํ๊ณ , ์์ธก ๋ถํฌ์ ์ค์ ์ฑ๋ฅ์ ๋ชจ๋ํฐ๋งํ๋ค๊ฐ ์ฃผ๊ธฐ์ ์ผ๋ก ์ฌํ์ตํ๋ ์ฒด๊ณ๋ฅผ ๊ฐ์ถฐ. ์ด ์ ์ฒด ์ด์ ๋ฌธํ๋ฅผ MLOps๋ผ๊ณ ๋ถ๋ฌ.
11. ์ค์ ์๋๋ฆฌ์ค: ๊ณ ๊ฐ ์ดํ ์์ธก ํ๋ก์ ํธ ๐
๊ฐ๋ ์ ์ฎ์ด์ ์ค์ ํ๋ก์ ํธ ํ๋๋ฅผ ์์์ผ๋ก ๊ตด๋ ค๋ณด์. ์ด๋ ๊ตฌ๋ ์๋น์ค ํ์ฌ๊ฐ โ๋ค์ ๋ฌ์ ํด์งํ ๊ณ ๊ฐ์ ๋ฏธ๋ฆฌ ์ฐพ์ ์ฟ ํฐ์ ๋ณด๋ด๊ณ ์ถ๋คโ๊ณ ํด.
๋ณด๋ค์ํผ ์ด ํ๋ก์ ํธ์์ TensorFlow๋ PyTorch๋ ์ ์ผ์ด. ๋ฐ๋๋ก ์ํ ์ฌ์ง์ผ๋ก ์นดํ ๊ณ ๋ฆฌ๋ฅผ ์๋ ๋ถ๋ฅํ๊ฑฐ๋, ๊ณ ๊ฐ ๋ฌธ์ ํ ์คํธ์ ๊ฐ์ฑ์ ๋ถ์ํ๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ค๋ฉด ๊ทธ๋ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ๊ฐ ๋ฑํํ๋ ๊ฑฐ์ง. ๋๊ตฌ๋ ๋ฌธ์ ๊ฐ ๊ณ ๋ฅธ๋ค๋ ๊ฐ๊ฐ, ์ด๊ฒ ์ง์ง ์ค๋ ฅ์ด์ผ.
12. ๊ฐ๋ฐ ํ๊ฒฝ ์ธํ ํ ๐ป
โ์ฝ๋๋ ๋ง๋๋ฐ ํ๊ฒฝ์ด ์ ๋ผ์โ๋ AI ๊ฐ๋ฐ์์ ์์ํ ์์ ์ด์ผ. ๋ช ๊ฐ์ง ์์น๋ง ์งํค๋ฉด ๊ณ ์์ด ํ ์ค์ด.
# ์ค์น ํ์ธ์ฉ ํ ๋ฐฉ ์คํฌ๋ฆฝํธ
import sklearn, torch
print("scikit-learn", sklearn.__version__)
print("torch", torch.__version__, "| CUDA:", torch.cuda.is_available())
import tensorflow as tf
print("tensorflow", tf.__version__, "| GPU:", tf.config.list_physical_devices("GPU"))
์ฐธ๊ณ ๋ก ์ ํ ์ค๋ฆฌ์ฝ(M ์๋ฆฌ์ฆ) ๋งฅ์์๋ PyTorch๊ฐ MPS ๋ฐฑ์๋๋ก GPU ๊ฐ์์ ์ง์ํด. torch.backends.mps.is_available()๋ก ํ์ธํ๊ณ device="mps"๋ก ์ฐ๋ฉด ๋ผ.
13. ์์ฃผ ๋ฌป๋ ์ง๋ฌธ ๐
14. ๋ง๋ฌด๋ฆฌ: ํ ์ฅ์ผ๋ก ์ ๋ฆฌํ๊ธฐ ๐
โก Scikit-learn: fit/predict์ ์ผ๊ด๋ API, Pipeline์ผ๋ก ๋์ ๋ฐฉ์ง, ์ ํ ๋ฐ์ดํฐ์ ๊ฐ๋ ํ์ต์ ์ต์ .
โข TensorFlow/Keras: compile/fit์ ๊ฐ๊ฒฐํจ, tf.dataยทSavedModelยทLiteRT ๋ฑ ๋ฐฐํฌ ์ํ๊ณ, Keras 3๋ ๋ฉํฐ ๋ฐฑ์๋.
โฃ PyTorch: ํ์ด์ฌ๋ค์ด ์ฆ์ ์คํ, zero_grad โ forward โ backward โ step 4๋ฐ์, ์ฐ๊ตฌยทLLM์ ์ฃผ๋ฅ, torch.compile๋ก ์ฑ๋ฅ ๋ณด๊ฐ.
โค ์ ํ๋ ํ๋๋ง ๋ณด์ง ๋ง๊ณ ์ ๋ฐ๋ยท์ฌํ์จยทF1์, ํ์ต ๊ณก์ ์ผ๋ก ๊ณผ์ ํฉ์ ์ฒดํฌ.
โฅ ๋ฐ์ดํฐ๊ฐ ์ ์ผ๋ฉด ์ ์ด ํ์ต, ๋ฐฐํฌ ํ์ ๋๋ฆฌํํธ ๋ชจ๋ํฐ๋ง๊น์ง๊ฐ ์ง์ง ์์ฑ.
์ฒ์์ import ์๋ฌ, shape ์๋ฌ, CUDA ์๋ฌ๊ฐ ๋ฒ๊ฐ์ ๊ฐ๋ฉฐ ๋ฐ๊ฒจ์ค ๊ฑฐ์ผ. ๊ทผ๋ฐ ๊ทธ๊ฑด ๋ค๋ค ๊ฑฐ์ณ ๊ฐ ํต๊ณผ์๋ก์ผ ๐ ์ค๋ ๋ณธ ๋ถ๊ฝ ๋ถ๋ฅ๊ธฐ์ MNIST ๋ชจ๋ธ์ ์ง์ ํ ๋ฒ์ฉ ๋๋ ค๋ณด๊ณ , ํ์ดํผํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ๊ฟ ์ ์๊ฐ ์ด๋ป๊ฒ ์์ง์ด๋์ง ๊ด์ฐฐํด ๋ด. ์์ผ๋ก ํ ๋ฒ ๋ง์ ธ๋ณธ ๊ฐ๋ ์ ์ ๋ ์ ์ํ๊ฑฐ๋ . ๋ค ์ฒซ ๋ฒ์งธ ๋ชจ๋ธ์ด ์ธ์์ ๋์ค๋ ๋ ์ ์์ํ ๊ฒ! ๐
โ๋ชจ๋ ๋ชจ๋ธ์ ํ๋ ธ๋ค. ํ์ง๋ง ์ผ๋ถ๋ ์ ์ฉํ๋ค.โ โ ํต๊ณํ์ ์กฐ์ง ๋ฐ์ค(George E. P. Box)
์๋ฒฝํ ๋ชจ๋ธ๋ณด๋ค ๋ฌธ์ ๋ฅผ ์ค์ ๋ก ํ์ด์ฃผ๋ ์ ์ฉํ ๋ชจ๋ธ์ ๋ชฉํ๋ก ํ์.
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.