A gépi tanulás kezdete körülbelül 10 perc alatt

A gépi tanulás növekedésével az iparágakban elengedhetetlenné vált egy olyan eszköz iránti igény, amely elősegíti a folyamat gyors áthidalását. A Python, a gépi tanulás technológiájának emelkedő csillaga gyakran az első választás a siker eléréséhez. Tehát nagyon fontos egy útmutató a gépi tanuláshoz a Pythonnal.

Bevezetés a gépi tanulásba a Python segítségével

Szóval, miért Python? Tapasztalataim szerint a Python az egyik legkönnyebben megtanulható programozási nyelv. Szükség van a folyamat gyors iterálására, és az adatkutatónak nem kell mély ismeretekkel rendelkeznie a nyelv iránt, mivel valóban gyorsan belelendülhetnek.

Mennyire könnyű?

for anything in the_list: print(anything)

Olyan könnyű . A szintaxis szorosan kapcsolódik az angolhoz (vagy az emberi nyelvhez, nem egy géphez). És nincsenek buta, göndör zárójelek, amelyek összezavarják az embereket. Van egy kollégám, aki a Minőségbiztosítás területén dolgozik, nem egy szoftvermérnök, és egy nap alatt írhat Python-kódot gyártási szinten. (Igazából!)

Tehát az alábbiakban tárgyalt könyvtárak készítői a Python-t választották nyelvük megválasztásához. Adatelemzőként és tudósként pedig csak remekműveiket használhatjuk a feladatok elvégzésében. Ezek a hihetetlen könyvtárak, amelyek elengedhetetlenek a gépi tanulás Python használatával .

  1. Dögös

A híres numerikus elemző könyvtár. Számos dolgot segít, az adatelosztás mediánjának kiszámításától a többdimenziós tömbök feldolgozásáig.

2. Pandák

CSV fájlok feldolgozásához. Természetesen meg kell dolgoznia néhány táblázatot, és meg kell néznie a statisztikákat, és ez a megfelelő eszköz, amelyet használni szeretne.

3. Matplotlib

Miután az adatokat a Pandas adatkeretekben tárolta, szükség lehet néhány vizualizációra, hogy jobban megértse az adatokat. A képek még mindig jobbak, mint ezer szó.

4. Seaborn

Ez szintén egy másik vizualizációs eszköz, de inkább a statisztikai vizualizációra koncentrál. Ilyenek például a hisztogramok vagy a kördiagramok, vagy a görbék, esetleg a korrelációs táblázatok.

5. Scikit-Learn

Ez a gépi tanulás Python-nal főnöke. Az úgynevezett gépi tanulás a Pythonnal ez a srác. Scikit-Learn. Az algoritmusoktól a fejlesztésekig minden szükséges itt van.

6. Tensorflow és Pytorch

Nem beszélek túl sokat erről a kettőről. De ha érdekel a mély tanulás, vessen egy pillantást rájuk, megéri az idejét. (Legközelebb újabb oktatót adok a Deep Learningről, maradj velünk!)

Python gépi tanulási projektek

Természetesen önmagában az olvasás és a tanulás nem juttatja el oda, ahová kell. Szüksége van tényleges gyakorlásra. Ahogy a blogomon is mondtam, az eszközök megtanulása értelmetlen, ha nem ugrik be az adatokba. Így bemutatok egy helyet, ahol könnyen megtalálhatja a Python Machine Learning Projekteket.

A Kaggle egy olyan platform, ahol közvetlenül az adatokba merülhet. Megoldja a projekteket, és nagyon jó lesz a gépi tanulásban. Valami, ami jobban érdekelheti: a Gépi Tanulás versenyei akár 100 000 dolláros nyereményt is felajánlhatnak. És érdemes megpróbálni a szerencsét. Haha.

De a legfontosabb nem a pénz - ez valóban egy olyan hely, ahol megtalálhatja a Gépi tanulást a Python projektekkel. Nagyon sok projekt kipróbálható. De ha újonc vagy, és feltételezem, hogy az vagy, akkor csatlakozni akarsz ehhez a versenyhez.

