ಡೇಟಾ ಸೈನ್ಸ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಮೊದಲ ಹೆಜ್ಜೆ. ಟೈಟಾನಿಕ್

ಒಂದು ಸಣ್ಣ ಪರಿಚಯಾತ್ಮಕ ಪದ

ಏನು ಮಾಡಬೇಕೆಂದು ಮತ್ತು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಮಗೆ ತಿಳಿಸುವ ಹಂತ-ಹಂತದ ಸೂಚನೆಗಳನ್ನು ನಮಗೆ ಒದಗಿಸಿದರೆ ನಾವು ಹೆಚ್ಚಿನ ಕೆಲಸಗಳನ್ನು ಮಾಡಬಹುದು ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ. ನನ್ನ ಜೀವನದಲ್ಲಿ ನಾನು ಏನನ್ನಾದರೂ ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗದ ಕ್ಷಣಗಳನ್ನು ನಾನು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೇನೆ ಏಕೆಂದರೆ ಎಲ್ಲಿಂದ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಷ್ಟಕರವಾಗಿತ್ತು. ಬಹುಶಃ, ಒಮ್ಮೆ ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ನೀವು "ಡೇಟಾ ಸೈನ್ಸ್" ಪದಗಳನ್ನು ನೋಡಿದ್ದೀರಿ ಮತ್ತು ನೀವು ಇದರಿಂದ ದೂರವಿದ್ದೀರಿ ಎಂದು ನಿರ್ಧರಿಸಿದ್ದೀರಿ ಮತ್ತು ಇದನ್ನು ಮಾಡುವ ಜನರು ಎಲ್ಲೋ ಬೇರೆ ಜಗತ್ತಿನಲ್ಲಿದ್ದಾರೆ. ಇಲ್ಲ, ಅವರು ಇಲ್ಲಿಯೇ ಇದ್ದಾರೆ. ಮತ್ತು, ಬಹುಶಃ, ಈ ಕ್ಷೇತ್ರದ ಜನರಿಗೆ ಧನ್ಯವಾದಗಳು, ನಿಮ್ಮ ಫೀಡ್ನಲ್ಲಿ ಲೇಖನವು ಕಾಣಿಸಿಕೊಂಡಿದೆ. ಈ ಕರಕುಶಲತೆಗೆ ಬಳಸಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಸಾಕಷ್ಟು ಕೋರ್ಸ್‌ಗಳಿವೆ, ಆದರೆ ಇಲ್ಲಿ ನಾನು ನಿಮಗೆ ಮೊದಲ ಹೆಜ್ಜೆ ಇಡಲು ಸಹಾಯ ಮಾಡುತ್ತೇನೆ.

ಸರಿ, ನೀವು ಸಿದ್ಧರಿದ್ದೀರಾ? ನೀವು ಪೈಥಾನ್ 3 ಅನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಎಂದು ನಾನು ನಿಮಗೆ ಈಗಿನಿಂದಲೇ ಹೇಳುತ್ತೇನೆ, ಏಕೆಂದರೆ ನಾನು ಇಲ್ಲಿ ಬಳಸುತ್ತಿದ್ದೇನೆ. ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ಅದನ್ನು ಮುಂಚಿತವಾಗಿ ಸ್ಥಾಪಿಸಲು ಅಥವಾ ಗೂಗಲ್ ಕೋಲಾಬ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನೋಡಲು ನಾನು ನಿಮಗೆ ಸಲಹೆ ನೀಡುತ್ತೇನೆ.

ಹಂತ ಒಂದು

ಈ ವಿಷಯದಲ್ಲಿ ಕಗ್ಲೆ ನಿಮ್ಮ ಮಹತ್ವದ ಸಹಾಯಕ. ತಾತ್ವಿಕವಾಗಿ, ನೀವು ಇಲ್ಲದೆ ಮಾಡಬಹುದು, ಆದರೆ ನಾನು ಇನ್ನೊಂದು ಲೇಖನದಲ್ಲಿ ಇದರ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ. ಇದು ಡೇಟಾ ಸೈನ್ಸ್ ಸ್ಪರ್ಧೆಗಳನ್ನು ಆಯೋಜಿಸುವ ವೇದಿಕೆಯಾಗಿದೆ. ಅಂತಹ ಪ್ರತಿಯೊಂದು ಸ್ಪರ್ಧೆಯಲ್ಲಿ, ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ ನೀವು ವಿವಿಧ ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ ಅವಾಸ್ತವಿಕ ಅನುಭವವನ್ನು ಪಡೆಯುತ್ತೀರಿ, ಅಭಿವೃದ್ಧಿ ಅನುಭವ ಮತ್ತು ತಂಡದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಅನುಭವ, ಇದು ನಮ್ಮ ಸಮಯದಲ್ಲಿ ಮುಖ್ಯವಾಗಿದೆ.

ನಾವು ಅಲ್ಲಿಂದ ನಮ್ಮ ಕೆಲಸವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಇದನ್ನು "ಟೈಟಾನಿಕ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಪರಿಸ್ಥಿತಿ ಹೀಗಿದೆ: ಪ್ರತಿಯೊಬ್ಬ ವ್ಯಕ್ತಿಯು ಬದುಕುಳಿಯುತ್ತಾನೆಯೇ ಎಂದು ಊಹಿಸಿ. ಸಾಮಾನ್ಯವಾಗಿ ಹೇಳುವುದಾದರೆ, DS ನಲ್ಲಿ ತೊಡಗಿರುವ ವ್ಯಕ್ತಿಯ ಕಾರ್ಯವು ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು, ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದು, ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುವುದು, ಮುನ್ಸೂಚನೆ, ಇತ್ಯಾದಿ. Kaggle ನಲ್ಲಿ, ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಹಂತವನ್ನು ಬಿಟ್ಟುಬಿಡಲು ನಮಗೆ ಅನುಮತಿಸಲಾಗಿದೆ - ಅವುಗಳನ್ನು ವೇದಿಕೆಯಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗುತ್ತದೆ. ನಾವು ಅವುಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗಿದೆ ಮತ್ತು ನಾವು ಪ್ರಾರಂಭಿಸಬಹುದು!

