Deine KI selbst programmieren: Wie du Künstliche Intelligenz zur Vorhersage von Immobiliendaten verwendest

Bist du Neuling auf dem Gebiet der Künstlichen Intelligenz und im Bereich des Machine Learnings? Willst du deine eigene KI selbst programmieren und mittels Künstlichen Neuronalen Netzen akkurate Vorhersagen treffen? 

KI selbst programmieren und Vorhersagen treffen

Super, dann bist du in diesem Tutorial auf meinem Blog genau richtig!

In diesem Blogbeitrag zeige ich euch, wie ihr in 5 Schritten eure KI selbst programmieren und anschließend mit eurer trainierten Künstlichen Intelligenz Vorhersagen zu Immobiliendaten treffen könnt.

Ich erkläre euch, wie ihr euer KI-Modell erstellt und mit einer Vielzahl von Immobiliendaten (Quadratmeter, Anzahl an Badezimmer, Garage …)  in der Programmiersprache Python mit Keras trainiert. Anschließend übergeben wir unserem Neuronalen Netz unbekannte Daten und lassen die KI abschätzen, ob der Preis der Immobilie über dem Mittelwert der Immobilienpreise liegen wird!!! 

Die dafür benötigten 5 Schritte sind die Folgenden:

KI selbst programmieren: Die 5 Schritte in der Übersicht

  1. Voraussetzungen und benötigte Module/Bibliotheken 
  2. Datenimport der Rohdaten aus csv-Datei
  3. Preprocessing (Datenvorbereitung und Skalierung)
  4. Erstellung des Künstlichen Neuronalen Netzes und Training des KI-Modells
  5. Testen der Genauigkeit der KI-Vorhersagen

Nachdem ihr jetzt einen Überblick habt, was euch erwartet, starten wir direkt in den Code und beginnen mit Schritt 1:

Schritt 1: Voraussetzungen und benötigte Module/Bibliotheken

Installation von Python und Editor (bzw. Jupyer-Notebook)

Falls ihr Python (die Programmiersprache, nicht die Schlange :)) noch nicht auf eurem Rechner installiert habt, könnt ihr Python auf dieser Webseite https://www.python.org/ downloaden und installieren. Auf der Homepage findet ihr alle Informationen für euer Betriebssystem.

Ihr könnt prüfen, ob die Installation erfolgreich war, indem ihr python in die Kommandozeile eingebt. Bei Windows müsst ihr dafür einfach nur in der Windowssuche „cmd“ eingeben und es öffnet sich das Terminal. Bei Mac OS x reicht die Suche nach Terminal. Sobald ihr in der Kommandozeile python eingegeben habt, sollte euch eure installierte Python-Version (z. B. 3.7.) angezeigt werden.

Für das heutige Tutorial nutze ich Jupyter Notebook aus dem Anaconda-Navigator. Den Download der Anaconda-Distribution findet ihr hier. Ihr dürft aber auch selbstverständlich jeden anderen Python-Editor (z. B. Spyder, VS Code, Eclipse,..) verwenden.

Benötigte Bibliotheken und Module

1. Keras

Wir benötigen die beiden gängigen ML-Bibliotheken Keras und Tensorflow. Zunächst müsst ihr diese installieren: Dies könnt ihr entweder in der Shell via einem pip-Install-Aufruf (z. B. pip install keras) oder in eurem Anaconda Navigator unter Environments (sucht bei den Packages in Anaconda nach keras, keras applications, tensorflow) tun.

Warum brauchen wir KERAS und TENSORFLOW? Keras ist eine leicht zu bedienende Bibliothek, welche im Machine Learning zur Erstellung und zum Trainieren von künstlichen Neuronalen Netzwerken verwendet wird. Bei Tensorflow wurde von Google entwickelt und ist ebenfalls im Machine Learning (speziell im Deep Learning) eine Standardbibliothek.

2. Numpy

