ਡਾਟਾ ਸਾਇੰਸ ਵਿੱਚ ਤੁਹਾਡਾ ਪਹਿਲਾ ਕਦਮ। ਟਾਇਟੈਨਿਕ

ਇੱਕ ਛੋਟਾ ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦ

ਮੇਰਾ ਮੰਨਣਾ ਹੈ ਕਿ ਅਸੀਂ ਹੋਰ ਚੀਜ਼ਾਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੇਕਰ ਸਾਨੂੰ ਕਦਮ-ਦਰ-ਕਦਮ ਹਿਦਾਇਤਾਂ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜੋ ਸਾਨੂੰ ਇਹ ਦੱਸਣਗੀਆਂ ਕਿ ਕੀ ਕਰਨਾ ਹੈ ਅਤੇ ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ। ਮੈਨੂੰ ਆਪਣੀ ਜ਼ਿੰਦਗੀ ਦੇ ਉਹ ਪਲ ਯਾਦ ਹਨ ਜਦੋਂ ਮੈਂ ਕੁਝ ਸ਼ੁਰੂ ਨਹੀਂ ਕਰ ਸਕਦਾ ਸੀ ਕਿਉਂਕਿ ਇਹ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਸੀ ਕਿ ਕਿੱਥੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ। ਸ਼ਾਇਦ, ਇੱਕ ਵਾਰ ਇੰਟਰਨੈੱਟ 'ਤੇ ਤੁਸੀਂ "ਡੇਟਾ ਸਾਇੰਸ" ਸ਼ਬਦ ਦੇਖੇ ਅਤੇ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਤੁਸੀਂ ਇਸ ਤੋਂ ਬਹੁਤ ਦੂਰ ਹੋ, ਅਤੇ ਜੋ ਲੋਕ ਅਜਿਹਾ ਕਰਦੇ ਹਨ ਉਹ ਕਿਤੇ ਬਾਹਰ, ਕਿਸੇ ਹੋਰ ਸੰਸਾਰ ਵਿੱਚ ਸਨ. ਨਹੀਂ, ਉਹ ਇੱਥੇ ਹੀ ਹਨ। ਅਤੇ, ਸ਼ਾਇਦ, ਇਸ ਖੇਤਰ ਦੇ ਲੋਕਾਂ ਦਾ ਧੰਨਵਾਦ, ਤੁਹਾਡੀ ਫੀਡ 'ਤੇ ਇੱਕ ਲੇਖ ਪ੍ਰਗਟ ਹੋਇਆ. ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਕੋਰਸ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਇਸ ਕਲਾ ਦੀ ਆਦਤ ਪਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਨਗੇ, ਪਰ ਇੱਥੇ ਮੈਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾ ਕਦਮ ਚੁੱਕਣ ਵਿੱਚ ਮਦਦ ਕਰਾਂਗਾ।

ਖੈਰ, ਕੀ ਤੁਸੀਂ ਤਿਆਰ ਹੋ? ਮੈਂ ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਦੱਸਦਾ ਹਾਂ ਕਿ ਤੁਹਾਨੂੰ ਪਾਈਥਨ 3 ਨੂੰ ਜਾਣਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ, ਕਿਉਂਕਿ ਮੈਂ ਇੱਥੇ ਇਹੀ ਵਰਤ ਰਿਹਾ ਹਾਂ। ਮੈਂ ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਸਲਾਹ ਦਿੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ 'ਤੇ ਸਥਾਪਿਤ ਕਰੋ ਜਾਂ ਗੂਗਲ ਕੋਲਬ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ।

ਪਹਿਲਾ ਕਦਮ

ਕਾਗਲ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਤੁਹਾਡਾ ਮਹੱਤਵਪੂਰਨ ਸਹਾਇਕ ਹੈ। ਸਿਧਾਂਤ ਵਿੱਚ, ਤੁਸੀਂ ਇਸ ਤੋਂ ਬਿਨਾਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਮੈਂ ਇਸ ਬਾਰੇ ਇੱਕ ਹੋਰ ਲੇਖ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗਾ. ਇਹ ਇੱਕ ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ ਡੇਟਾ ਸਾਇੰਸ ਮੁਕਾਬਲਿਆਂ ਦੀ ਮੇਜ਼ਬਾਨੀ ਕਰਦਾ ਹੈ। ਅਜਿਹੇ ਹਰੇਕ ਮੁਕਾਬਲੇ ਵਿੱਚ, ਸ਼ੁਰੂਆਤੀ ਪੜਾਵਾਂ ਵਿੱਚ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ, ਵਿਕਾਸ ਅਨੁਭਵ ਅਤੇ ਇੱਕ ਟੀਮ ਵਿੱਚ ਕੰਮ ਕਰਨ ਦਾ ਤਜਰਬਾ, ਜੋ ਕਿ ਸਾਡੇ ਸਮੇਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਅਨੁਭਵ ਪ੍ਰਾਪਤ ਕਰੋਗੇ।