Íme egy példa projekt, amelyet az alábbi oktatóanyagban használunk:

Titanic: Gépi tanulás katasztrófából

Igen, a hírhedt Titanic. Tragikus katasztrófa 1912-ben, amely 2224 utas életét vesztette 2224 utas és legénység részéről. Ez a Kaggle verseny (vagy mondhatom oktatóanyag) megadja a valós adatokat a katasztrófáról. Az Ön feladata az adatok magyarázata, hogy megjósolhassa, hogy egy személy életben maradt-e vagy sem.

Gépi tanulás Python bemutatóval

Mielőtt elmélyülnénk a Titanic adataiban, telepítsünk néhány szükséges eszközt.

Természetesen Python. Először a Python offfical webhelyről kell telepítenie. Telepítenie kell a 3.6+ verziót, hogy naprakész legyen a könyvtárakkal.

Ezt követően az összes könyvtárat Python pip segítségével kell telepítenie. A Pip programot automatikusan telepíteni kell az imént letöltött Python terjesztésével együtt.

Ezután telepítse a szükséges dolgokat a pip segítségével. Nyissa meg a terminált, a parancssort vagy a Powershellt, és írja a következőket:

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

Nos, minden jól néz ki. De várj, mi a jupyter? A Jupyter Juliát, Pythonot és R-t jelenti, tehát Jupytr. De ez egy furcsa szóösszetétel, ezért csak Jupyterre változtatták. Ez egy híres notebook, ahova interaktívan írhat Python kódot.

Csak írja be a jupyter notebookot a termináljába, és megnyílik egy ilyen böngészőoldal:

Írja be a kódot a zöld téglalap belsejébe, és interaktív módon írhatja és értékelheti a Python kódot.

Most telepítette az összes eszközt. Menjünk!

Adatok feltárása

Az első lépés az adatok feltárása. Töltse le az adatokat a Titanic oldalról a Kaggle-ben. Ezután helyezze a kinyert adatokat egy mappába, ahol elindítja a Jupyter notebookot.

Ezután importálja a szükséges könyvtárakat:

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

Ezután töltse be az adatokat:

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

Valami ilyesmit fog látni:

Ez az adatunk. A következő oszlopok vannak:

  1. PassengerId, az utas azonosítója
  2. Túlélte, túlélte-e vagy sem
  3. Pclass, a szolgáltatás osztálya, talán 1 gazdaságos, 2 üzleti és 3 első osztályú
  4. Név, az utas neve
  5. Szex
  6. Kor
  7. Sibsp, vagy testvérek és házastársak, a fedélzeten lévő testvérek és házastársak száma
  8. Parch, vagy szülők és gyermekek, számuk a fedélzeten
  9. Jegy, jegy részlete
  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()

Az 1 értékű korrelációk erősen korrelálnak pozitívan, a -1 pedig erősen korrelálnak negatívan . Például a nemi férfi és a női nem negatív összefüggést mutat, mivel az utasoknak egyik vagy másik nemként kellett azonosulniuk. Ezen kívül láthatja, hogy semmi nem kapcsolódik semmihez, kivéve azokat, amelyeket a funkciótervezéssel hoztak létre. Ez azt jelenti, hogy jók vagyunk.

Mi fog történni, ha valami szorosan összefügg valamivel? Az egyiket kiküszöbölhetjük, mivel újabb információk hozzáadása egy új oszlopon keresztül nem ad új információt a rendszernek, mivel mindkettő pontosan ugyanaz.

Gépi tanulás Python-nal

Most elérkeztünk a bemutató csúcsához: Machine Learning modellezés.

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

A scikit-learn könyvtárban számos algoritmust választhat.

  1. Logisztikus regresszió
  2. Véletlen Erdő
  3. SVM
  4. K Legközelebbi szomszéd
  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