Classificatie is een ML taak waarbij een label voorspeld moet worden uit een mogelijke lijst van antwoorden.
Wanneer er slechts 2 mogelijke labels zijn dan noemt men dit binaire classificatie
Voorbeeld : je spam filter : een mail is spam of ham - je lost in dit geval een ja/nee vraag op
Wanneer er meerdere labels mogelijk zijn dan noemt men dit multiclass classificatie
Voorbeeld : herkennen van handgeschreven cijfers - het antwoord kan zijn : 0,1,...,9
Regressie is een ML taak waarbij een cijfer (continue waarde) voorspeld moet worden
Voorbeeld : iemand zijn leeftijd voorspellen, iemand zijn jaarlijks inkomen voorspellen, ...
Wanneer je leert aan de hand van een supervisor dan heb je trainingsdata ter beschikking en leer je een model op basis van deze data. Een model zal je instaat stellen om een beslissing te nemen voor elk geval (instantie) waarvan je een voorspelling wil doen. Een model mag echter niet alleen goed presteren op de trainingsdata, het model moet algemeen genoeg zijn om ook ongeziene instanties correct te gaan voorspellen. Men zegt dat het model moet kunnen generalizeren van de trainingsdata naar de test data. De test data is een deel van de data die je ter beschikking hebt, maar niet meeneemt tijdens het trainen van je model. Wanneer je model extreem goed presteert op je trainingsdata, maar niet zo goed presteert op je test data spreekt men van overfitting. Wanneer je model zelfs niet goed presteert op je trainingsdata dan spreek je van underfitting. Zoek een punt waarbij je data goed presteert op zowel trainings- als test-data.
Voorspel wanneer iemand een boot koopt :
Age | Nr cars | owns house | nr children | status | owns dog | bought a boat |
---|---|---|---|---|---|---|
66 | 1 | yes | 2 | widowed | no | yes |
52 | 2 | yes | 3 | married | no | yes |
22 | 0 | no | 0 | married | yes | no |
25 | 1 | no | 1 | single | no | no |
44 | 0 | no | 2 | divorced | yes | no |
39 | 1 | yes | 2 | married | yes | no |
26 | 1 | no | 2 | single | no | no |
40 | 3 | yes | 1 | married | yes | no |
53 | 2 | yes | 2 | divorced | no | yes |
64 | 2 | yes | 3 | divorced | no | no |
58 | 2 | yes | 2 | married | yes | yes |
33 | 1 | no | 1 | single | no | no |
mogelijke hypothesen :
ouder dan 45, en minder dan 3 kinderen of niet gescheiden -> dan zal je een boot kopen (100% accuracy -> overfitting )
exact 66, 52, 53 of 58 jaar oud zijn -> dan zal je een boot kopen (100% accuracy -> overfitting )
ouder dan 50 -> dan zal je een boot kopen (simpelere regel die min of meer ok presteert)
bezitter van een huis dan -> zal je een boot kopen (underfitting ! )
Waarschijnlijk het simpelste leermodel : er wordt niet echt een model
opgebouwd, het enige wat er gedaan wordt is de dataset van
trainingspunten bijhouden. Wanneer een voorspelling moet gebeuren voor
een nieuw datapunt wordt in de dataset de dichtste buur gezocht (wanneer
De voorspelling van het nieuwe datapunt zal afhangen van de waarden van zijn buren.
Beslissingsgrenzen bepaald door het aantal buren :
<matplotlib.legend.Legend at 0x7f9df3d1e908>
Hoe aantal buren kiezen? Hoe meer buren, hoe simpeler het model.
De classificatie van Iris species : voorbeeld uit :
An Introduction to Machine Learning with Python, MΓΌller & Guido
from sklearn.datasets import load_iris
iris_dataset = load_iris()
print("Keys of iris_dataset:\n", iris_dataset.keys())
Keys of iris_dataset: dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names'])
print(iris_dataset['DESCR'][:193] + "\n...")
Iris Plants Database ==================== Notes ----- Data Set Characteristics: :Number of Instances: 150 (50 in each of three classes) :Number of Attributes: 4 numeric, predictive att ...
print("Feature names:\n", iris_dataset['feature_names'])
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
print("Type of data:", type(iris_dataset['data']))
Type of data: <class 'numpy.ndarray'>
print("Shape of data:", iris_dataset['data'].shape)
Shape of data: (150, 4)
print("First five rows of data:\n", iris_dataset['data'][:5])
First five rows of data: [[5.1 3.5 1.4 0.2] [4.9 3. 1.4 0.2] [4.7 3.2 1.3 0.2] [4.6 3.1 1.5 0.2] [5. 3.6 1.4 0.2]]
print("Type of target:", type(iris_dataset['target']))
Type of target: <class 'numpy.ndarray'>
print("Shape of target:", iris_dataset['target'].shape)
Shape of target: (150,)
print("Target:\n", iris_dataset['target'])
Target: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
iris_dataset['data'], iris_dataset['target'], random_state=0)
#de dataset wordt eerst via een random generator door elkaar geschud om een
#representatieve test set te krijgen
print("X_train shape:", X_train.shape)
print("y_train shape:", y_train.shape)
X_train shape: (112, 4) y_train shape: (112,)
print("X_test shape:", X_test.shape)
print("y_test shape:", y_test.shape)
X_test shape: (38, 4) y_test shape: (38,)
Het is steeds een goed idee om je data te visualiseren, bvb. via een scatterplot, om eventuele trends in de data te visualiseren. Het geeft je ook een idee van welk leermodel je zou kunnen gebruiken.
# create dataframe from data in X_train
# label the columns using the strings in iris_dataset.feature_names
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
%matplotlib inline
iris_dataframe = pd.DataFrame(X_train, columns=iris_dataset.feature_names)
# create a scatter matrix from the dataframe, color by y_train
pd.plotting.scatter_matrix(iris_dataframe, c=y_train, figsize=(7, 7),
marker='o', hist_kwds={'bins': 20})
plt.show()
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=1)
#knn is een object waarop de verdere fit/predict/score operaties zullen gebeuren
knn.fit(X_train, y_train)
#het model wordt gebouwd
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=1, p=2, weights='uniform')
minkowski afstandsmaat : veralgemening van de Manhattan (p = 1) en Euclidische afstand (p = 2)
http://dataaspirant.com/2015/04/11/five-most-popular-similarity-measures-implementation-in-python/
X_new = np.array([[5, 2.9, 1, 0.2]])
print("X_new.shape:", X_new.shape)
X_new.shape: (1, 4)
#nieuwe voorspellingen worden gemaakt a.d.h.v. het model
prediction = knn.predict(X_new)
print("Prediction:", prediction)
print("Predicted target name:",
iris_dataset['target_names'][prediction])
Prediction: [0] Predicted target name: ['setosa']
y_pred = knn.predict(X_test)
print("Test set predictions:\n", y_pred)
Test set predictions: [2 1 0 2 0 2 0 1 1 1 2 1 1 1 1 0 1 1 0 0 2 1 0 0 2 0 0 1 1 0 2 1 0 2 2 1 0 2]
print("Test set score: {:.2f}".format(np.mean(y_pred == y_test)))
Test set score: 0.97
print("Test set score: {:.2f}".format(knn.score(X_test, y_test)))
Test set score: 0.97
2 belangrijke parameters :
Sterktes:
Zwaktes:
k noemt men een hyperparameter : deze moet je vooraf instellen (tijdens de fase model building) en kan het resultaat van het voorspellen serieus beΓ―nvloeden.
er bestaat geen algemene optimale keuze voor k. Deze is datset afhankelijk.
wanneer k klein is (weinig buren worden gebruikt) dan heeft ruis in de data meer effect op het resultaat dan wanneer k groot is
wanneer k groot is (veel buren mee laten beslissen) dan wordt het effect van ruis wel geminimaliseerd, maar dan vergt het voorspellen veel rekenkracht.
een kleine k heeft weinig last van bias maar geeft een hoge variantie, terwijl een grote k minder variantie geeft maar gevoeliger is aan bias
Meestal wordt een oneven getal gebruikt als de waarde voor k als het aantal te voorspellen klassen even is - (dit om gelijkstand te vermijden bij voting)
Vaak gekozen voor :
Andere methoden gebaseerd op parameter tuning : trial-and-error in combinatie met berekenen van errors, Elbow-methode
rmse_val = [] #to store rmse values for different k
for K in range(20):
K = K+1
model = neighbors.KNeighborsRegressor(n_neighbors = K)
model.fit(x_train, y_train) #fit the model
pred=model.predict(x_test) #make prediction on test set
error = sqrt(mean_squared_error(y_test,pred)) #calculate rmse
rmse_val.append(error) #store rmse values
Bias is een fout / error in het leermodel die onstaat doordat verkeerde assumpties gebruikt zijn om het model op te stellen. Een model met hoge bias zal (te) weinig rekening houden met de trainingsdata en zal het model oversimplificeren.
Variantie is eveneens een fout, maar deze is te wijten aan te gevoelig zijn voor de fluctuaties in de trainingsset, waardoor ruis mee gemodelleerd kan worden en het model dus de trainingsdata te goed modelleert (overfitting!)
de trade-off : beide effecten moeten vermeden worden maar vaak is het zo dat lage bias, veel variantie inhoudt en vice versa.
Wanneer heel veel features aanwezig zijn in de data, dan is het moelijker om datapunten te vinden die dichtbij zijn (ze zijn misschien dichtbij in een bepaalde feature maar als er heel veel zijn heeft dit weinig effect op de afstand)
Dus in dit geval zullen er heel veel extra datavoorbeelden nodig zijn om goede dichte buren te vinden !
M.a.w. je helpt het leerprobleem niet vooruit door je data steeds rijker te beschrijven als je geen extra datavoorbeelden hebt. Bovendien bestaat ook het gevaar voor overfitting.
Als je toch extra features toevoegt dan zal je dus ook meer trainingsdata moeten toevoegen maar deze zal exponentieel moeten groeien om hetzelfde aandeel van data te voorzien en overfitting te vermijden.
Oplossing : investeren in feature selection methoden, zoals Principal component en singular value decomposition
zie ook artikel : http://www.visiondummy.com/2014/04/curse-dimensionality-affect-classification/
KNN Classification using Scikit-learn Learn K-Nearest Neighbor(KNN) Classification and build KNN classifier using Python Scikit-learn package. online @ https://www.datacamp.com/community/tutorials/k-nearest-neighbor-classification-scikit-learn
A Practical Introduction to K-Nearest Neighbors Algorithm for Regression (with Python code) online @ https://www.analyticsvidhya.com/blog/2018/08/k-nearest-neighbor-introduction-regression-python/