์งง์ ์๊ฐ ๋จ์ด
๋๋ ์ฐ๋ฆฌ์๊ฒ ๋ฌด์์ ํด์ผ ํ ์ง, ์ด๋ป๊ฒ ํด์ผ ํ ์ง ์๋ ค์ฃผ๋ ๋จ๊ณ๋ณ ์ง์นจ์ด ์ ๊ณต๋๋ค๋ฉด ์ฐ๋ฆฌ๊ฐ ๋ ๋ง์ ์ผ์ ํ ์ ์๋ค๊ณ ๋ฏฟ์ต๋๋ค. ๋ ์์ ๋ ์ธ์์์ ์ด๋์๋ถํฐ ์์ํด์ผ ํ ์ง ์ดํดํ๊ธฐ ์ด๋ ค์ ๊ธฐ ๋๋ฌธ์ ๋ฌด์ธ๊ฐ๋ฅผ ์์ํ ์ ์์๋ ์๊ฐ์ ๊ธฐ์ตํฉ๋๋ค. ์๋ง๋ ์๋ ์์ ์ ์ธํฐ๋ท์์ "๋ฐ์ดํฐ ๊ณผํ"์ด๋ผ๋ ๋จ์ด๋ฅผ ๋ณด๊ณ ์์ ์ ์ด๊ฒ๊ณผ๋ ๊ฑฐ๋ฆฌ๊ฐ ๋ฉ๊ณ ์ด ์ผ์ ํ๋ ์ฌ๋๋ค์ ์ ๋ฐ๊นฅ ์ด๋๊ฐ, ๋ค๋ฅธ ์ธ๊ณ์ ์๋ค๊ณ ํ๋จํ์ ๊ฒ์
๋๋ค. ์๋, ๋ฐ๋ก ์ฌ๊ธฐ ์์ด์. ๊ทธ๋ฆฌ๊ณ ์๋ง๋ ์ด ๋ถ์ผ์ ์ฌ๋๋ค ๋๋ถ์ ๊ทํ์ ํผ๋์ ๊ธฐ์ฌ๊ฐ ๋ํ๋ฌ์ ๊ฒ์
๋๋ค. ์ด ๊ธฐ์ ์ ์ต์ํด์ง๋ ๋ฐ ๋์์ด ๋๋ ๊ฐ์ข๊ฐ ๋ง์ด ์์ง๋ง ์ฌ๊ธฐ์๋ ์ฒซ ๋จ๊ณ๋ฅผ ๋ฐ๋ ๋ฐ ๋์์ ๋๋ฆฌ๊ฒ ์ต๋๋ค.
์, ์ค๋น๋๋์? ์ฌ๊ธฐ์๋ Python 3๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ Python XNUMX๋ฅผ ์์์ผ ํ๋ค๋ ์ ์ ์ฆ์ ๋ง์๋๋ฆฌ๊ฒ ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฏธ๋ฆฌ Jupyter Notebook์ ์ค์นํด ๋ณด์๊ฑฐ๋ ๊ตฌ๊ธ Colab ์ฌ์ฉ๋ฒ์ ์ฐธ๊ณ ํด ๋ณด์๊ธธ ๊ถํฉ๋๋ค.
ะจะฐะณ์ ะฟะตัะฒัะน
Kaggle์ ์ด ๋ฌธ์ ์ ์์ด ์ค์ํ ์กฐ๋ ฅ์์
๋๋ค. ์์น์ ์ผ๋ก ๊ทธ๊ฒ ์์ด๋ ํ ์ ์์ง๋ง ์ด์ ๋ํด์๋ ๋ค๋ฅธ ๊ธฐ์ฌ์์ ์ด์ผ๊ธฐํ๊ฒ ์ต๋๋ค. ๋ฐ์ดํฐ ์ฌ์ด์ธ์ค ๋ํ๋ฅผ ๊ฐ์ตํ๋ ํ๋ซํผ์
๋๋ค. ์ด๋ฌํ ๊ฐ ๋ํ์์๋ ์ด๊ธฐ ๋จ๊ณ์์ ์ฐ๋ฆฌ ์๋์ ์ค์ํ ๋ค์ํ ์ข
๋ฅ์ ๋ฌธ์ ํด๊ฒฐ, ๊ฐ๋ฐ ๊ฒฝํ ๋ฐ ํ ์์
๊ฒฝํ์ ๋ํ ๋นํ์ค์ ์ธ ์์ ๊ฒฝํ์ ์ป๊ฒ ๋ ๊ฒ์
๋๋ค.
์ฐ๋ฆฌ๋ ๊ฑฐ๊ธฐ์์ ์ฐ๋ฆฌ์ ์๋ฌด๋ฅผ ๋งก์ ๊ฒ์ ๋๋ค. ์ด๋ฆ์ 'ํ์ดํ๋'์ด๋ค. ์กฐ๊ฑด์ ์ด๋ ์ต๋๋ค. ๊ฐ ๊ฐ์ธ์ด ์์กดํ ๊ฒ์ธ์ง ์์ธกํ๋ ๊ฒ์ ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก DS์ ๊ด๋ จ๋ ์ฌ๋์ ์ ๋ฌด๋ ๋ฐ์ดํฐ ์์ง, ์ฒ๋ฆฌ, ๋ชจ๋ธ ํ์ต, ์์ธก ๋ฑ์ ๋๋ค. Kaggle์์๋ ๋ฐ์ดํฐ ์์ง ๋จ๊ณ๋ฅผ ๊ฑด๋๋ธ ์ ์์ต๋๋ค. ๋ฐ์ดํฐ ์์ง ๋จ๊ณ๋ ํ๋ซํผ์ ํ์๋ฉ๋๋ค. ๋ค์ด๋ก๋ํด์ผ ํ๋ฉฐ ์์ํ ์ ์์ต๋๋ค!
๋ค์๊ณผ ๊ฐ์ด ์ด ์์ ์ ์ํํ ์ ์์ต๋๋ค.
๋ฐ์ดํฐ ํญ์๋ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋ ํ์ผ์ด ํฌํจ๋์ด ์์ต๋๋ค.
๋ฐ์ดํฐ๋ฅผ ๋ค์ด๋ก๋ํ๊ณ Jupyter ๋
ธํธ๋ถ์ ์ค๋นํ ๋ค์...
ะจะฐะณ์ ะฒัะพัะพะน
์ด์ ์ด ๋ฐ์ดํฐ๋ฅผ ์ด๋ป๊ฒ ๋ก๋ํฉ๋๊น?
๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
import pandas as pd
import numpy as np
Pandas๋ฅผ ์ฌ์ฉํ๋ฉด ์ถ๊ฐ ์ฒ๋ฆฌ๋ฅผ ์ํด .csv ํ์ผ์ ๋ค์ด๋ก๋ํ ์ ์์ต๋๋ค.
๋ฐ์ดํฐ ํ
์ด๋ธ์ ์ซ์๊ฐ ํฌํจ๋ ํ๋ ฌ๋ก ํํํ๋ ค๋ฉด Numpy๊ฐ ํ์ํฉ๋๋ค.
๊ณ์ํ์ธ์. train.csv ํ์ผ์ ๊ฐ์ ธ์์ ์
๋ก๋ํด ๋ณด๊ฒ ์ต๋๋ค.
dataset = pd.read_csv('train.csv')
๋ฐ์ดํฐ์ธํธ ๋ณ์๋ฅผ ํตํด train.csv ๋ฐ์ดํฐ ์ ํ์ ์ฐธ์กฐํ๊ฒ ์ต๋๋ค. ๊ฑฐ๊ธฐ์ ๋ฌด์์ด ์๋์ง ๋ด ์๋ค:
dataset.head()
head() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐํ๋ ์์ ์ฒ์ ๋ช ํ์ ๋ณผ ์ ์์ต๋๋ค.
Survived ์ด์ ์ ํํ๊ฒ ์ด ๋ฐ์ดํฐ ํ๋ ์์ ์๋ ค์ง ๊ฒฐ๊ณผ์ ๋๋ค. ์์ ์ง๋ฌธ์ ๊ฒฝ์ฐ test.csv ๋ฐ์ดํฐ์ Survived ์ด์ ์์ธกํด์ผ ํฉ๋๋ค. ์ด ๋ฐ์ดํฐ๋ ํ์ดํ๋์ ๋ค๋ฅธ ์น๊ฐ์ ๋ํ ์ ๋ณด๋ฅผ ์ ์ฅํ๋ฉฐ, ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ฐ๋ฆฌ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ ์์ต๋๋ค.
์ด์ ํ ์ด๋ธ์ ์ข ์ ๋ฐ์ดํฐ์ ๋ ๋ฆฝ ๋ฐ์ดํฐ๋ก ๋๋์ด ๋ณด๊ฒ ์ต๋๋ค. ์ฌ๊ธฐ์์๋ ๋ชจ๋ ๊ฒ์ด ๊ฐ๋จํฉ๋๋ค. ์ข ์ ๋ฐ์ดํฐ๋ ๊ฒฐ๊ณผ์ ํฌํจ๋ ๋ ๋ฆฝ ๋ฐ์ดํฐ์ ์์กดํ๋ ๋ฐ์ดํฐ์ ๋๋ค. ๋ ๋ฆฝ์ ์ธ ๋ฐ์ดํฐ๋ ๊ฒฐ๊ณผ์ ์ํฅ์ ๋ฏธ์น๋ ๋ฐ์ดํฐ์ ๋๋ค.
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ๋ฐ์ดํฐ ์ธํธ๊ฐ ์์ต๋๋ค.
โVova๋ ์ปดํจํฐ ๊ณผํ์ ๊ฐ๋ฅด์ณค์ต๋๋ค.
Vova๋ ์ปดํจํฐ ๊ณผํ์์ 2์ ์ ๋ฐ์์ต๋๋ค.โ
์ปดํจํฐ ๊ณผํ์ ์ฑ์ ์ Vova๊ฐ ์ปดํจํฐ ๊ณผํ์ ๊ณต๋ถํ์ต๋๊น?๋ผ๋ ์ง๋ฌธ์ ๋ํ ๋ต์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ช ๋ฐฑํฉ๋๊น? ๊ณ์ํด์ ์งํํ์ธ์. ์ฐ๋ฆฌ๋ ์ด๋ฏธ ๋ชฉํ์ ๋ ๊ฐ๊น์์ก์ต๋๋ค!
๋ ๋ฆฝ ๋ฐ์ดํฐ์ ๊ธฐ์กด ๋ณ์๋ X์ ๋๋ค. ์ข ์ ๋ฐ์ดํฐ์ ๊ฒฝ์ฐ y์ ๋๋ค.
์ฐ๋ฆฌ๋ ๋ค์์ ์ํํฉ๋๋ค:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
๊ทธ๊ฒ์ ๋ฌด์์ ๋๊น? iloc[:, 2: ] ํจ์๋ฅผ ์ฌ์ฉํ์ฌ Python์ ๋ค์๊ณผ ๊ฐ์ด ์๋ฆฝ๋๋ค. ๋ณ์ X์์ ๋ ๋ฒ์งธ ์ด๋ถํฐ ์์ํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ณ ์ถ์ต๋๋ค(XNUMX๋ถํฐ ๊ณ์ฐ์ด ์์๋๋ ๊ฒฝ์ฐ ํฌํจ). ๋ ๋ฒ์งธ ์ค์์๋ ์ฒซ ๋ฒ์งธ ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ณ ์ถ๋ค๊ณ ๋งํฉ๋๋ค.
[ a:b, c:d ]๋ ๊ดํธ ์์ ์ฌ์ฉํ๋ ๊ตฌ์ฑ์ ๋๋ค. ๋ณ์๋ฅผ ์ง์ ํ์ง ์์ผ๋ฉด ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ ์ฅ๋ฉ๋๋ค. ์ฆ, [:,: d]๋ฅผ ์ง์ ํ๋ฉด ์ซ์ d ์ดํ์ ์ด์ ์ ์ธํ๊ณ ๋ฐ์ดํฐํ๋ ์์ ๋ชจ๋ ์ด์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค. ๋ณ์ a์ b๋ ๋ฌธ์์ด์ ์ ์ํ์ง๋ง ๋ชจ๋ ํ์ํ๋ฏ๋ก ๊ธฐ๋ณธ๊ฐ์ผ๋ก ๋ก๋๋ค.์ฐ๋ฆฌ๊ฐ ๋ฌด์์ ์ป์๋์ง ๋ด ์๋ค:
X.head()
y.head()
์ด ์์ ๊ตํ์ ๋จ์ํํ๊ธฐ ์ํด ํน๋ณํ ์ฃผ์๊ฐ ํ์ํ๊ฑฐ๋ ์์กด ๊ฐ๋ฅ์ฑ์ ์ ํ ์ํฅ์ ์ฃผ์ง ์๋ ์ด์ ์ ๊ฑฐํ๊ฒ ์ต๋๋ค. ์ฌ๊ธฐ์๋ str ์ ํ์ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋ฉ๋๋ค.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
๊ฐ๋ ์! ๋ค์ ๋จ๊ณ๋ก ๋์ด ๊ฐ์๋ค.
3 ๋จ๊ณ
์ฌ๊ธฐ์๋ ๊ธฐ๊ณ๊ฐ ์ด ๋ฐ์ดํฐ๊ฐ ๊ฒฐ๊ณผ์ ์ด๋ค ์ํฅ์ ๋ฏธ์น๋์ง ๋ ์ ์ดํดํ ์ ์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ธ์ฝ๋ฉํด์ผ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๋ชจ๋ ๊ฒ์ ์ธ์ฝ๋ฉํ์ง ์๊ณ ์ฐ๋ฆฌ๊ฐ ๋จ๊ธด str ๋ฐ์ดํฐ๋ง ์ธ์ฝ๋ฉํ ๊ฒ์ ๋๋ค. ์ด "์น์ค". ์ฐ๋ฆฌ๋ ์ด๋ป๊ฒ ์ฝ๋ฉํ๊ณ ์ถ๋์? ์ฌ๋์ ์ฑ๋ณ์ ๋ํ ๋ฐ์ดํฐ๋ฅผ ๋ฒกํฐ(10 - ๋จ์ฑ, 01 - ์ฌ์ฑ)๋ก ํํํด ๋ณด๊ฒ ์ต๋๋ค.
๋จผ์ ํ ์ด๋ธ์ NumPy ํ๋ ฌ๋ก ๋ณํํด ๋ณด๊ฒ ์ต๋๋ค.
X = np.array(X)
y = np.array(y)
์ด์ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X = np.array(ct.fit_transform(X))
sklearn ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ฐ์ดํฐ ๊ณผํ์์ ์์ ํ ์์ ์ ์ํํ ์ ์๋ ๋ฉ์ง ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋๋ค. ์ฌ๊ธฐ์๋ ํฅ๋ฏธ๋ก์ด ๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ์ด ๋ง์ด ํฌํจ๋์ด ์์ผ๋ฉฐ ๋ฐ์ดํฐ ์ค๋น๋ ๊ฐ๋ฅํฉ๋๋ค.
OneHotEncoder๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ช ๋ ๋๋ก ํด๋น ํํ์์ ์ฌ๋์ ์ฑ๋ณ์ ์ธ์ฝ๋ฉํ ์ ์์ต๋๋ค. ๋จ์ฑ, ์ฌ์ฑ 2๊ฐ์ ํด๋์ค๊ฐ ์์ฑ๋ฉ๋๋ค. ๊ทธ ์ฌ๋์ด ๋จ์์ธ ๊ฒฝ์ฐ, โ๋จ์โ ์ด์๋ 1, โ์ฌ์โ ์ด์๋ 0์ด ๊ฐ๊ฐ ๊ธฐ๋ก๋ฉ๋๋ค.
OneHotEncoder() ๋ค์๋ [1]์ด ์์ต๋๋ค. ์ด๋ ์ด ๋ฒํธ 1(XNUMX๋ถํฐ ๊ณ์ฐ)์ ์ธ์ฝ๋ฉํ๋ค๋ ์๋ฏธ์ ๋๋ค.
๊ฐ๋ ์. ๋์ฑ ๋ ๋์๊ฐ์!
์ผ๋ฐ์ ์ผ๋ก ์ผ๋ถ ๋ฐ์ดํฐ๋ ๊ณต๋ฐฑ์ผ๋ก ๋จ์ ์์ต๋๋ค(์ฆ, NaN - ์ซ์๊ฐ ์๋). ์๋ฅผ ๋ค์ด, ์ด๋ฆ, ์ฑ๋ณ ๋ฑ ์ฌ๋์ ๋ํ ์ ๋ณด๊ฐ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ์ ๋์ด์ ๋ํ ์ ๋ณด๋ ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ ๋ค์ ๋ฐฉ๋ฒ์ ์ ์ฉํฉ๋๋ค. ๋ชจ๋ ์ด์ ๋ํ ์ฐ์ ํ๊ท ์ ์ฐพ๊ณ , ์ด์ ์ผ๋ถ ๋ฐ์ดํฐ๊ฐ ๋๋ฝ๋ ๊ฒฝ์ฐ ์ฐ์ ํ๊ท ์ผ๋ก ๊ณต๋ฐฑ์ ์ฑ์๋๋ค.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
์ด์ ๋ฐ์ดํฐ๊ฐ ๋งค์ฐ ํด ๋ ๋ฐ์ํ๋ ์ํฉ์ ๊ณ ๋ คํด ๋ณด๊ฒ ์ต๋๋ค. ์ผ๋ถ ๋ฐ์ดํฐ๋ [0:1] ๊ฐ๊ฒฉ์ ์๋ ๋ฐ๋ฉด ์ผ๋ถ ๋ฐ์ดํฐ๋ ์๋ฐฑ, ์์ฒ์ ์ด๊ณผํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๋ถ์ฐ์ ์ ๊ฑฐํ๊ณ ์ปดํจํฐ ๊ณ์ฐ์ ๋์ฑ ์ ํํ๊ฒ ๋ง๋ค๊ธฐ ์ํด ๋ฐ์ดํฐ๋ฅผ ์ค์บํ๊ณ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํฉ๋๋ค. ๋ชจ๋ ์ซ์๊ฐ XNUMX์ ์ด๊ณผํ์ง ์๋๋ก ํ์ธ์. ์ด๋ฅผ ์ํด StandardScaler ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
์ด์ ์ฐ๋ฆฌ์ ๋ฐ์ดํฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
์์
. ์ฐ๋ฆฌ๋ ์ด๋ฏธ ๋ชฉํ์ ๊ฐ๊น์์ก์ต๋๋ค!
XNUMX๋จ๊ณ
์ฒซ ๋ฒ์งธ ๋ชจ๋ธ์ ํ๋ จ์์ผ ๋ณด๊ฒ ์ต๋๋ค! sklearn ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฐ๋ฆฌ๋ ์๋ง์ ํฅ๋ฏธ๋ก์ด ๊ฒ๋ค์ ์ฐพ์ ์ ์์ต๋๋ค. ๋๋ ์ด ๋ฌธ์ ์ Gradient Boosting Classifier ๋ชจ๋ธ์ ์ ์ฉํ์ต๋๋ค. ์ฐ๋ฆฌ์ ์์ ์ ๋ถ๋ฅ ์์ ์ด๊ธฐ ๋๋ฌธ์ A ๋ถ๋ฅ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ํ๋ 1(์์กด) ๋๋ 0(์์กดํ์ง ์์)์ผ๋ก ํ ๋น๋์ด์ผ ํฉ๋๋ค.
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
fit ํจ์๋ Python์ ๋ค์๊ณผ ๊ฐ์ด ์ง์ํฉ๋๋ค. ๋ชจ๋ธ์ด X์ y ์ฌ์ด์ ์ข ์์ฑ์ ์ฐพ๋๋ก ํฉ๋๋ค.
XNUMX์ด๋ ์ ๋์ด ๋ชจ๋ธ์ด ์ค๋น๋ฉ๋๋ค.
์ด๋ป๊ฒ ์ ์ฉํ๋์? ์ง๊ธ ๋ณผ๊ฒ์!
XNUMX๋จ๊ณ. ๊ฒฐ๋ก
์ด์ ์์ธก์ด ํ์ํ ํ ์คํธ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋ ํ ์ด๋ธ์ ๋ก๋ํด์ผ ํฉ๋๋ค. ์ด ํ ์ด๋ธ์ ์ฌ์ฉํ์ฌ X์์ ์ํํ ๊ฒ๊ณผ ๋์ผํ ์์ ์ ๋ชจ๋ ์ํํฉ๋๋ค.
X_test = pd.read_csv('test.csv', index_col=0)
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X_test.drop(count, inplace=True, axis=1)
X_test = np.array(X_test)
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X_test = np.array(ct.fit_transform(X_test))
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X_test)
X_test = imputer.transform(X_test)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_test[:, 2:] = sc.fit_transform(X_test[:, 2:])
์ด์ ๋ชจ๋ธ์ ์ ์ฉํด ๋ณด๊ฒ ์ต๋๋ค!
gbc_predict = gbc.predict(X_test)
๋ชจ๋. ์ฐ๋ฆฌ๋ ์์ธกํ์ต๋๋ค. ์ด์ csv๋ก ๊ธฐ๋กํด์ ์ฌ์ดํธ๋ก ๋ณด๋ด์ผ ํฉ๋๋ค.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
์ค๋น๊ฐ ๋. ์ฐ๋ฆฌ๋ ๊ฐ ์น๊ฐ์ ๋ํ ์์ธก์ด ํฌํจ๋ ํ์ผ์ ๋ฐ์์ต๋๋ค. ๋จ์ ๊ฒ์ ์ด๋ฌํ ์๋ฃจ์
์ ์น์ฌ์ดํธ์ ์
๋ก๋ํ๊ณ ์์ธก์ ๋ํ ํ๊ฐ๋ฅผ ๋ฐ๋ ๊ฒ์
๋๋ค. ์ด๋ฌํ ์์์ ์ธ ์๋ฃจ์
์ ๋์ค์๊ฒ 74%์ ์ ๋ต์ ์ ๊ณตํ ๋ฟ๋ง ์๋๋ผ ๋ฐ์ดํฐ ๊ณผํ์ ์ด๋ ์ ๋ ์๊ทน์ ์ค๋๋ค. ๊ฐ์ฅ ๊ถ๊ธํ์ ๋ถ์ ์ธ์ ๋ ์ง ๋น๊ณต๊ฐ ๋ฉ์์ง๋ก ์ ์๊ฒ ํธ์ง๋ฅผ ๋ณด๋ด ์ง๋ฌธํ์ค ์ ์์ต๋๋ค. ๋ชจ๋์๊ฒ ๊ฐ์ฌ๋๋ฆฝ๋๋ค!
์ถ์ฒ : habr.com