Sådan kommer du i gang med maskinindlæring på cirka 10 minutter

Med stigningen i maskinlæring inden for brancher er behovet for et værktøj, der hurtigt kan hjælpe dig med at gentage gennem processen, blevet meget vigtigt. Python, en voksende stjerne inden for maskinlæringsteknologi, er ofte det første valg, der giver dig succes. Så en guide til maskinindlæring med Python er virkelig nødvendig.

Introduktion til maskinindlæring med Python

Så hvorfor Python? Efter min erfaring er Python et af de nemmeste programmeringssprog at lære. Der er behov for at gentage processen hurtigt, og dataforskeren behøver ikke at have et dybt kendskab til sproget, da de hurtigt kan få fat i det.

Hvor let?

for anything in the_list: print(anything)

Så let . Syntaksen er tæt knyttet til engelsk (eller menneskeligt sprog, ikke en maskine). Og der er ingen dumme krøllede parenteser, der forvirrer mennesker. Jeg har en kollega, der er i kvalitetssikring, ikke en softwareingeniør, og hun kan skrive Python-kode inden for en dag på produktionsniveau. (Virkeligt!)

Så de bygherrer af bibliotekerne, vi vil diskutere nedenfor, valgte Python for deres valg af sprog. Og som dataanalytiker og videnskabsmand kan vi bare bruge deres mesterværker til at hjælpe os med at fuldføre opgaverne. Dette er de utrolige biblioteker, der er must-haves til maskinindlæring med Python .

  1. Numpy

Det berømte numeriske analysebibliotek. Det vil hjælpe dig med at gøre mange ting, lige fra beregning af medianen for datadistribution til behandling af flerdimensionelle matrixer.

2. Pandaer

Til behandling af CSV-filer. Selvfølgelig skal du behandle nogle tabeller og se statistikker, og dette er det rigtige værktøj, du vil bruge.

3. Matplotlib

Når du har gemt dataene i Pandas-datarammer, har du muligvis brug for nogle visualiseringer for at forstå mere om dataene. Billeder er stadig bedre end tusinder af ord.

4. Søfødt

Dette er også et andet visualiseringsværktøj, men mere fokuseret på statistisk visualisering. Ting som histogrammer eller cirkeldiagrammer eller kurver eller måske sammenhængstabeller.

5. Scikit-Learn

Dette er den sidste chef for Machine Learning med Python. DEN SÅ KALDTE Machine Learning med Python er denne fyr. Scikit-Learn. Alle de ting, du har brug for, fra algoritmer til forbedringer, er her.

6. Tensorflow og Pytorch

Jeg taler ikke for meget om disse to. Men hvis du er interesseret i dyb læring, så kig på dem, det vil være din tid værd. (Jeg vil give en anden tutorial om Deep Learning næste gang, hold dig opdateret!)

Python Machine Learning-projekter

Selvfølgelig vil læsning og studier alene ikke bringe dig, hvor du skal hen. Du har brug for faktisk praksis. Som jeg sagde på min blog, er det meningsløst at lære værktøjerne, hvis du ikke springer ind i dataene. Og så introducerer jeg dig til et sted, hvor du nemt kan finde Python Machine Learning-projekter.

Kaggle er en platform, hvor du kan dykke direkte ned i dataene. Du løser projekter og bliver rigtig god til Machine Learning. Noget der kan gøre dig mere interesseret i det: Machine Learning-konkurrencer, det holder, kan give en præmie helt op til $ 100.000. Og du vil måske prøve lykken. Haha.

Men det vigtigste er ikke pengene - det er virkelig et sted, hvor du kan finde Machine Learning med Python-projekter. Der er mange projekter, du kan prøve. Men hvis du er nybegynder, og jeg antager, at du er det, vil du gerne deltage i denne konkurrence.

Her er et eksempel på et projekt, som vi bruger i nedenstående tutorial:

Titanic: Machine Learning from Disaster

Ja, den berygtede Titanic. En tragisk katastrofe i 1912, der tog livet af 1502 mennesker fra 2224 passagerer og besætning. Denne Kaggle-konkurrence (eller jeg kan sige tutorial) giver dig de rigtige data om katastrofen. Og din opgave er at forklare dataene, så du kan forudsige, om en person overlevede eller ej under hændelsen.