ਅਸੀਂ ਉਥੋਂ ਆਪਣਾ ਕੰਮ ਲਵਾਂਗੇ। ਇਸਨੂੰ "ਟਾਈਟੈਨਿਕ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਸ਼ਰਤ ਇਹ ਹੈ: ਭਵਿੱਖਬਾਣੀ ਕਰੋ ਕਿ ਕੀ ਹਰੇਕ ਵਿਅਕਤੀ ਬਚੇਗਾ ਜਾਂ ਨਹੀਂ। ਆਮ ਤੌਰ 'ਤੇ, DS ਵਿੱਚ ਸ਼ਾਮਲ ਇੱਕ ਵਿਅਕਤੀ ਦਾ ਕੰਮ ਡੇਟਾ ਇਕੱਠਾ ਕਰਨਾ, ਇਸਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ, ਇੱਕ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣਾ, ਪੂਰਵ ਅਨੁਮਾਨ ਲਗਾਉਣਾ ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਹੈ। ਕਾਗਲ ਵਿੱਚ, ਸਾਨੂੰ ਡੇਟਾ ਇਕੱਤਰ ਕਰਨ ਦੇ ਪੜਾਅ ਨੂੰ ਛੱਡਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ - ਉਹ ਪਲੇਟਫਾਰਮ 'ਤੇ ਪੇਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਸਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਅਸੀਂ ਸ਼ੁਰੂਆਤ ਕਰ ਸਕਦੇ ਹਾਂ!

ਤੁਸੀਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕਰ ਸਕਦੇ ਹੋ:

ਡੇਟਾ ਟੈਬ ਵਿੱਚ ਉਹ ਫਾਈਲਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜਿਹਨਾਂ ਵਿੱਚ ਡੇਟਾ ਹੁੰਦਾ ਹੈ

ਅਸੀਂ ਡਾਟਾ ਡਾਊਨਲੋਡ ਕੀਤਾ, ਸਾਡੀਆਂ ਜੁਪੀਟਰ ਨੋਟਬੁੱਕਾਂ ਤਿਆਰ ਕੀਤੀਆਂ ਅਤੇ...

ਦੂਜਾ ਕਦਮ

ਹੁਣ ਅਸੀਂ ਇਸ ਡੇਟਾ ਨੂੰ ਕਿਵੇਂ ਲੋਡ ਕਰਦੇ ਹਾਂ?

ਪਹਿਲਾਂ, ਆਓ ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੀਏ:

import pandas as pd
import numpy as np

Pandas ਸਾਨੂੰ ਅੱਗੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ .csv ਫਾਈਲਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ।

ਨੰਬਰਾਂ ਦੇ ਨਾਲ ਇੱਕ ਮੈਟ੍ਰਿਕਸ ਦੇ ਰੂਪ ਵਿੱਚ ਸਾਡੀ ਡੇਟਾ ਸਾਰਣੀ ਨੂੰ ਦਰਸਾਉਣ ਲਈ Numpy ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਲੰਗ ਜਾਓ. ਚਲੋ ਫਾਈਲ train.csv ਲੈ ਕੇ ਇਸਨੂੰ ਸਾਡੇ ਲਈ ਅਪਲੋਡ ਕਰੀਏ:

dataset = pd.read_csv('train.csv')

ਅਸੀਂ ਡੇਟਾਸੇਟ ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਸਾਡੀ train.csv ਡੇਟਾ ਚੋਣ ਦਾ ਹਵਾਲਾ ਦੇਵਾਂਗੇ। ਆਓ ਦੇਖੀਏ ਕਿ ਉੱਥੇ ਕੀ ਹੈ:

dataset.head()

