Hausaufgabe 1 Machine Learning
Modul SMART HOME SoSe 2021/2022
von
Francisco José Araque Pineda
Matrikel-Nummer: 0473287
Studiengang: Wirtschaftingenieurwesen
Prof. Dr. Rita Streblow
Berlin, den August 2, 2022
Inhaltsübersicht
1. Einleitung...............................................................................................................3
2. Nächster Nachbar und K-nächste Nachbarn...........................................................4
3. Support Vector Machine.........................................................................................6
4. Schlussfolgerungen der Aufgabe..........................................................................10
1. Einleitung
In dieser Aufgabe wollen wir verschiedene Algorithmen des maschinellen Lernens
einsetzen, um den Zustand eines Raumes als „behaglich“ oder unbehaglich zu
klassifizieren.
Für die Entwicklung der Algorithmen wurde beschlossen, das Tool Google Colab zu
verwenden. Google Colab ist ein kostenloses Online-Tool, das die Entwicklung und
Ausführung von Python-Codes ermöglicht, ohne dass der Computer über bestimmte
Eigenschaften verfügen muss. Der Hauptgrund für die Verwendung dieses Tools ist die
Flüssigkeit und die Benutzerfreundlichkeit, die es bietet.
Der Hausaufgabendatensatz besteht aus einer .csv-Datei mit einer Tabelle mit 34 Zeilen
und 9 Spalten. Vor der Anwendung eines Algorithmus ist es notwendig, die Daten zu
verarbeiten und nur die für diese Aufgabe wesentlichen Informationen zu speichern.
Daher werden die Spalten „Temp. In ºC“, „rel. Feuchte in %“ und „Bewertung“
beibehalten und der Rest gestrichen. Der Name der Spalten wird dann in „x1“, „x2“ und
„y“ geändert.
Schließlich wird der Wert der Spalte „y“ durch eine „1“ ersetzt, wenn er „behaglich“
war, oder durch eine „0“, wenn er „unbehaglich“ war.
Nach der Verarbeitung des ursprünglichen Datensatzes werden die folgenden
Algorithmen angewandt: Nächster Nachbarn, K-nächste Nachbarn und Support Vector
Machine.
2. Nächster Nachbar und K-nächste Nachbarn
Der erste Schritt besteht darin, die Bibliotheken zu laden, die für die Implementierung
dieser beiden Algorithmen verwendet werden sollen.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
import matplotlib.patches as mpatches
import seaborn as sb
%matplotlib inline
plt.rcParams['figure.figsize'] = (16, 9)
plt.style.use('ggplot')
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
Der Datensatz wird auch geladen.
datosread = '/content/Datensatz_Hausaufgabe_scikit-learn.csv'
datos = pd.read_csv(datosread, on_bad_lines='skip', sep=';')
Die Daten werden in Training und Test unterteilt.
X = datos[['x1','x2']].values
y = datos['y'].values
X_train, X_test, y_train, y_test = train_test_split(X, y,
random_state=0)
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
Als nächstes verwenden wir einen Befehl, um zu sehen, für welche Werte von „k“ die
höchste Genauigkeit erzielt wird.
k_range = range(1, 20)
scores = []
for k in k_range:
knn = KNeighborsClassifier(n_neighbors = k)
knn.fit(X_train, y_train)
scores.append(knn.score(X_test, y_test))
plt.figure()
plt.xlabel('k')
plt.ylabel('accuracy')
plt.scatter(k_range, scores)
plt.xticks([0,5,10,15,20])
([<matplotlib.axis.XTick at 0x7f5ff2be4550>, <matplotlib.axis.XTick
at 0x7f5ff2ac9950>, <matplotlib.axis.XTick at 0x7f5ff2ac93d0>,
<matplotlib.axis.XTick at 0x7f5ff2a468d0>, <matplotlib.axis.XTick
at 0x7f5ff2a46bd0>], <a list of 5 Text major ticklabel objects>)
Wie man sieht, werden die höchsten Genauigkeitswerte für „k” gleich 1 und „k“ gleich
2 erzielt. Daher sind die Ergebnisse für den Nächster Nachbarn Algorithmus (k gleich 1)
und für den K-nächste Nachbarn Algorithmus (der das beste Ergebnis für k gleich 2
erzielt) gleich. Daher werden diese beiden Algorithmen in denselben Abschnitt
aufgenommen.
Der Algorithmus ist mit einem Wert von k gleich 2 aufgebaut.
n_neighbors = 2
knn = KNeighborsClassifier(n_neighbors)
knn.fit(X_train, y_train)
print('Accuracy of K-NN classifier on training set: {:.2f}'
.format(knn.score(X_train, y_train)))
print('Accuracy of K-NN classifier on test set: {:.2f}'
.format(knn.score(X_test, y_test)))
Accuracy of K-NN classifier on training set: 0.96
Accuracy of K-NN classifier on test set: 1.00
Man sieht, dass die Genauigkeit des Algorithmus sehr hoch ist.
Schließlich wird das Modell angewandt, um zu sehen, wie sich ein Benutzer in einem
Raum mit einer Temperatur von 23,3 °C und einer Luftfeuchtigkeit von 46 % fühlen
würde.
print(knn.predict([[23.3, 46]]))
[0]
Das Ergebnis ist 0, so die Bewertung des Raums ist unbehaglich.
3. Support Vector Machine
Die erforderlichen Bibliotheken werden geladen, die Daten werden geladen und
ausgedruckt.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
import seaborn as sns
from mlxtend.plotting import plot_decision_regions
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
plt.rcParams['image.cmap'] = "bwr"
#plt.rcParams['figure.dpi'] = "100"
plt.rcParams['savefig.bbox'] = "tight"
style.use('ggplot') or plt.style.use('ggplot')
import warnings
warnings.filterwarnings('ignore')
datosread = '/Datensatz_Hausaufgabe_scikit-learn.csv'
datos = pd.read_csv(datosread, on_bad_lines='skip', sep=';')
datos.head(20)
print(datos)
x1 x2 y
0 20.0 40 1
1 24.0 30 0
2 20.5 75 0
3 24.0 42 1
4 22.0 60 1
5 18.0 41 0
6 20.4 52 1
7 26.0 52 0
8 22.0 75 0
9 20.1 32 0
10 18.0 62 0
11 21.0 75 0
12 24.0 30 0
13 25.0 27 0
14 24.2 39 1
15 23.2 58 1
16 19.9 63 1
17 25.0 40 1
18 20.0 20 0
19 18.0 51 0
20 25.0 25 0
21 21.3 52 1
22 22.1 43 1
23 18.3 39 0
24 26.2 49 0
25 22.0 40 1
26 20.3 54 1
27 23.0 52 1
28 24.1 51 1
29 26.1 53 0
30 24.1 72 0
Als nächster Schritt wird ein Diagramm mit den Daten erstellt, um sie besser zu
verstehen.
fig, ax = plt.subplots(figsize=(6,4))
ax.scatter(datos.x1, datos.x2, c=datos.y);
ax.set_title("Zusammenhang");
Die Daten werden in Train (80%) und Test (20%) unterteilt.
X = datos.drop(columns = 'y')
y = datos['y']
X_train, X_test, y_train, y_test = train_test_split(
X,
y.values.reshape(-1,1),
train_size = 0.8,
random_state = 1234,
shuffle = True
)
Das Modell wird erstellt.
modelo = SVC(C = 100, kernel = 'linear', random_state=123)
modelo.fit(X_train, y_train)
SVC(C=100, kernel='linear', random_state=123)
Die Grenzen der Klassifizierung werden grafisch dargestellt.
x = np.linspace(np.min(X_train.x1), np.max(X_train.x1), 50)
y = np.linspace(np.min(X_train.x2), np.max(X_train.x2), 50)
Y, X = np.meshgrid(y, x)
grid = np.vstack([X.ravel(), Y.ravel()]).T
pred_grid = modelo.predict(grid)
fig, ax = plt.subplots(figsize=(6,4))
ax.scatter(grid[:,0], grid[:,1], c=pred_grid, alpha = 0.2)
ax.scatter(X_train.x1, X_train.x2, c=y_train, alpha = 1)
ax.scatter(
modelo.support_vectors_[:, 0],
modelo.support_vectors_[:, 1],
s=200, linewidth=1,
facecolors='none', edgecolors='black'
)
ax.contour(
X,
Y,
modelo.decision_function(grid).reshape(X.shape),
colors = 'k',
levels = [-1, 0, 1],
alpha = 0.5,
linestyles = ['--', '-', '--']
)
ax.set_title("Resultados clasificación SVM lineal");
Die Testwerte werden vorhergesagt und die Genauigkeit des Modells wird berechnet.
predicciones = modelo.predict(X_test)
predicciones
array([1, 1, 1, 0, 1, 1, 1])
accuracy = accuracy_score(
y_true = y_test,
y_pred = predicciones,
normalize = True
)
print("")
print(f"El accuracy de test es: {100*accuracy}%")
El accuracy de test es: 42.857142857142854%
Wie man sieht, liegt die Genauigkeit des Modells bei 42.86 %.
Schließlich wird das Modell angewandt, um zu sehen, wie sich ein Benutzer in einem
Raum mit einer Temperatur von 23,3 °C und einer Luftfeuchtigkeit von 46 % fühlen
würde.
predicciones2 = modelo.predict([[23.3, 46]])
predicciones2
array([1])
Das Ergebnis ist 1, so die Bewertung des Raums ist behaglich.
4. Schlussfolgerungen der Aufgabe
Der erste und wichtigste Schritt bei der Durchführung dieser Aufgabe bestand darin,
den Datensatz zu verstehen. Danach muss man verstehen, welche Informationen
notwendig und welche entbehrlich sind, um die Modelle zu erstellen und zu
entscheiden, wie sich ein Benutzer in einem Raum mit einer Temperatur von 23,3ºC
und einer Luftfeuchtigkeit von 46% fühlen würde.
Ein weiterer wichtiger Schritt bestand darin, mit Hilfe des Befehls zu berechnen, für
welche Werte von k die höchste Genauigkeit erzielt wurde, da dies eine Menge Arbeit
ersparte.
Schließlich, wenn man vergleicht die Genauigkeit der beiden Modelle, so zeigt sich,
dass der K-nächste-Nachbarn-Algorithmus eine höhere Genauigkeit (100%) erzielt als
der Support-Vector-Machine-Algorithmus (42.86%).
Daher kann man sagen, dass das Endergebnis ist, dass ein Benutzer einen Raum mit
einer Temperatur von 23,3°C und einer Luftfeuchtigkeit von 46% unbehaglich bewerten
würde.