Maskinindlæring med Python-vejledning

Før vi går dybt ind i dataene fra Titanic, lad os installere nogle værktøjer, du har brug for.

Selvfølgelig, Python. Du skal installere det først fra det officielle Python-websted. Du skal installere version 3.6+ for at holde dig opdateret med bibliotekerne.

Derefter skal du installere alle bibliotekerne via Python pip. Pip skal installeres automatisk med distributionen af ​​Python, du lige har downloadet.

Installer derefter de ting, du har brug for via pip. Åbn din terminal, kommandolinje eller Powershell, og skriv følgende:

pip install numpypip install pandaspip install matplotlibpip install seabornpip install scikit-learnpip install jupyter

Alt ser godt ud. Men vent, hvad er jupyter? Jupyter står for Julia, Python og R, deraf Jupytr. Men det er en underlig kombination af ord, så de ændrede det til bare Jupyter. Det er en berømt notesbog, hvor du kan skrive Python-kode interaktivt.

Skriv bare jupyter-notesbog i din terminal, så åbner du en browserside som denne:

Skriv koden inde i det grønne rektangel, og du kan skrive og evaluere Python-kode interaktivt.

Nu har du installeret alle værktøjerne. Lad os komme afsted!

Dataefterforskning

Det første trin er at udforske dataene. Du skal downloade dataene fra Titanic-siden i Kaggle. Sæt derefter de udpakkede data i en mappe, hvor du starter din Jupyter-notesbog.

Importér derefter de nødvendige biblioteker:

import numpy as np import pandas as pdimport matplotlib.pyplot as pltimport seaborn as snsimport warningswarnings.filterwarnings('ignore')%matplotlib inline

Indlæs derefter dataene:

train_df=pd.read_csv("train.csv")train_df.head()

Du vil se noget som dette:

Det er vores data. Den har følgende kolonner:

  1. PassengerId, identifikationen af ​​passageren
  2. Overlevede, uanset om han / hun overlevede eller ej
  3. Pclass, tjenestens klasse, måske 1 er økonomi, 2 er forretning og 3 er første klasse
  4. Navn, navnet på passageren
  5. Køn
  6. Alder
  7. Sibsp eller søskende og ægtefæller, antal søskende og ægtefæller om bord
  8. Parch eller forældre og børn, antallet af dem om bord
  9. Billet, billetdetalje
  10. Cabin, their cabin. NaN means unknown
  11. Embarked, the origin of embarkation, S for Southampton, Q for Queenstown, C for Cherbourg

While exploring data, we often find missing data. Let’s see them:

def missingdata(data): total = data.isnull().sum().sort_values(ascending = False) percent = (data.isnull().sum()/data.isnull().count()*100).sort_values(ascending = False) ms=pd.concat([total, percent], axis=1, keys=['Total', 'Percent']) ms= ms[ms["Percent"] > 0] f,ax =plt.subplots(figsize=(8,6)) plt.xticks(rotation='90') fig=sns.barplot(ms.index, ms["Percent"],color="green",alpha=0.8) plt.xlabel('Features', fontsize=15) plt.ylabel('Percent of missing values', fontsize=15) plt.title('Percent missing data by feature', fontsize=15) return ms
missingdata(train_df)

We will see a result like this:

The cabin, age, and embarked data has some missing values. And cabin information is largely missing. We need to do something about them. This is what we call Data Cleaning.

Data Cleaning

This is what we use 90% of the time. We will do Data Cleaning a lot for every single Machine Learning project. When the data is clean, we can easily jump ahead to the next step without worrying about anything.

The most common technique in Data Cleaning is filling missing data. You can fill the data missing with Mode, Mean, or Median. There is no absolute rule on these choices — you can try to choose one after another and see the performance. But, for a rule of thumb, you can only use mode for categorized data, and you can use median or mean for continuous data.

So let’s fill the embarkation data with Mode and the Age data with median.

