๋ฐ์ดํ„ฐ ๊ณผํ•™์˜ ์ฒซ ๋ฒˆ์งธ ๋‹จ๊ณ„์ž…๋‹ˆ๋‹ค. ๊ฑฐ๋Œ€ํ•œ

์งง์€ ์†Œ๊ฐœ ๋‹จ์–ด

๋‚˜๋Š” ์šฐ๋ฆฌ์—๊ฒŒ ๋ฌด์—‡์„ ํ•ด์•ผ ํ• ์ง€, ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ• ์ง€ ์•Œ๋ ค์ฃผ๋Š” ๋‹จ๊ณ„๋ณ„ ์ง€์นจ์ด ์ œ๊ณต๋œ๋‹ค๋ฉด ์šฐ๋ฆฌ๊ฐ€ ๋” ๋งŽ์€ ์ผ์„ ํ•  ์ˆ˜ ์žˆ๋‹ค๊ณ  ๋ฏฟ์Šต๋‹ˆ๋‹ค. ๋‚˜ ์ž์‹ ๋„ ์ธ์ƒ์—์„œ ์–ด๋””์„œ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์•ผ ํ• ์ง€ ์ดํ•ดํ•˜๊ธฐ ์–ด๋ ค์› ๊ธฐ ๋•Œ๋ฌธ์— ๋ฌด์–ธ๊ฐ€๋ฅผ ์‹œ์ž‘ํ•  ์ˆ˜ ์—†์—ˆ๋˜ ์ˆœ๊ฐ„์„ ๊ธฐ์–ตํ•ฉ๋‹ˆ๋‹ค. ์•„๋งˆ๋„ ์˜›๋‚  ์˜›์ ์— ์ธํ„ฐ๋„ท์—์„œ "๋ฐ์ดํ„ฐ ๊ณผํ•™"์ด๋ผ๋Š” ๋‹จ์–ด๋ฅผ ๋ณด๊ณ  ์ž์‹ ์€ ์ด๊ฒƒ๊ณผ๋Š” ๊ฑฐ๋ฆฌ๊ฐ€ ๋ฉ€๊ณ  ์ด ์ผ์„ ํ•˜๋Š” ์‚ฌ๋žŒ๋“ค์€ ์ € ๋ฐ”๊นฅ ์–ด๋”˜๊ฐ€, ๋‹ค๋ฅธ ์„ธ๊ณ„์— ์žˆ๋‹ค๊ณ  ํŒ๋‹จํ–ˆ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์•„๋‹ˆ, ๋ฐ”๋กœ ์—ฌ๊ธฐ ์žˆ์–ด์š”. ๊ทธ๋ฆฌ๊ณ  ์•„๋งˆ๋„ ์ด ๋ถ„์•ผ์˜ ์‚ฌ๋žŒ๋“ค ๋•๋ถ„์— ๊ท€ํ•˜์˜ ํ”ผ๋“œ์— ๊ธฐ์‚ฌ๊ฐ€ ๋‚˜ํƒ€๋‚ฌ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด ๊ธฐ์ˆ ์— ์ต์ˆ™ํ•ด์ง€๋Š” ๋ฐ ๋„์›€์ด ๋˜๋Š” ๊ฐ•์ขŒ๊ฐ€ ๋งŽ์ด ์žˆ์ง€๋งŒ ์—ฌ๊ธฐ์„œ๋Š” ์ฒซ ๋‹จ๊ณ„๋ฅผ ๋ฐŸ๋Š” ๋ฐ ๋„์›€์„ ๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž, ์ค€๋น„๋๋‚˜์š”? ์—ฌ๊ธฐ์„œ๋Š” 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

์ฝ”๋ฉ˜ํŠธ๋ฅผ ์ถ”๊ฐ€