ನೀವು ಇದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಮಾಡಬಹುದು:

ಡೇಟಾ ಟ್ಯಾಬ್ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ

ನಾವು ಡೇಟಾವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ, ನಮ್ಮ ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್‌ಗಳನ್ನು ಸಿದ್ಧಪಡಿಸಿದ್ದೇವೆ ಮತ್ತು...

ಹಂತ ಎರಡು

ನಾವು ಈಗ ಈ ಡೇಟಾವನ್ನು ಹೇಗೆ ಲೋಡ್ ಮಾಡುತ್ತೇವೆ?

ಮೊದಲಿಗೆ, ಅಗತ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳೋಣ:

import pandas as pd
import numpy as np

ಮುಂದಿನ ಪ್ರಕ್ರಿಯೆಗಾಗಿ .csv ಫೈಲ್‌ಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಪಾಂಡಾಗಳು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಆಗಿ ನಮ್ಮ ಡೇಟಾ ಟೇಬಲ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸಲು Numpy ಅಗತ್ಯವಿದೆ.
ಮುಂದುವರೆಯಿರಿ. ನಾವು train.csv ಫೈಲ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ನಮಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡೋಣ:

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

ಡೇಟಾಸೆಟ್ ವೇರಿಯಬಲ್ ಮೂಲಕ ನಾವು ನಮ್ಮ train.csv ಡೇಟಾ ಆಯ್ಕೆಯನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ. ಅಲ್ಲಿ ಏನಿದೆ ಎಂದು ನೋಡೋಣ:

dataset.head()

ಹೆಡ್() ಕಾರ್ಯವು ಡೇಟಾಫ್ರೇಮ್‌ನ ಮೊದಲ ಕೆಲವು ಸಾಲುಗಳನ್ನು ನೋಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉಳಿದಿರುವ ಕಾಲಮ್‌ಗಳು ನಿಖರವಾಗಿ ನಮ್ಮ ಫಲಿತಾಂಶಗಳಾಗಿವೆ, ಇವುಗಳನ್ನು ಈ ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ. ಕಾರ್ಯದ ಪ್ರಶ್ನೆಗಾಗಿ, test.csv ಡೇಟಾಗಾಗಿ ನಾವು ಸರ್ವೈವ್ಡ್ ಕಾಲಮ್ ಅನ್ನು ಊಹಿಸಬೇಕಾಗಿದೆ. ಈ ಡೇಟಾವು ಟೈಟಾನಿಕ್‌ನ ಇತರ ಪ್ರಯಾಣಿಕರ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಇದಕ್ಕಾಗಿ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ, ಫಲಿತಾಂಶವು ತಿಳಿದಿಲ್ಲ.

ಆದ್ದರಿಂದ, ನಮ್ಮ ಟೇಬಲ್ ಅನ್ನು ಅವಲಂಬಿತ ಮತ್ತು ಸ್ವತಂತ್ರ ಡೇಟಾಗೆ ವಿಭಜಿಸೋಣ. ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ. ಅವಲಂಬಿತ ಡೇಟಾವು ಫಲಿತಾಂಶಗಳಲ್ಲಿರುವ ಸ್ವತಂತ್ರ ಡೇಟಾವನ್ನು ಅವಲಂಬಿಸಿರುವ ಡೇಟಾ. ಸ್ವತಂತ್ರ ಡೇಟಾವು ಫಲಿತಾಂಶದ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರುವ ಡೇಟಾ.

ಉದಾಹರಣೆಗೆ, ನಾವು ಈ ಕೆಳಗಿನ ಡೇಟಾ ಸೆಟ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ:

“ವೋವಾ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನವನ್ನು ಕಲಿಸಿದರು - ಇಲ್ಲ.
Vova ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ 2 ಪಡೆದರು.

ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿನ ಗ್ರೇಡ್ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ: ವೋವಾ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನವನ್ನು ಅಧ್ಯಯನ ಮಾಡಿದ್ದಾರೆಯೇ? ಇದು ಸ್ಪಷ್ಟವಾಗಿದೆಯೇ? ನಾವು ಮುಂದುವರಿಯೋಣ, ನಾವು ಈಗಾಗಲೇ ಗುರಿಗೆ ಹತ್ತಿರವಾಗಿದ್ದೇವೆ!

ಸ್ವತಂತ್ರ ಡೇಟಾಗೆ ಸಾಂಪ್ರದಾಯಿಕ ವೇರಿಯೇಬಲ್ X. ಅವಲಂಬಿತ ಡೇಟಾಗಾಗಿ, y.

ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತೇವೆ:

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

ಅದು ಏನು? iloc[:, 2: ] ಕಾರ್ಯದೊಂದಿಗೆ ನಾವು ಪೈಥಾನ್‌ಗೆ ಹೇಳುತ್ತೇವೆ: ಎರಡನೇ ಕಾಲಮ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಡೇಟಾವನ್ನು ನಾನು ವೇರಿಯಬಲ್ 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