தரவு அறிவியலில் உங்கள் முதல் படி. டைட்டானிக்

ஒரு சிறிய அறிமுக வார்த்தை

என்ன செய்ய வேண்டும், எப்படிச் செய்ய வேண்டும் என்பதை எங்களுக்குத் தெரிவிக்கும் படிப்படியான வழிமுறைகள் வழங்கப்பட்டால், இன்னும் பல விஷயங்களைச் செய்ய முடியும் என்று நான் நம்புகிறேன். எங்கிருந்து தொடங்குவது என்பதைப் புரிந்துகொள்வது கடினமாக இருந்ததால், எதையாவது தொடங்க முடியாத தருணங்களை நான் நினைவில் வைத்திருக்கிறேன். ஒருவேளை, ஒரு காலத்தில் இணையத்தில் நீங்கள் "டேட்டா சயின்ஸ்" என்ற வார்த்தைகளைப் பார்த்தீர்கள், நீங்கள் இதிலிருந்து வெகு தொலைவில் இருக்கிறீர்கள் என்று முடிவு செய்திருக்கலாம், இதைச் செய்பவர்கள் வேறொரு உலகில் எங்காவது இருந்திருக்கலாம். இல்லை, அவர்கள் இங்கேயே இருக்கிறார்கள். மற்றும், ஒருவேளை, இந்தத் துறையில் உள்ளவர்களுக்கு நன்றி, உங்கள் ஊட்டத்தில் ஒரு கட்டுரை தோன்றியது. இந்த கைவினைப்பொருளில் நீங்கள் வசதியாக இருக்க உதவும் பல படிப்புகள் உள்ளன, ஆனால் முதல் படி எடுக்க நான் உங்களுக்கு உதவுகிறேன்.

சரி, நீங்கள் தயாரா? பைதான் 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 தரவுக்கான சர்வைவ் நெடுவரிசையை நாம் கணிக்க வேண்டும். இந்தத் தரவு டைட்டானிக்கின் பிற பயணிகளைப் பற்றிய தகவல்களைச் சேமிக்கிறது, அதற்காக நாங்கள் சிக்கலைத் தீர்க்கிறோம், அதன் விளைவு எங்களுக்குத் தெரியாது.

எனவே, எங்கள் அட்டவணையை சார்பு மற்றும் சுயாதீனமான தரவுகளாகப் பிரிப்போம். இங்கே எல்லாம் எளிது. சார்பு தரவு என்பது விளைவுகளில் உள்ள சுயாதீனமான தரவைச் சார்ந்து இருக்கும் தரவு. சுயாதீன தரவு என்பது முடிவை பாதிக்கும் தரவு.

எடுத்துக்காட்டாக, எங்களிடம் பின்வரும் தரவுத் தொகுப்பு உள்ளது:

“வோவா கணினி அறிவியலைக் கற்பித்தார் - இல்லை.
வோவா கணினி அறிவியலில் 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))

sklearn நூலகம் தரவு அறிவியலில் முழுமையான வேலைகளைச் செய்ய அனுமதிக்கும் ஒரு அருமையான நூலகம் ஆகும். இது அதிக எண்ணிக்கையிலான சுவாரஸ்யமான இயந்திர கற்றல் மாதிரிகளைக் கொண்டுள்ளது மற்றும் தரவுத் தயாரிப்பையும் செய்ய அனுமதிக்கிறது.

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], சில நூற்றுக்கணக்கான மற்றும் ஆயிரங்களுக்கு அப்பால் செல்லலாம். அத்தகைய சிதறலை அகற்றவும், கணினியை அதன் கணக்கீடுகளில் துல்லியமாக மாற்றவும், நாங்கள் தரவை ஸ்கேன் செய்து அதை அளவிடுவோம். எல்லா எண்களும் மூன்றை தாண்டக்கூடாது. இதைச் செய்ய, நாங்கள் StandardScaler செயல்பாட்டைப் பயன்படுத்துவோம்.

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

இப்போது எங்கள் தரவு இதுபோல் தெரிகிறது:

வர்க்கம். நாங்கள் ஏற்கனவே எங்கள் இலக்கை நெருங்கிவிட்டோம்!

படி நான்கு

எங்கள் முதல் மாதிரியைப் பயிற்றுவிப்போம்! ஸ்க்லேர்ன் நூலகத்திலிருந்து நாம் ஏராளமான சுவாரஸ்யமான விஷயங்களைக் காணலாம். இந்தச் சிக்கலுக்கு கிரேடியண்ட் பூஸ்டிங் கிளாசிஃபையர் மாதிரியைப் பயன்படுத்தினேன். எங்கள் பணி ஒரு வகைப்பாடு பணி என்பதால் நாங்கள் A வகைப்படுத்தியைப் பயன்படுத்துகிறோம். முன்கணிப்பு 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