head() ਫੰਕਸ਼ਨ ਸਾਨੂੰ ਡੇਟਾਫ੍ਰੇਮ ਦੀਆਂ ਪਹਿਲੀਆਂ ਕੁਝ ਕਤਾਰਾਂ ਨੂੰ ਵੇਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਬਚੇ ਹੋਏ ਕਾਲਮ ਬਿਲਕੁਲ ਸਾਡੇ ਨਤੀਜੇ ਹਨ, ਜੋ ਇਸ ਡੇਟਾਫ੍ਰੇਮ ਵਿੱਚ ਜਾਣੇ ਜਾਂਦੇ ਹਨ। ਕਾਰਜ ਪ੍ਰਸ਼ਨ ਲਈ, ਸਾਨੂੰ test.csv ਡੇਟਾ ਲਈ ਬਚੇ ਹੋਏ ਕਾਲਮ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਡੇਟਾ ਟਾਈਟੈਨਿਕ ਦੇ ਹੋਰ ਯਾਤਰੀਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਜਿਸ ਲਈ ਅਸੀਂ, ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹੋਏ, ਨਤੀਜਾ ਨਹੀਂ ਜਾਣਦੇ ਹਾਂ।

ਇਸ ਲਈ, ਆਓ ਆਪਣੀ ਸਾਰਣੀ ਨੂੰ ਨਿਰਭਰ ਅਤੇ ਸੁਤੰਤਰ ਡੇਟਾ ਵਿੱਚ ਵੰਡੀਏ। ਇੱਥੇ ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ. ਨਿਰਭਰ ਡੇਟਾ ਉਹ ਡੇਟਾ ਹੁੰਦੇ ਹਨ ਜੋ ਨਤੀਜਿਆਂ ਵਿੱਚ ਸੁਤੰਤਰ ਡੇਟਾ ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਸੁਤੰਤਰ ਡੇਟਾ ਉਹ ਡੇਟਾ ਹੁੰਦੇ ਹਨ ਜੋ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਦੇ ਹਨ।

ਉਦਾਹਰਨ ਲਈ, ਸਾਡੇ ਕੋਲ ਹੇਠਾਂ ਦਿੱਤੇ ਡੇਟਾ ਸੈੱਟ ਹਨ:

“ਵੋਵਾ ਨੇ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਪੜ੍ਹਾਇਆ - ਨਹੀਂ।
ਵੋਵਾ ਨੇ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਵਿੱਚ 2 ਪ੍ਰਾਪਤ ਕੀਤੇ।

ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਵਿੱਚ ਗ੍ਰੇਡ ਸਵਾਲ ਦੇ ਜਵਾਬ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ: ਕੀ ਵੋਵਾ ਨੇ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਦਾ ਅਧਿਐਨ ਕੀਤਾ? ਕੀ ਇਹ ਸਪੱਸ਼ਟ ਹੈ? ਆਓ ਅੱਗੇ ਵਧੀਏ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਟੀਚੇ ਦੇ ਨੇੜੇ ਹਾਂ!

ਸੁਤੰਤਰ ਡੇਟਾ ਲਈ ਰਵਾਇਤੀ ਵੇਰੀਏਬਲ X ਹੈ। ਨਿਰਭਰ ਡੇਟਾ ਲਈ, y.

ਅਸੀਂ ਹੇਠ ਲਿਖੇ ਕੰਮ ਕਰਦੇ ਹਾਂ:

X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]

ਇਹ ਕੀ ਹੈ? ਫੰਕਸ਼ਨ iloc[:, 2: ] ਨਾਲ ਅਸੀਂ Python ਨੂੰ ਦੱਸਦੇ ਹਾਂ: ਮੈਂ ਵੇਰੀਏਬਲ X ਵਿੱਚ ਦੂਜੇ ਕਾਲਮ ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਦੇਖਣਾ ਚਾਹੁੰਦਾ ਹਾਂ (ਸਮੇਤ ਅਤੇ ਬਸ਼ਰਤੇ ਕਿ ਗਿਣਤੀ ਜ਼ੀਰੋ ਤੋਂ ਸ਼ੁਰੂ ਹੋਵੇ)। ਦੂਜੀ ਲਾਈਨ ਵਿੱਚ ਅਸੀਂ ਕਹਿੰਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਪਹਿਲੇ ਕਾਲਮ ਵਿੱਚ ਡੇਟਾ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ।

[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)

ਸੁਪਰ! ਆਓ ਅਗਲੇ ਪੜਾਅ 'ਤੇ ਚੱਲੀਏ।