Falls ihr ebenfalls mit dem Jupyter Notebook arbeitet, empfehle ich die Installation via Anaconda (klickt dazu einfach im Anaconda Navigator auf Environments, wählt eure Python-Version aus und installiert das Paket numpy) bzw. über den conda install numpy Befehl.

Numpy ist ein Erweiterungsmodul für Python und erleichtert das Rechnen mit großen Arrays und Matrizen enorm.

3. Pandas

Pandas ist eine Softwarebibiliothek stellt nützliche Funktionen und Datenstrukturen zur Manipulation von Daten und zur Analyse von Tabellen zur Verfügung.

Wie ihr Pandas installiert, ist hier ausführlich erklärt: https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html.

4. scikitlearn

Wir benötigen ebenfalls die Bibliothek scikit-learn, welches auf NumPy und SciPy basiert und die speziell im Bereich der Vorhersagen im Machine Learning oft eingesetzt wird. Hier geht’s zur Dokumentation von scikit-learn.

Installiert euch scikitlearnn bzw. Scipy entweder in eurer Anaconda-Environment oder mithilfe des folgenden Aufrufs: pip install -U scikit-learn (https://stackoverflow.com/questions/36384447/how-to-install-sklearn/36384516)

5. matplotlib

Matplotlib ist eine tolle Bibliothek zum Plotten und bietet hervorragende Funktionalitäten zur Erstellung und Visualisierung eurer Diagramme. Falls ihr mehr zu Matplotlib erfahren möchtet, schaut gerne unter der Rubrik Matplotlib auf dem Blog vorbei.

Holt euch Matplotlib in eurer Anaconda-Environment oder via python -m pip install -U matplotlib (DOKUMENTATION).

Perfekt. Genug mit den Vorbereitungen, jetzt geht’s ans Eingemachte: Holen wir uns unsere Rohdaten.

 

Schritt 2: Datenimport der Rohdaten aus csv-Datei

Hier ist der Datensatz mit den Immobiliendaten, mit denen wir unsere Künstliche Intelligenz programmieren: 

https://drive.google.com/file/d/1GfvKA0qznNVknghV4botnNxyH-KvODOC/view. Ihr könnt die Datei downloaden und im selben Ordner wie euer Jupyter Notebook / Python-File speichern. Gebt der heruntergeladenen Datei am besten einen aussagekräftigen Dateinamen (hier: Immobiliendaten_Rohdaten.csv).

Jetzt können wir die Daten in Python mit Pandas einlesen. Die Daten sind als csv-Datei gespeichert. Deshalb verwenden wir die Funktion pd.read_csv(‚Dateiname‘). Wir laden die Daten und speichern sie als Pandas DataFrame in die Variable pd. Der Code sieht wie folgt aus:

import pandas as pd
pd = pd.read_csv('Immobilien_Rohdaten.csv')

Wenn ihr euch jetzt pd ausgeben lässt, seht ihr alle unsere Daten geordnet vorliegen. 

pd

KI selbst programmieren: Pandas Tabelle unserer Rohdaten der Immobilien

Ihr erkennt, dass die Tabelle aus 1460 Reihen a 11 Spalten besteht. 1460 Reihen bedeutet, dass wir in dieser Tabelle insgesamt 1460 verschiedene Immobilien betrachten und anhand von verschiedenen Kriterien bewerten. Diese Immobilien unterscheiden sich je nach Größe der Wohnung, Gesamtzahl an Räumen, Badezimmern, usw. Da die Tabelle sehr umfangreich ist, wird nur ein Ausschnitt angezeigt.

Aber welche Daten habt ihr denn da gerade importiert, fragt ihr euch vielleicht? Die Antwort: In der Tabelle seht ihr 11 Spalten, von LotArea bis AboveMedianPrice. 10 dieser Spalten sind die Inputs, also die X-Variablen, welche wir später zum Trainieren unserer KI und unseres Künstlichen Neuronalen Netzwerks benötigen. LotArea (= die Gesamtquadratmeterzahl der Immobilie) bis GarageArea (= die Quadratmeterzahl der Garage) beschreiben diese X-Werte.

In der elften Spalte ist die Variable AboveMedianPrice unsere Y-Variable/Zielgröße. Warum enthält diese Spalte unsere Y-Daten und damit unsere Zielgrößen?

Die Antwort ist einfach: Denn wir wollen eine KI trainieren, die uns vorhersagt, ob eine unbekannte Immobilie mit bestimmten X-Variablen (also LotArea, OverallQuality, OverallCond,…, GarageArea) über dem durchschnittlichen Preis liegt. Unsere Herangehensweise ist, dass wir der KI zunächst mit bekannten Daten von realen Immobilien ‚beibringen‘, wann Immobilienpreise über dem durchschnittlichen Preis liegen. Für jede Immobilie im Trainingssatz erhält die KI die richtige Antwort (also die Labels). 

Falls ihr euch wundert, warum in der Spalte für AboveMedianPrice (also unsere Zielgröße) nur 0 und 1 steht, möchte ich das kurz anhand dieses Bildes erklären:

ki selbst programmieren

KI selbst programmieren: Zielgröße ‚AboveMedianPrice‘ Erklärung

Das heißt, eine Immobilie mit dem Wert 1 für die Variable AboveMedianPrice bedeutet, dass sie überdurchschnittlich teuer ist.

Schritt 3: Preprocessing (Datenvorbereitung und Skalierung)

Jetzt müssen wir unsere Tabelle in ein Numpy-Array umwandeln. Das geht folgendermaßen:

datensatz = pd.values

Im nächsten Schritt müssen wir unseren Datensatz splitten, also aufteilen, in X- und Y-Daten. Dies geht mit nur zwei Zeilen Code:

X = datensatz[:, 0:10]

Y = datensatz[:, 10]

Wir speichern also die jeweiligen Einträge unserer Tabelle in der X- bzw. der Y-Variable. Es ist wichtig anzumerken, dass der erste Eintrag in der eckigen Klammer sich auf die Reihen und der zweite auf die Spalten bezieht. 

Die Angabe [: bedeutet, dass wir alle Reihen (also alle Immobilien) berücksichtigen. [:, 0:10] –> 0:10 schließt Spalte 10 AboveMedianPrice bewusst aus, da in der Listenschreibweise beim Index 0 zu zählen begonnen wird. Der Index 0 bezieht sich also auf die Variable LotArea.

Wisst ihr, was dann in der Variable Y gespeichert wird? Richtig, nur die Ergebnisse der 10. Spalte (also inklusive AboveMedianPrice). Lasst euch doch einmal X oder Y ausgeben, dann werdet ihr das Resultat sehen. Ihr werdet merken, dass in der Y-Variable wie gewünscht nur noch die Ergebnisse der Spalte AboveMedianPrice steht.

Sinn und Zweck dieses Splittens ist es, die X-Variablen und die Y-Variable getrennt vorliegen zu haben. Diesen Schritt habt ihr geschafft!! Sehr gut, weiter geht’s.

Der nächste Schritt besteht darin, unsere X-Werte zu skalieren. Wieso fragt ihr? Das müssen wir deshalb machen, weil die X-Werte (also die Größe der Garage, die Anzahl der Badezimmer, …) extrem voneinander abweichen und ganz unterschiedliche Werteintervalle besitzen. Wir wollen nun, dass nach dem Skalieren alle X_Werte in Werten zwischen 0 und 1 vorliegen. Das setzen wir mithilfe von sklearn um:

from sklearn import preprocessing

skalierer = preprocessing.MinMaxScaler()
X_skaliert = skalierer.fit_transform(X)

X_skaliert

Ob die Skalierung geklappt hat und ob wirklich alle X-Werte jetzt in Werte zwischen 0 und 1 umgewandelt wurden, könnt ihr durch Ausgeben von X_skaliert testen:

X_skaliert

Im Anschluss müssen wir unseren gesamten Datensatz in Trainings, Validierungs- und Testdaten aufsplitten. Unser Ziel ist, dass wir unsere KI mit 70% aller Daten trainieren. Die verbleibenden 30% sollen zum Validieren und Testen unseres trainierten KI-Modells genutzt werden.

Ergo: Wir trainieren zunächst das Modell und sobald es eine zufriedenstellende Genauigkeit erreicht hat, wenden wir unser Neuronales Netz auf unbekannte Immobilien an und bitten es um eine Vorhersage zur Größe AboveMedianPrice. Wir implementieren das Splitten mithilfe der Funktion train_test_split, welche wir von sklearn importieren.

from sklearn.model_selection import train_test_split

X_training, X_valid_und_test, Y_training, Y_valid_und_test = train_test_split(X_skaliert, Y, test_size=0.3)

Im nächsten Schritt trennen wir natürlich auch noch unsere Test- und Validierungsdaten zu gleichen Anteilen (=0.5 = 50%).

X_valid, X_test, Y_valid, Y_test = train_test_split(X_valid_und_test, Y_valid_und_test, test_size=0.5)

Falls du noch wenige oder fast keine Vorkenntnisse in der Programmiersprache Python hast, empfehle ich dir die beiden Bücher und Programmierkurse*: 

Python: 3 Programmieren für Einsteiger und 

Python: Der Grundkurs

———————————————————————————————————-

Schritt 4: Erstellung des Künstlichen Neuronalen Netzes und Training des KI-Modells

Wir erstellen jetzt unser Neuronales Netz. Dieses ist das Herzstück unserer KI und soll ein sequentielles NN-Modell  (Sequential) sein. Es besteht aus vollständig vernetzten Schichten (engl.: Fully connected layers). Das bedeutet, dass alle Neuronen zwischen den verschiedenen Ebenen miteinander verbunden sind.

Unser Modell besteht aus einer Inputschicht, 3 Hidden Layers (versteckte Schichten) und einer Ausgabeschicht mit einem Neuron. Unser Neuronales Netz erwartet für sein Training die Übergabe von x_Werten. Diese Information und das Format unserer Inputdaten teilen wir unserem Neuronalen Netz mit (10,) unter dem Keyword input_shape mit.

Wir übergeben 10, da unsere Trainingsdaten 10 Spalten mit X-Werten besitzen. Diese sind LotArea, Garage,… 32 bezieht sich auf die Anzahl der Neuronen der jeweiligen Schicht, und relu beschreibt die Wahl der Aktivierungsfunktion

Warum wollen in der Outputschicht nur 1 Neuron? Wir wählen 1, weil wir nur eine Aussage vom Neuronalen Netz wissen wollen: Ist der Preis der übergebenen Immobilien überdurchschnittlich oder liegt er unter dem Medianwert?

Wir müssen unser Model kompilieren und die Optimierungsfunktion, die Lossfunktion und die zu messende Metrik (wir wollen die Genauigkeit – accuracy- messen) festlegen. Im Anschluss ‚fitten‘ wir unser Modell. Das heißt, wir trainieren unsere KI mithilfe der X-Daten und dem Wissen über die richten y-Daten des Trainingssatzes.

Da die y-Daten beschriftet (‚gelabelt‘) sind (mit 0 und 1), kann die KI den Zusammenhang zwischen Inputvariablen und der Y_Variable AboveMedianPrice lernen und verstehen. Wir übergeben deshalb in der model.fit-Funktion unsere X- und Y-Daten. Außerdem teilen wir dem Modell mit, wie viele Epochen durchgeführt werden soll und wie groß die Batch_Size ist. Das, was ich gerade in Worten beschrieben habe, ist im folgenden Code enthalten:

from keras.models import Sequential

from keras.layers import Dense

model = Sequential([
Dense(32, activation='relu', input_shape=(10,)),
Dense(32, activation='relu'),
Dense(32, activation='relu'),
Dense(1, activation='sigmoid')
])

model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=['accuracy'])
model_hist = model.fit(X_training, Y_training, epochs=200, batch_size=32, validation_data=(X_valid, Y_valid))

—————————————————————————————————————————–

Meine Empfehlung: Falls ihr noch keinerlei Kenntnisse in der Python-Programmierung habt und unbedingt Python lernen möchtet: Startet durch mit dem Online-Kurs Python Programming Bootcamp von Derek Banas. Ich habe den Kurs auch besucht und durchgearbeitet. Ich kann euch diesen Kurs wirklich ans Herz legen, weil er meiner Meinung nach der beste und einer der umfangreichsten Python-Kurse bei Udemy ist. Der Kurs dauert über 20 Stunden und bietet einen qualitativ hochwertigen Einstieg in die (objektorientierte) Programmierung mit Python. Derek hat seine Videos so gestaltet, dass er ohne lange Umschweife die wichtigsten Inhalte präzise an Hand von Codebeispielen erklärt. Er bettet viele, interaktive Übungsaufgaben ein, sodass ihr euren Fortschritt regelmäßig überprüfen könnt.

Neben Grundlagen wie Funktionen, Klassen, Schleifen, usw. werdet ihr ebenfalls lernen, wie SQLite funktioniert und wie ihr grafische Benutzeroberflächen (GUIs) programmiert. Außerdem lernt ihr das Webframework Django kennen.

Also nichts wie los, das ist eure Chance bei Python so richtig durchzustarten! Ich bin mir sicher, dass ihr nicht enttäuscht werdet und eure Lernfortschritte durch die Decke gehen werden! Klickt direkt auf das Bild, das euch zum Kurs bringt und sichert euch den tollen Udemy-Kurs*:

————————————————————————————————————————————

Glückwunsch, wenn ihr den Anweisungen bis hierhin gefolgt seid, habt ihr jetzt euer Neuronales Netz trainiert und könnt eure KI zur Vorhersage von neuen, ihr unbekannten Daten verwenden.

Schritt 5: Testen der Genauigkeit der KI-Vorhersagen

Testen wir, wie gut sich unsere KI bei der Vorhersage für die Testdaten schlägt. Zur Erinnerung: Die KI wurde nicht mit den Test-, sondern mit den Trainingsdaten trainiert. Das bedeutet, dass wir jetzt den ersten richtigen Praxistest machen und unsere Künstliche Intelligenz mit unbekannten Daten füttern. 

model.evaluate(X_test, Y_test)[1]

Warum brauchen wir die Angabe in den eckigen Klammern? Die 1 bezieht sich auf die Ausgabe der Genauigkeit, da uns nur dieser Wert aktuell interessiert. Wenn ihr das ausführt, solltet ihr eine Genauigkeit von mindestens 91% erhalten. Yippie, das kann sich doch sehen lassen!

Das NN erreicht eine Genauigkeit von über 90% bei der Anwendung auf unbekannte Testdaten. ABER: Können und wollen wir dieser KI einfach vertrauen? Nein, natürlich nicht. Wir sollten uns genauer ansehen, welche Werte die KI erkennt und wie gut wir unser Netz trainiert haben:

Schauen wir doch zunächst, welchen AboveMedianPrice (also y-Variable) die dritte Immobilie im Testdatensatz hat. Wenn ihr das ausgeben lässt via

print(Y_test[2])

, dann bekommt ihr als Ausgabe eine 1. Das bedeutet (wir erinnern uns an die Grafik), dass die Immobilie 3 überdurchschnittlich teuer ist. 

Cool, aber das war einfach. Hier hat unsere KI noch keine Vorhersage treffen müssen. Wir haben gerade nur die vorliegenden Labels/richtigen Lösungen der AboveMedianPrice-Variable zu einer Immobilie abgefragt. Was wir jedoch wollen, ist, dass unsere KI uns Prognosen liefert. Also tun wir doch genau das:

Y_test_vorhersage = model.predict(X_test)

Y_test_vorhersage[2]

Und? Welchen Wert erhaltet ihr als Ergebnis? Kommt die Wahrscheinlichkeit sehr nah an den Wert 1 heran? Also, dass Immobilie 3 überdurchschnittlich teuer ist? 

Klasse, dann habt ihr das Tutorial fast geschafft und eure KI hat sehr gute Arbeit geleistet!!!

Im letzten Schritt wollen wir unsere Ergebnisse zur besseren Anschaulichkeit mit Matplotlib visualisieren. Wie das geht, zeige ich euch im Folgenden:

from matplotlib import pyplot as plt

plt.figure(figsize=(10,6))

plt.plot(model_hist.history['acc'])

plt.plot[model_hist.history['val_acc'])

plt.title('Genauigkeit des Modells')

plt.xlabel('Epochen')

plt.ylabel('Genauigkeit')

plt.legend(['Training', 'Validierung'])

plt.show()

Yeah, jetzt habt ihr es geschafft!

Herzlichen Glückwunsch. Ihr habt jetzt eure eigene KI selbst programmiert und ein funktionsfähiges KI-Modell zur Bewertung von Immobiliendaten aufgebaut! Das kann sich sehen lassen!!!

Für alle YouTube- und Videofans: Die Inhalte dieses Blogbeitrags habe ich auch noch einmal in ein Video gepackt. Durch Klick aufs Bild oder auf den LINK gelangt ihr direkt zum YouTube-Video:

KI selbst programmieren: YouTube Tutorial zum Artikel

Lasst mir gerne bei der Gelegenheit auf meinem Blog und YouTube-Kanal ein Abo (hier geht’s zum Newsletter) da, um keine spannenden (KI) Programmiervideos mehr zu verpassen.

————————————————————————————————————————————

Tolle Bücher und Kurse* zum Python lernen (speziell für Programmier-Einsteiger)

Meine Empfehlung: Falls ihr noch keinerlei Kenntnisse in der Python-Programmierung habt oder aber von einer anderen Programmiersprache umsteigen möchtet: Startet durch mit dem Online-Kurs Python Programming Bootcamp von Derek Banas. Ich habe den Kurs auch besucht und durchgearbeitet. Ich kann euch diesen Kurs wirklich ans Herz legen, weil er meiner Meinung nach der beste und einer der umfangreichsten Python-Kurse bei Udemy ist. Der Kurs dauert über 20 Stunden und bietet einen qualitativ hochwertigen Einstieg in die (objektorientierte) Programmierung mit Python. Derek hat seine Videos so gestaltet, dass er ohne lange Umschweife die wichtigsten Inhalte präzise an Hand von Codebeispielen erklärt. Er bettet viele, interaktive Übungsaufgaben ein, sodass ihr euren Fortschritt regelmäßig überprüfen könnt.

Neben Grundlagen wie Funktionen, Klassen, Schleifen, usw. werdet ihr ebenfalls lernen, wie SQLite funktioniert und wie ihr grafische Benutzeroberflächen (GUIs) programmiert. Außerdem lernt ihr das Webframework Django kennen.

Also nichts wie los, das ist eure Chance bei Python so richtig durchzustarten! Ich bin mir sicher, dass ihr nicht enttäuscht werdet und eure Lernfortschritte durch die Decke gehen werden! Klickt direkt auf das Bild, das euch zum Kurs bringt und sichert euch den tollen Udemy-Kurs*:

 

————————————————————————————————————————————

Vielen Dank für euer Interesse am Artikel „KI selbst programmieren“. Bis zum nächsten Artikel auf

Python programmieren mit Maximilian

Euer Maximilian.

Alle mit * gekennzeichneten Links sind Affiliate-Links.

Speichere in deinen Favoriten diesen permalink.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.