train_df['Embarked'].fillna(train_df['Embarked'].mode()[0], inplace = True)train_df['Age'].fillna(train_df['Age'].median(), inplace = True)

The next important technique is to just remove the data, especially for largely missing data. Let’s do it for the cabin data.

drop_column = ['Cabin']train_df.drop(drop_column, axis=1, inplace = True)

Now we can check the data we have cleaned.

print('check the nan value in train data')print(train_df.isnull().sum())

Perfect! No missing data found. Means the data has been cleaned.

Feature Engineering

Now we have cleaned the data. The next thing we can do is Feature Engineering.

Feature Engineering is basically a technique for finding Feature or Data from the currently available data. There are several ways to do this technique. More often, it is about common sense.

Let’s take a look at the Embarked data: it is filled with Q, S, or C. The Python library will not be able to process this, since it is only able to process numbers. So you need to do something called One Hot Vectorization, changing the column into three columns. Let’s say Embarked_Q, Embarked_S, and Embarked_C which are filled with 0 or 1 whether the person embarked from that harbor or not.

The other example is SibSp and Parch. Maybe there is nothing interesting in both of those columns, but you might want to know how big the family was of the passenger who boarded in the ship. You might assume that if the family was bigger, then the chance of survival would increase, since they could help each other. On other hand, solo people would’ve had it hard.

So you want to create another column called family size, which consists of sibsp + parch + 1 (the passenger themself).

The last example is called bin columns. It is a technique which creates ranges of values to group several things together, since you assume it is hard to differentiate things with similar value. For example, Age. For a person aged 5 and 6, is there any significant difference? or for person aged 45 and 46, is there any big difference?

That’s why we create bin columns. Maybe for age, we will create 4 bins. Children (0–14 years), Teenager (14–20), Adult (20–40), and Elders (40+)

Let’s code them:

all_data = train_df
for dataset in all_data : dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
import re# Define function to extract titles from passenger namesdef get_title(name): title_search = re.search(' ([A-Za-z]+)\.', name) # If the title exists, extract and return it. if title_search: return title_search.group(1) return ""# Create a new feature Title, containing the titles of passenger namesfor dataset in all_data: dataset['Title'] = dataset['Name'].apply(get_title)# Group all non-common titles into one single grouping "Rare"for dataset in all_data: dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss') dataset['Title'] = dataset['Title'].replace('Ms', 'Miss') dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
for dataset in all_data: dataset['Age_bin'] = pd.cut(dataset['Age'], bins=[0,14,20,40,120], labels=['Children','Teenage','Adult','Elder'])
for dataset in all_data: dataset['Fare_bin'] = pd.cut(dataset['Fare'], bins=[0,7.91,14.45,31,120], labels ['Low_fare','median_fare', 'Average_fare','high_fare']) traindf=train_dffor dataset in traindf: drop_column = ['Age','Fare','Name','Ticket'] dataset.drop(drop_column, axis=1, inplace = True)
drop_column = ['PassengerId']traindf.drop(drop_column, axis=1, inplace = True)traindf = pd.get_dummies(traindf, columns = ["Sex","Title","Age_bin","Embarked","Fare_bin"], prefix=["Sex","Title","Age_type","Em_type","Fare_type"])

Now, you have finished all the features. Let’s take a look into the correlation for each feature:

sns.heatmap(traindf.corr(),annot=True,cmap='RdYlGn',linewidths=0.2) #data.corr()-->correlation matrixfig=plt.gcf()fig.set_size_inches(20,12)plt.show()

Korrelationer med værdien 1 betyder stærkt korreleret positivt, -1 betyder stærkt korreleret negativt . For eksempel vil kønsmand og kønskvinde korrelere negativt, da passagerer skulle identificere sig som det ene eller det andet køn. Bortset fra det kan du se, at intet er relateret til noget meget undtagen dem, der er oprettet via funktionsteknik. Det betyder, at vi er gode at gå.

Hvad vil der ske, hvis noget stærkt korrelerer med noget andet? Vi kan fjerne en af ​​dem, da tilføjelse af ikke-information via en ny kolonne ikke giver systemet nye oplysninger, da begge er nøjagtigt de samme.

