ഡാറ്റാ സയൻസിലെ നിങ്ങളുടെ ആദ്യ ചുവട്. ടൈറ്റാനിക്

ഒരു ചെറിയ ആമുഖ വാക്ക്

എന്തുചെയ്യണമെന്നും എങ്ങനെ ചെയ്യണമെന്നും ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങൾ നൽകിയാൽ നമുക്ക് കൂടുതൽ നേട്ടങ്ങൾ കൈവരിക്കാൻ കഴിയുമെന്ന് ഞാൻ വിശ്വസിക്കുന്നു. എവിടെ തുടങ്ങണമെന്ന് മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടായതിനാൽ എനിക്ക് എന്തെങ്കിലും ആരംഭിക്കാൻ കഴിയാത്ത നിമിഷങ്ങൾ എന്റെ ജീവിതത്തിൽ ഞാൻ ഓർക്കുന്നു. ഒരുപക്ഷേ, വളരെക്കാലം മുമ്പ്, "ഡാറ്റ സയൻസ്" എന്ന വാക്കുകൾ ഓൺലൈനിൽ കണ്ടപ്പോൾ നിങ്ങൾ അതിൽ നിന്ന് വളരെ അകലെയാണെന്നും അത് ചെയ്യുന്ന ആളുകൾ മറ്റെവിടെയോ, മറ്റൊരു ലോകത്തിലാണെന്നും നിങ്ങൾ കരുതിയിരിക്കാം. പക്ഷേ ഇല്ല, അവർ ഇവിടെയുണ്ട്. ഒരുപക്ഷേ ഈ മേഖലയിലെ ആളുകൾക്ക് നന്ദി, ഈ ലേഖനം നിങ്ങളുടെ ഫീഡിൽ എത്തി. ഈ കരകൗശലത്തിൽ വൈദഗ്ദ്ധ്യം നേടാൻ നിങ്ങളെ സഹായിക്കുന്ന ധാരാളം കോഴ്‌സുകളുണ്ട്, പക്ഷേ ഇവിടെ ഞാൻ നിങ്ങളെ ആദ്യപടി സ്വീകരിക്കാൻ സഹായിക്കും.

അപ്പോൾ, നിങ്ങൾ തയ്യാറാണോ? പൈത്തൺ 3 അറിയണമെന്ന് ഞാൻ ഉടൻ തന്നെ നിങ്ങളോട് പറയും, കാരണം അതാണ് ഞാൻ ഇവിടെ ഉപയോഗിക്കുന്നത്. ജൂപ്പിറ്റർ നോട്ട്ബുക്ക് മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്യാനോ ഗൂഗിൾ കൊളാബ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പരിശോധിക്കാനോ ഞാൻ ശുപാർശ ചെയ്യുന്നു.

സ്റ്റെപ്പ് ഒന്ന്

ഈ കാര്യത്തിൽ Kaggle ഒരു വലിയ സഹായമാണ്. തത്വത്തിൽ, നിങ്ങൾക്ക് ഇത് കൂടാതെ തന്നെ ചെയ്യാൻ കഴിയും, പക്ഷേ ഞാൻ അത് മറ്റൊരു ലേഖനത്തിൽ ഉൾപ്പെടുത്താം. ഡാറ്റാ സയൻസ് മത്സരങ്ങൾ നടത്തുന്ന ഒരു പ്ലാറ്റ്‌ഫോമാണിത്. ഈ മത്സരങ്ങളിൽ ഓരോന്നിലും, പ്രാരംഭ ഘട്ടത്തിൽ, വിവിധ തരത്തിലുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിൽ നിങ്ങൾക്ക് അവിശ്വസനീയമായ അനുഭവം, വികസന അനുഭവം, ടീം വർക്ക് അനുഭവം എന്നിവ ലഭിക്കും, ഇത് ഇന്ന് നിർണായകമാണ്.

