თქვენი პირველი ნაბიჯი მონაცემთა მეცნიერებაში. ტიტანიკი

მოკლე შესავალი სიტყვა

მე მჯერა, რომ ჩვენ შეგვეძლო მეტი რამის გაკეთება, თუ მივიღებთ ნაბიჯ-ნაბიჯ ინსტრუქციებს, რომლებიც გვეუბნებიან, რა და როგორ გავაკეთოთ. მე თვითონ მახსოვს მომენტები ჩემს ცხოვრებაში, როდესაც რაღაცის დაწყება არ შემეძლო, რადგან უბრალოდ რთული იყო იმის გაგება, თუ სად უნდა დამეწყო. შესაძლოა, ერთხელ ინტერნეტში დაინახეთ სიტყვები "მონაცემთა მეცნიერება" და გადაწყვიტეთ, რომ თქვენ შორს იყავით ამისგან და ადამიანები, რომლებიც ამას აკეთებენ, სადღაც იქ, სხვა სამყაროში იყვნენ. არა, ისინი აქ არიან. და, ალბათ, ამ სფეროს ხალხის წყალობით, თქვენს არხზე გამოჩნდა სტატია. არსებობს უამრავი კურსი, რომელიც დაგეხმარებათ შეეგუოთ ამ ხელობას, მაგრამ აქ მე დაგეხმარებით პირველი ნაბიჯის გადადგმაში.

აბა, მზად ხარ? ნება მომეცით დაუყოვნებლივ გითხრათ, რომ თქვენ უნდა იცოდეთ Python 3, რადგან სწორედ ამას გამოვიყენებ აქ. ასევე გირჩევთ წინასწარ დააინსტალიროთ Jupyter Notebook-ზე ან ნახეთ როგორ გამოიყენოთ google colab.

ნაბიჯი ერთი

კაგლი თქვენი მნიშვნელოვანი თანაშემწეა ამ საკითხში. პრინციპში, ამის გარეშე შეგიძლიათ, მაგრამ ამაზე სხვა სტატიაში ვისაუბრებ. ეს არის პლატფორმა, რომელიც მასპინძლობს მონაცემთა მეცნიერების კონკურსებს. თითოეულ ასეთ კონკურსში, ადრეულ ეტაპზე თქვენ მიიღებთ არარეალურ გამოცდილებას სხვადასხვა სახის პრობლემების გადაჭრის, განვითარების გამოცდილებას და გუნდში მუშაობის გამოცდილებას, რაც მნიშვნელოვანია ჩვენს დროში.

ჩვენ იქიდან ავიღებთ ჩვენს დავალებას. მას "ტიტანიკი" ჰქვია. პირობა ასეთია: იწინასწარმეტყველე გადარჩება თუ არა თითოეული ადამიანი. ზოგადად რომ ვთქვათ, DS-ში ჩართული პირის ამოცანაა მონაცემების შეგროვება, დამუშავება, მოდელის მომზადება, პროგნოზირება და ა.შ. Kaggle-ში ჩვენ გვაქვს უფლება გამოვტოვოთ მონაცემთა შეგროვების ეტაპი - ისინი წარმოდგენილია პლატფორმაზე. ჩვენ უნდა გადმოვწეროთ ისინი და შეგვიძლია დავიწყოთ!

ამის გაკეთება შეგიძლიათ შემდეგნაირად:

მონაცემთა ჩანართი შეიცავს ფაილებს, რომლებიც შეიცავს მონაცემებს

გადმოვწერეთ მონაცემები, მოვამზადეთ ჩვენი Jupyter-ის ნოუთბუქები და...

ნაბიჯი მეორე

როგორ ჩავტვირთოთ ახლა ეს მონაცემები?

პირველ რიგში, მოდით შემოვიტანოთ საჭირო ბიბლიოთეკები:

import pandas as pd
import numpy as np

Pandas მოგვცემს საშუალებას გადმოვწეროთ .csv ფაილები შემდგომი დამუშავებისთვის.

Numpy საჭიროა ჩვენი მონაცემთა ცხრილის წარმოსაჩენად, როგორც მატრიცა რიცხვებით.
Განაგრძე. ავიღოთ ფაილი train.csv და ავტვირთოთ ჩვენთან:

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

ჩვენ მივმართავთ ჩვენს train.csv მონაცემთა შერჩევას მონაცემთა ნაკრების ცვლადის მეშვეობით. ვნახოთ რა არის იქ:

dataset.head()

head() ფუნქცია საშუალებას გვაძლევს გადავხედოთ მონაცემთა ჩარჩოს პირველ რამდენიმე სტრიქონს.

Survived სვეტები არის ზუსტად ჩვენი შედეგები, რომლებიც ცნობილია ამ მონაცემთა ჩარჩოში. დავალების კითხვისთვის, ჩვენ უნდა ვიწინასწარმეტყველოთ Survived სვეტი 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))

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

ახლა ჩვენი მონაცემები ასე გამოიყურება:

Კლასი. ჩვენ უკვე ახლოს ვართ მიზანთან!

ნაბიჯი მეოთხე

ვავარჯიშოთ ჩვენი პირველი მოდელი! Sklearn ბიბლიოთეკიდან ჩვენ შეგვიძლია ვიპოვოთ უამრავი საინტერესო რამ. მე გამოვიყენე Gradient Boosting Classifier მოდელი ამ პრობლემაზე. ჩვენ ვიყენებთ კლასიფიკატორს, რადგან ჩვენი ამოცანა არის კლასიფიკაციის ამოცანა. პროგნოზი უნდა დაინიშნოს 1 (გადარჩენილი) ან 0 (არ გადარჩა).

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

fit ფუნქცია ეუბნება Python-ს: მოდით, მოდელმა მოძებნოს დამოკიდებულებები 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