Maskinindlæring med Python

Nu er vi kommet til toppen af ​​vejledningen: Machine Learning modellering.

from sklearn.model_selection import train_test_split #for split the datafrom sklearn.metrics import accuracy_score #for accuracy_scorefrom sklearn.model_selection import KFold #for K-fold cross validationfrom sklearn.model_selection import cross_val_score #score evaluationfrom sklearn.model_selection import cross_val_predict #predictionfrom sklearn.metrics import confusion_matrix #for confusion matrixall_features = traindf.drop("Survived",axis=1)Targeted_feature = traindf["Survived"]X_train,X_test,y_train,y_test = train_test_split(all_features,Targeted_feature,test_size=0.3,random_state=42)X_train.shape,X_test.shape,y_train.shape,y_test.shape

Du kan vælge mange algoritmer inkluderet i scikit-learning-biblioteket.

  1. Logistisk regression
  2. Tilfældig skov
  3. SVM
  4. K Nærmeste nabo
  5. Naive Bayes
  6. Decision Trees
  7. AdaBoost
  8. LDA
  9. Gradient Boosting

You might be overwhelmed trying to figure out what is what. Don’t worry, just treat is as a black box: choose one with the best performance. (I will create a whole article on these algorithms later.)

Let’s try it with my favorite one: the Random Forest Algorithm

from sklearn.ensemble import RandomForestClassifiermodel = RandomForestClassifier(criterion='gini', n_estimators=700, min_samples_split=10,min_samples_leaf=1, max_features="auto",oob_score=True, random_state=1,n_jobs=-1)model.fit(X_train,y_train)prediction_rm=model.predict(X_test)print('--------------The Accuracy of the model----------------------------')print('The accuracy of the Random Forest Classifier is', round(accuracy_score(prediction_rm,y_test)*100,2))kfold = KFold(n_splits=10, random_state=22) # k=10, split the data into 10 equal partsresult_rm=cross_val_score(model,all_features,Targeted_feature,cv=10,scoring='accuracy')print('The cross validated score for Random Forest Classifier is:',round(result_rm.mean()*100,2))y_pred = cross_val_predict(model,all_features,Targeted_feature,cv=10)sns.heatmap(confusion_matrix(Targeted_feature,y_pred),annot=True,fmt='3.0f',cmap="summer")plt.title('Confusion_matrix', y=1.05, size=15)

Wow! It gives us 83% accuracy. That’s good enough for our first time.

The cross validated score means a K Fold Validation method. If K = 10, it means you split the data in 10 variations and compute the mean of all scores as the final score.

Fine Tuning

Now you are done with the steps in Machine Learning with Python. But, there is one more step which can bring you better results: fine tuning. Fine tuning means finding the best parameter for Machine Learning Algorithms. If you see the code for random forest above:

model = RandomForestClassifier(criterion='gini', n_estimators=700, min_samples_split=10,min_samples_leaf=1, max_features="auto",oob_score=True, random_state=1,n_jobs=-1)

Der er mange parametre, du skal indstille. Dette er forresten standardindstillingerne. Og du kan ændre de parametre, som du vil. Men det tager selvfølgelig meget tid.

Bare rolig - der er et værktøj kaldet Grid Search , der automatisk finder de optimale parametre. Lyder godt, ikke?

# Random Forest Classifier Parameters tunning model = RandomForestClassifier()n_estim=range(100,1000,100)
## Search grid for optimal parametersparam_grid = {"n_estimators" :n_estim}
model_rf = GridSearchCV(model,param_grid = param_grid, cv=5, scoring="accuracy", n_jobs= 4, verbose = 1)
model_rf.fit(train_X,train_Y)
# Best scoreprint(model_rf.best_score_)
#best estimatormodel_rf.best_estimator_

Nå, du kan prøve det selv. Og sjov med maskinlæring.

Konklusion

Hvordan var det? Det virker ikke meget svært, gør det? Maskinindlæring med Python er let. Alt er lagt ud til dig. Du kan bare gøre det magiske. Og bringe mennesker lykke.

Dette stykke blev oprindeligt udgivet på min blog på thedatamage.com