നമ്മുടെ പ്രശ്നം അവിടെ നിന്ന് നോക്കാം. അതിനെ "ടൈറ്റാനിക്" എന്ന് വിളിക്കുന്നു. ഓരോ വ്യക്തിയും അതിജീവിക്കുമോ എന്ന് പ്രവചിക്കുക എന്നതാണ് ലക്ഷ്യം. പൊതുവായി പറഞ്ഞാൽ, ഒരു ഡാറ്റാ സയന്റിസ്റ്റിന്റെ ജോലി ഡാറ്റ ശേഖരിക്കുക, അത് പ്രോസസ്സ് ചെയ്യുക, ഒരു മോഡലിനെ പരിശീലിപ്പിക്കുക, ഒരു പ്രവചനം നടത്തുക തുടങ്ങിയവയാണ്. മറുവശത്ത്, കഗ്ഗിൾ ഡാറ്റാ ശേഖരണ ഘട്ടം ഒഴിവാക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു - ഇതെല്ലാം പ്ലാറ്റ്‌ഫോമിൽ ലഭ്യമാണ്. നമ്മൾ അത് അപ്‌ലോഡ് ചെയ്യേണ്ടതുണ്ട്, നമുക്ക് ആരംഭിക്കാം!

ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യാം:

ഡാറ്റ ടാബിൽ ഡാറ്റ അടങ്ങിയിരിക്കുന്ന ഫയലുകൾ അടങ്ങിയിരിക്കുന്നു

ഞങ്ങൾ ഡാറ്റ ലോഡ് ചെയ്തു, ഞങ്ങളുടെ ജൂപ്പിറ്റർ നോട്ട്ബുക്കുകൾ തയ്യാറാക്കി, കൂടാതെ...

ഘട്ടം രണ്ട്

ഈ ഡാറ്റ ഇപ്പോൾ എങ്ങനെ ഡൗൺലോഡ് ചെയ്യാം?

ആദ്യം, ആവശ്യമായ ലൈബ്രറികൾ ഇറക്കുമതി ചെയ്യാം:

import pandas as pd
import numpy as np

കൂടുതൽ പ്രോസസ്സിംഗിനായി .csv ഫയലുകൾ ലോഡ് ചെയ്യാൻ പാണ്ടകൾ ഞങ്ങളെ അനുവദിക്കും.

നമ്മുടെ ഡാറ്റ പട്ടികയെ സംഖ്യകളുടെ ഒരു മാട്രിക്സായി പ്രതിനിധീകരിക്കുന്നതിന് നമ്പി ആവശ്യമാണ്.
നമുക്ക് മുന്നോട്ട് പോകാം. നമുക്ക് 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:] ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് നമ്മൾ പൈത്തണിനോട് പറയുന്നു: വേരിയബിൾ X-ൽ രണ്ടാമത്തെ കോളത്തിൽ നിന്ന് ആരംഭിക്കുന്ന ഡാറ്റ (എണ്ണം പൂജ്യത്തിൽ ആരംഭിക്കുന്നുണ്ടെങ്കിൽ ഉൾപ്പെടെ) കാണാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. രണ്ടാമത്തെ വരിയിൽ, y-യിൽ ആദ്യ കോളത്തിൽ നിന്നുള്ള ഡാറ്റ കാണാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു എന്ന് പറയുന്നു.

[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 നമ്മെ അനുവദിക്കും. ഇത് രണ്ട് ക്ലാസുകൾ സൃഷ്ടിക്കും: പുരുഷനും സ്ത്രീയും. വ്യക്തി പുരുഷനാണെങ്കിൽ, "പുരുഷ" കോളത്തിന് യഥാക്രമം 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:])

ഇപ്പോൾ ഞങ്ങളുടെ ഡാറ്റ ഇതുപോലെ കാണപ്പെടുന്നു:

കൊള്ളാം. നമ്മൾ ലക്ഷ്യത്തിന് അടുത്തെത്തി!

ഘട്ടം നാല്

നമ്മുടെ ആദ്യത്തെ മോഡലിനെ പരിശീലിപ്പിക്കാം! sklearn ലൈബ്രറിയിൽ നമുക്ക് ധാരാളം രസകരമായ കാര്യങ്ങൾ കണ്ടെത്താൻ കഴിയും. ഈ പ്രശ്നത്തിന് ഞാൻ ഗ്രേഡിയന്റ് ബൂസ്റ്റിംഗ് ക്ലാസിഫയർ മോഡൽ പ്രയോഗിച്ചു. നമ്മുടെ ടാസ്‌ക് ഒരു വർഗ്ഗീകരണ പ്രശ്‌നമായതിനാൽ നമ്മൾ ഒരു ക്ലാസിഫയർ ഉപയോഗിക്കുന്നു. 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