ਤੀਜਾ ਕਦਮ

ਇੱਥੇ ਸਾਨੂੰ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਏਨਕੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਕਿ ਮਸ਼ੀਨ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਝ ਸਕੇ ਕਿ ਇਹ ਡੇਟਾ ਨਤੀਜੇ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਪਰ ਅਸੀਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਏਨਕੋਡ ਨਹੀਂ ਕਰਾਂਗੇ, ਪਰ ਸਿਰਫ 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))

ਸਕਲੇਰਨ ਲਾਇਬ੍ਰੇਰੀ ਅਜਿਹੀ ਵਧੀਆ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਸਾਨੂੰ ਡੇਟਾ ਸਾਇੰਸ ਵਿੱਚ ਪੂਰਾ ਕੰਮ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਇਸ ਵਿੱਚ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਦਿਲਚਸਪ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਮਾਡਲ ਸ਼ਾਮਲ ਹਨ ਅਤੇ ਇਹ ਸਾਨੂੰ ਡਾਟਾ ਤਿਆਰ ਕਰਨ ਦੀ ਆਗਿਆ ਵੀ ਦਿੰਦਾ ਹੈ।

OneHotEncoder ਸਾਨੂੰ ਉਸ ਪ੍ਰਤੀਨਿਧਤਾ ਵਿੱਚ ਇੱਕ ਵਿਅਕਤੀ ਦੇ ਲਿੰਗ ਨੂੰ ਏਨਕੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੱਸਿਆ ਹੈ। 2 ਕਲਾਸਾਂ ਬਣਾਈਆਂ ਜਾਣਗੀਆਂ: ਮਰਦ, ਔਰਤ। ਜੇਕਰ ਵਿਅਕਤੀ ਮਰਦ ਹੈ, ਤਾਂ ਕ੍ਰਮਵਾਰ "ਪੁਰਸ਼" ਕਾਲਮ ਵਿੱਚ 1 ਅਤੇ "ਔਰਤ" ਕਾਲਮ ਵਿੱਚ 0 ਲਿਖਿਆ ਜਾਵੇਗਾ।

OneHotEncoder() ਤੋਂ ਬਾਅਦ [1] ਹੈ - ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅਸੀਂ ਕਾਲਮ ਨੰਬਰ 1 (ਜ਼ੀਰੋ ਤੋਂ ਗਿਣਦੇ ਹੋਏ) ਨੂੰ ਏਨਕੋਡ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।

ਸੁਪਰ। ਆਓ ਹੋਰ ਵੀ ਅੱਗੇ ਵਧੀਏ!

ਇੱਕ ਨਿਯਮ ਦੇ ਤੌਰ ਤੇ, ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ ਕਿ ਕੁਝ ਡੇਟਾ ਖਾਲੀ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ (ਅਰਥਾਤ, NaN - ਇੱਕ ਨੰਬਰ ਨਹੀਂ)। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਵਿਅਕਤੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹੈ: ਉਸਦਾ ਨਾਮ, ਲਿੰਗ। ਪਰ ਉਸਦੀ ਉਮਰ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀ ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਾਂਗੇ: ਅਸੀਂ ਸਾਰੇ ਕਾਲਮਾਂ ਵਿੱਚ ਅੰਕਗਣਿਤ ਦਾ ਮਤਲਬ ਲੱਭਾਂਗੇ ਅਤੇ, ਜੇਕਰ ਕਾਲਮ ਵਿੱਚ ਕੁਝ ਡੇਟਾ ਗੁੰਮ ਹੈ, ਤਾਂ ਅਸੀਂ ਗਣਿਤ ਦੇ ਮੱਧਮਾਨ ਨਾਲ ਖਾਲੀ ਥਾਂ ਨੂੰ ਭਰਾਂਗੇ।

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)

