Erste Schritte mit maschinellem Lernen in ca. 10 Minuten

Mit dem Aufkommen des maschinellen Lernens in der Industrie ist die Notwendigkeit eines Tools, mit dem Sie den Prozess schnell durchlaufen können, von entscheidender Bedeutung geworden. Python, ein aufstrebender Stern in der Technologie des maschinellen Lernens, ist oft die erste Wahl, um Ihnen Erfolg zu bringen. Eine Anleitung zum maschinellen Lernen mit Python ist also wirklich notwendig.

Einführung in das maschinelle Lernen mit Python

Warum also Python? Nach meiner Erfahrung ist Python eine der am einfachsten zu erlernenden Programmiersprachen. Es ist notwendig, den Prozess schnell zu wiederholen, und der Datenwissenschaftler muss keine tiefen Kenntnisse der Sprache haben, da er sehr schnell den Dreh raus bekommen kann.

Wie einfach?

for anything in the_list: print(anything)

So einfach ist das . Die Syntax ist eng mit Englisch (oder der menschlichen Sprache, nicht einer Maschine) verwandt. Und es gibt keine dummen geschweiften Klammern, die den Menschen verwirren. Ich habe eine Kollegin in der Qualitätssicherung, keine Software-Ingenieurin, und sie kann Python-Code innerhalb eines Tages auf Produktionsebene schreiben. (Wirklich!)

Daher haben die Ersteller der Bibliotheken, die wir unten diskutieren, Python für ihre Wahl der Sprache ausgewählt. Und als Datenanalyst und Wissenschaftler können wir nur ihre Meisterwerke verwenden, um die Aufgaben zu erledigen. Dies sind die unglaublichen Bibliotheken, die ein Muss für maschinelles Lernen mit Python sind .

  1. Numpy

Die berühmte Bibliothek für numerische Analysen. Es wird Ihnen dabei helfen, viele Dinge zu tun, von der Berechnung des Medians der Datenverteilung bis zur Verarbeitung mehrdimensionaler Arrays.

2. Pandas

Zur Verarbeitung von CSV-Dateien. Natürlich müssen Sie einige Tabellen verarbeiten und Statistiken anzeigen, und dies ist das richtige Tool, das Sie verwenden möchten.

3. Matplotlib

Nachdem Sie die Daten in Pandas-Datenrahmen gespeichert haben, benötigen Sie möglicherweise einige Visualisierungen, um mehr über die Daten zu erfahren. Bilder sind immer noch besser als Tausende von Wörtern.

4. Seaborn

Dies ist ebenfalls ein weiteres Visualisierungswerkzeug, das sich jedoch mehr auf die statistische Visualisierung konzentriert. Dinge wie Histogramme oder Kreisdiagramme oder Kurven oder vielleicht Korrelationstabellen.

5. Scikit-Learn

Dies ist der letzte Chef des maschinellen Lernens mit Python. Das so genannte maschinelle Lernen mit Python ist dieser Typ. Scikit-Learn. Hier finden Sie alles, was Sie von Algorithmen bis hin zu Verbesserungen benötigen.

6. Tensorflow und Pytorch

Ich rede nicht zu viel über diese beiden. Aber wenn Sie sich für Deep Learning interessieren, schauen Sie sich diese an, es wird Ihre Zeit wert sein. (Ich werde das nächste Mal ein weiteres Tutorial über Deep Learning geben, bleibt dran!)

Python Machine Learning-Projekte

Lesen und Lernen allein bringt Sie natürlich nicht dahin, wo Sie hin müssen. Sie brauchen tatsächliche Übung. Wie ich in meinem Blog sagte, ist das Erlernen der Tools sinnlos, wenn Sie nicht in die Daten springen. Und so stelle ich Ihnen einen Ort vor, an dem Sie Python Machine Learning Projects leicht finden können.

Kaggle ist eine Plattform, auf der Sie direkt in die Daten eintauchen können. Sie lösen Projekte und werden beim maschinellen Lernen richtig gut. Etwas, das Sie vielleicht mehr daran interessiert: Die von ihm veranstalteten Wettbewerbe für maschinelles Lernen können einen Preis von bis zu 100.000 US-Dollar verleihen. Und vielleicht möchten Sie Ihr Glück versuchen. Haha.

Das Wichtigste ist jedoch nicht das Geld - es ist wirklich ein Ort, an dem Sie maschinelles Lernen mit Python-Projekten finden können. Es gibt viele Projekte, die Sie ausprobieren können. Aber wenn Sie ein Neuling sind und ich nehme an, dass Sie es sind, werden Sie an diesem Wettbewerb teilnehmen wollen.

Hier ist ein Beispielprojekt, das wir im folgenden Tutorial verwenden werden:

