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

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

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

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

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

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

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

നിങ്ങൾക്ക് ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യാൻ കഴിയും:

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

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

ഘട്ടം രണ്ട്

ഇപ്പോൾ എങ്ങനെയാണ് ഈ ഡാറ്റ ലോഡ് ചെയ്യുക?

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

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:])

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

ക്ലാസ്. ഞങ്ങൾ ഇതിനകം ഞങ്ങളുടെ ലക്ഷ്യത്തിനടുത്താണ്!

ഘട്ടം നാല്

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