ਹੁਣ ਅਸੀਂ ਇਸ ਗੱਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹਾਂ ਕਿ ਸਥਿਤੀਆਂ ਉਦੋਂ ਵਾਪਰਦੀਆਂ ਹਨ ਜਦੋਂ ਡੇਟਾ ਬਹੁਤ ਵੱਡਾ ਹੁੰਦਾ ਹੈ। ਕੁਝ ਡੇਟਾ ਅੰਤਰਾਲ ਵਿੱਚ ਹੁੰਦਾ ਹੈ [0:1], ਜਦੋਂ ਕਿ ਕੁਝ ਸੈਂਕੜੇ ਅਤੇ ਹਜ਼ਾਰਾਂ ਤੋਂ ਪਾਰ ਜਾ ਸਕਦਾ ਹੈ। ਅਜਿਹੇ ਸਕੈਟਰ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਅਤੇ ਕੰਪਿਊਟਰ ਨੂੰ ਇਸਦੀ ਗਣਨਾ ਵਿੱਚ ਵਧੇਰੇ ਸਟੀਕ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਡੇਟਾ ਨੂੰ ਸਕੈਨ ਕਰਾਂਗੇ ਅਤੇ ਸਕੇਲ ਕਰਾਂਗੇ। ਸਾਰੇ ਨੰਬਰ ਤਿੰਨ ਤੋਂ ਵੱਧ ਨਾ ਹੋਣ ਦਿਓ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਟੈਂਡਰਡਸਕੇਲਰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])

ਹੁਣ ਸਾਡਾ ਡੇਟਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਦਾ ਹੈ:

ਕਲਾਸ. ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਆਪਣੇ ਟੀਚੇ ਦੇ ਨੇੜੇ ਹਾਂ!

ਕਦਮ ਚਾਰ

ਆਓ ਆਪਣੇ ਪਹਿਲੇ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਈਏ! ਸਕਲੈਰਨ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਅਸੀਂ ਬਹੁਤ ਸਾਰੀਆਂ ਦਿਲਚਸਪ ਚੀਜ਼ਾਂ ਲੱਭ ਸਕਦੇ ਹਾਂ। ਮੈਂ ਇਸ ਸਮੱਸਿਆ ਲਈ ਗਰੇਡੀਐਂਟ ਬੂਸਟਿੰਗ ਕਲਾਸੀਫਾਇਰ ਮਾਡਲ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ। ਅਸੀਂ ਏ ਕਲਾਸੀਫਾਇਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਕਿਉਂਕਿ ਸਾਡਾ ਕੰਮ ਇੱਕ ਵਰਗੀਕਰਨ ਦਾ ਕੰਮ ਹੈ। ਪੂਰਵ-ਅਨੁਮਾਨ ਨੂੰ 1 (ਬਚਿਆ) ਜਾਂ 0 (ਬਚਿਆ ਨਹੀਂ) ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)

ਫਿਟ ਫੰਕਸ਼ਨ ਪਾਈਥਨ ਨੂੰ ਦੱਸਦਾ ਹੈ: ਮਾਡਲ ਨੂੰ X ਅਤੇ y ਵਿਚਕਾਰ ਨਿਰਭਰਤਾਵਾਂ ਦੀ ਖੋਜ ਕਰਨ ਦਿਓ।

ਇੱਕ ਸਕਿੰਟ ਤੋਂ ਵੀ ਘੱਟ ਅਤੇ ਮਾਡਲ ਤਿਆਰ ਹੈ।

ਇਸ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ? ਅਸੀਂ ਹੁਣ ਦੇਖਾਂਗੇ!

ਕਦਮ ਪੰਜ. ਸਿੱਟਾ

ਹੁਣ ਸਾਨੂੰ ਆਪਣੇ ਟੈਸਟ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਸਾਰਣੀ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਲਈ ਸਾਨੂੰ ਇੱਕ ਪੂਰਵ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਸਾਰਣੀ ਨਾਲ ਅਸੀਂ ਉਹੀ ਸਾਰੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਾਂਗੇ ਜੋ ਅਸੀਂ 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% ਲੋਕਾਂ ਨੂੰ ਸਹੀ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਸਗੋਂ ਡਾਟਾ ਸਾਇੰਸ ਵਿੱਚ ਕੁਝ ਪ੍ਰੇਰਣਾ ਵੀ ਦਿੰਦਾ ਹੈ। ਸਭ ਤੋਂ ਉਤਸੁਕ ਵਿਅਕਤੀ ਕਿਸੇ ਵੀ ਸਮੇਂ ਮੈਨੂੰ ਨਿੱਜੀ ਸੰਦੇਸ਼ਾਂ ਵਿੱਚ ਲਿਖ ਸਕਦੇ ਹਨ ਅਤੇ ਇੱਕ ਸਵਾਲ ਪੁੱਛ ਸਕਦੇ ਹਨ। ਸਭ ਦਾ ਧੰਨਵਾਦ!

ਸਰੋਤ: www.habr.com