Titanic: Maschinelles Lernen aus Katastrophen

Ja, die berüchtigte Titanic. Eine tragische Katastrophe im Jahr 1912, bei der 1502 Menschen von 2224 Passagieren und Besatzungsmitgliedern ums Leben kamen. Dieser Kaggle-Wettbewerb (oder ich kann sagen Tutorial) gibt Ihnen die wirklichen Daten über die Katastrophe. Und Ihre Aufgabe ist es, die Daten zu erklären, damit Sie vorhersagen können, ob eine Person während des Vorfalls überlebt hat oder nicht.

Maschinelles Lernen mit Python Tutorial

Bevor wir uns eingehend mit den Daten der Titanic befassen, installieren wir einige Tools, die Sie benötigen.

Natürlich Python. Sie müssen es zuerst von der Python offfical-Website installieren. Sie müssen Version 3.6+ installieren, um mit den Bibliotheken auf dem neuesten Stand zu bleiben.

Danach müssen Sie alle Bibliotheken über Python Pip installieren. Pip sollte automatisch mit der gerade heruntergeladenen Python-Distribution installiert werden.

Installieren Sie dann die benötigten Dinge über pip. Öffnen Sie Ihr Terminal, Ihre Befehlszeile oder Powershell und schreiben Sie Folgendes:

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

Nun, alles sieht gut aus. Aber warte, was ist Jupiter? Jupyter steht für Julia, Python und R, daher Jupytr. Aber es ist eine seltsame Kombination von Wörtern, also haben sie es in nur Jupyter geändert. Es ist ein berühmtes Notizbuch, in das Sie Python-Code interaktiv schreiben können.

Geben Sie einfach jupyter notebook in Ihr Terminal ein und Sie öffnen eine Browserseite wie folgt:

Schreiben Sie den Code in das grüne Rechteck und Sie können Python-Code interaktiv schreiben und auswerten.

Jetzt haben Sie alle Tools installiert. Lasst uns anfangen!

Datenexploration

Der erste Schritt besteht darin, die Daten zu untersuchen. Sie müssen die Daten von der Titanic-Seite in Kaggle herunterladen. Legen Sie dann die extrahierten Daten in einen Ordner, in dem Sie Ihr Jupyter-Notizbuch starten.

Importieren Sie dann die erforderlichen Bibliotheken:

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

Laden Sie dann die Daten:

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

Sie werden so etwas sehen:

Das sind unsere Daten. Es hat die folgenden Spalten:

  1. PassengerId, die Kennung des Passagiers
  2. Überlebt, ob er / sie überlebt hat oder nicht
  3. Klasse, die Klasse des Dienstes, vielleicht 1 ist Wirtschaft, 2 ist Geschäft und 3 ist erstklassig
  4. Name, der Name des Passagiers
  5. Sex
  6. Alter
  7. Geschwister oder Geschwister und Ehepartner, Anzahl der Geschwister und Ehepartner an Bord
  8. Parch oder Eltern und Kinder, Anzahl von ihnen an Bord
  9. Ticket, Ticketdetail
  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()

Korrelationen mit dem Wert 1 bedeuten stark positiv korreliert, -1 bedeutet negativ negativ korreliert . Zum Beispiel korrelieren Geschlecht männlich und Geschlecht weiblich negativ, da Passagiere sich als das eine oder andere Geschlecht identifizieren mussten. Abgesehen davon können Sie sehen, dass nichts mit etwas zu tun hat, außer denjenigen, die über Feature Engineering erstellt wurden. Das heißt, wir können loslegen.

Was passiert, wenn etwas stark mit etwas anderem korreliert? Wir können eine davon entfernen, da das Hinzufügen weiterer Informationen über eine neue Spalte dem System keine neuen Informationen liefert, da beide genau gleich sind.

Maschinelles Lernen mit Python

Jetzt sind wir am Scheitelpunkt des Tutorials angelangt: Modellierung des maschinellen Lernens.

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

Sie können viele Algorithmen auswählen, die in der Scikit-Learn-Bibliothek enthalten sind.

  1. Logistische Regression
  2. Zufälliger Wald
  3. SVM
  4. K Nächster Nachbar
  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)

There are many parameters you need to set. These are the defaults, by the way. And you can change the parameters however you want. But of course, it will takes a lot of time.

Don’t worry — there is a tool called Grid Search, which finds the optimal parameters automatically. Sounds great, right?

# 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_

Well, you can try it out for yourself. And have fun with Machine Learning.

Conclusion

How was it? It doesn’t seem very difficult does it? Machine Learning with Python is easy. Everything has been laid out for you. You can just do the magic. And bring happiness to people.

This piece was originally released on my blog at thedatamage.com