Viele Unter­neh­men sit­zen auf einem Schatz und wis­sen oft nicht, was sie damit anfan­gen sol­len. Die Rede ist von Daten. Um die­sen Schatz heben zu kön­nen, braucht es Wis­sen und Werk­zeuge. Ein wich­ti­ger Teil des Hebens des Daten­schat­zes wird unter dem Begriff „Data Sci­ence“ zusam­men­ge­fasst. Dabei wer­den ver­schie­dene mathe­ma­ti­sche Metho­den und Algo­rith­men ein­ge­setzt, um am Ende ein Modell zu erstel­len, das die eige­nen Daten mög­lichst gut wider­spie­gelt und mit dem man Aus­sa­gen über die Zukunft machen kann. Wenn im Zusam­men­hang mit Data Sci­ence von „Model­len“ die Rede ist, sind maschi­nelle Lern­mo­delle gemeint.

Das klingt erst ein­mal sehr kryp­tisch. Und über­haupt, wo fange ich an und was brau­che ich alles, um ein sol­ches Modell zu erstel­len? Genau darum soll es in die­sem Block­bei­trag gehen. Wir neh­men Sie an die Hand und zei­gen Ihnen Schritt für Schritt, wie der Ein­stieg in das Thema Data Sci­ence klappt, sodass Sie am Ende des Bei­trags in der Lage sind, ein eige­nes maschi­nel­les Lern­mo­dell (engl. Maschine Lear­ning Model) zu erstellen.

Python

Python ist die Pro­gram­mier­spra­che der Wahl, wenn es um Daten­ber­ar­bei­tung und maschi­nelle Lern­mo­delle geht. Die Instal­la­tion unter Win­dows, Linux und macOS ist ein­fach und schnell.

Zuerst soll­ten Sie über­prü­fen, ob Python bereits auf Ihrem Rech­ner instal­liert ist und wenn ja, in wel­cher Ver­sion. Öff­nen Sie dazu die Kon­sole und pro­bie­ren Sie nach­ein­an­der fol­gende Befehle aus:

python --version
python2 --version
python3 --version

Sie kön­nen zum Abschnitt „Vir­tu­elle Umge­bun­gen“ wech­seln, wenn Sie bereits Python in einer mög­lichst aktu­el­len Ver­sion (3.10 oder höher) instal­liert haben.

Win­dows

Laden Sie das Instal­la­ti­ons­pro­gramm für Python von der Web­site python.org her­un­ter. Kli­cken Sie dort auf den Rei­ter „Down­loads“ und dann auf „Win­dows“. Kli­cken Sie auf „Down­load Win­dows instal­ler (64-bit)“ unter einer mög­lichst aktu­el­len Ver­sion (z.B. Python 3.12.6) und laden Sie diese her­un­ter. Nach Abschluss des Down­loads star­ten Sie das Instal­la­ti­ons­pro­gramm. Gleich zu Beginn der Instal­la­tion sollte der Punkt „Add Python 3.x to PATH“ ange­kreuzt wer­den. Dadurch wird das Instal­la­ti­ons­ver­zeich­nis zur Umge­bungs­va­ria­blen PATH hin­zu­ge­fügt und es kann der Python3-Befehl in jedem Ver­zeich­nis ohne Angabe des voll­stän­di­gen Pfads und ohne Not­wen­dig­keit, im Instal­la­ti­ons­ver­zeich­nis zu sein, aus­ge­führt wer­den. Alle ande­ren Vor­ein­stel­lun­gen im Instal­la­ti­ons­pro­gramm pas­sen in der Regel und Sie kön­nen auf „Install Now“ kli­cken. Abschlie­ßend fragt das Instal­la­ti­ons­pro­gramm, ob die Län­gen­be­schrän­kung für Datei­pfade auf­ge­ho­ben wer­den soll („Disable file path length limit“). Dies soll­ten Sie bejahen.

macOS

Wenn Sie einen Mac benut­zen, emp­feh­len wir Ihnen, zuerst den Paket­ma­na­ger „Home­brew“ zu instal­lie­ren. Geben Sie dazu fol­gen­den Befehl in das Mac-Ter­mi­nal ein (Sie fin­den ihn auch unter www.brew.sh):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Nach der Instal­la­tion das Ter­mi­nal kom­plett schlie­ßen und wie­der öff­nen. Danach soll­ten Sie das Pyenv-Modul mit „brew install pyenv“ instal­lie­ren. Mit Pyenv kön­nen Sie schnell zwi­schen ver­schie­de­nen Python-Ver­sio­nen für Ihre ver­schie­de­nen Pro­jekte wech­seln, was sehr nütz­lich ist, da einige Python-Module eine bestimmte Python-Ver­sion erfor­dern. Der Clou von Pyenv besteht darin, dass Sie in der Kon­fi­gu­ra­tion Ihrer Shell eine soge­nannte Shim regis­trie­ren. Dadurch wird der Befehl „python“ von einem Skript abge­fan­gen, das dann ent­schei­det, wel­ches Python-Binary auf­ge­ru­fen wer­den soll. Damit das funk­tio­niert, müs­sen Sie Pyenv in die Kon­fi­gu­ra­tion der Shell ZSH ein­tra­gen. Füh­ren Sie dazu fol­gen­den Befehl im Ter­mi­nal aus:

echo 'eval "$(pyenv init --path)"'>> ~/.zprofile
echo 'eval "$(pyenv init -)"'>> ~/.zshrc

Anschlie­ßend das Ter­mi­nal kom­plett been­den (am bes­ten mit cmd +Q). Danach öff­nen Sie das Ter­mi­nal erneut und geben den Befehl „pyenv install 3.12.2“ ein, um die neu­este Ver­sion von Python zu instal­lie­ren, die zum Zeit­punkt der Erstel­lung die­ses Bei­trags ver­füg­bar war.

Linux

Auf­grund der gro­ßen Anzahl von Linux-Dis­tri­bu­tio­nen ist es im Rah­men die­ses Blogs nicht mög­lich, für jede Dis­tri­bu­tion den Weg zur Instal­la­tion von Python zu beschrei­ben. Zum Glück ist bei den meis­ten Dis­tri­bu­tio­nen Python bereits vor­in­stal­liert. Sollte dies bei Ihrer Dis­tri­bu­tion nicht der Fall sein, wer­den Sie wahr­schein­lich in den Repo­si­to­ries Ihrer Dis­tri­bu­tion fün­dig. Bei Ubuntu z.B. soll­ten Sie zunächst die Pakete mit „sudo apt update“ aktua­li­sie­ren und dann mit dem Befehl „apt search python3.12“ nach Instal­la­ti­ons­pa­ke­ten der Ver­sion 3.12 suchen. Mit „apt install python3.12“ kön­nen Sie dann diese Ver­sion instal­lie­ren. Wir emp­feh­len, unter Linux mit dem Paket­ma­na­ger pip zu arbei­ten, da Sie so bestimmte Module ein­fach nach­in­stal­lie­ren kön­nen. pip kann auch über das Ter­mi­nal mit „sudo apt install python3-pip“ instal­liert werden.

Vir­tu­elle Umgebungen

Am bes­ten ist es, sich von Anfang an an das Arbei­ten in vir­tu­el­len Umge­bun­gen zu gewöh­nen. Das mag auf den ers­ten Blick kom­pli­ziert erschei­nen, ist es aber nicht. Für jedes Pro­jekt, das Sie begin­nen, wird zunächst eine vir­tu­elle Umge­bung ein­ge­rich­tet. Sie kön­nen sie sich wie einen Ord­ner vor­stel­len, der alle Werk­zeuge für Ihr Pro­jekt ent­hält, genau auf Ihre Bedürf­nisse zugeschnitten.

Diese Vor­ge­hens­weise erspart Ihnen viel Ärger im Laufe der ver­schie­de­nen Pro­jekte. Zum Hin­ter­grund: Python-Skripte ver­wen­den in der Regel Module, die bestimmte Funk­tio­nen zur Ver­fü­gung stel­len. Es gibt bereits unzäh­lige Module, die alle für unter­schied­li­che Zwe­cke ein­ge­setzt wer­den kön­nen. Die Python-Skripte basie­ren aber nicht immer auf der glei­chen Ver­sion von Python und/oder ver­wen­den die glei­che Modul­ver­sion. Wenn man nun für jedes Pro­jekt auf der gan­zen Maschine immer wie­der glo­bal die Python­ver­sion oder bestimmte Modul­ver­sio­nen ändern muss, wird es unüber­sicht­lich bzw. man kann nicht ohne wei­te­res an zwei ver­schie­de­nen Pro­jek­ten arbei­ten, die unter­schied­li­che Python- bzw. Modul­ver­sio­nen benötigen.

Im Laufe die­ses Blogs wer­den wir ein neues Pro­jekt star­ten, in dem wir den Wert von Immo­bi­lien in New York anhand der Wohn­flä­che mit Hilfe einer linea­ren Regres­sion vor­her­sa­gen wol­len. Dazu legen wir einen neuen Ord­ner für die­ses Pro­jekt an und erstel­len in die­sem Ord­ner eine neue vir­tu­elle Umge­bung. Wenn wir die vir­tu­elle Umge­bung akti­vie­ren, arbei­tet Python nur mit die­sem Ord­ner und instal­liert alle Module aus­schließ­lich dort. Theo­re­tisch könn­ten wir auch eine bestimmte Ver­sion von Python für diese Umge­bung instal­lie­ren. Unsere glo­bal instal­lierte Python-Ver­sion bliebe davon unberührt.

Machine Lear­ning in a Nutshell

Um aus den Mit­teln und Mög­lich­kei­ten, die Data Sci­ence bie­tet, einen Mehr­wert für Ihr Unter­neh­men zu gene­rie­ren, sind vor allem zwei Aspekte wich­tig. Die wich­tigste Kom­po­nente sind die Daten. Auch hier gilt das Motto „Gar­bage in Gar­bage out“. Wenn die Daten nicht reprä­sen­ta­tiv für Ihren Anwen­dungs­fall oder sehr lücken­haft und nicht ver­nünf­tig auf­be­rei­tet sind, nützt der beste Machine Lear­ning-Algo­rith­mus nichts. In sol­chen Fäl­len kann man noch so viele Daten­sätze auf das maschi­nelle Lern­mo­dell wer­fen, der Out­put wird nicht zufrie­den­stel­lend sein.

Der zweite wich­tige Aspekt ist die Aus­wahl des rich­ti­gen Machine Lear­ning-Modells (auch kurz „Modell“ genannt). Unter Machine Lear­ning ver­steht man Pro­gramme, die ihr Wis­sen aus einem Daten­satz gewin­nen und dann mit die­sem Wis­sen bestimmte Auf­ga­ben erle­di­gen kön­nen, die sonst nur sehr auf­wen­dig oder gar nicht lös­bar wären. Dar­über hin­aus ler­nen die Modelle mit jedem neuen Daten­punkt dazu und sind in der Lage, neue Regeln für sich selbst auf­zu­stel­len, die dann wie­derum das Ergeb­nis (auch Vor­her­sage oder im Eng­li­schen „pre­dic­tion“ genannt) verbessern.

Es gibt ver­schie­dene Arten, wie maschi­nelle Lern­al­go­rith­men ler­nen. Die bei­den wich­tigs­ten Arten sind das über­wachte Ler­nen (Super­vi­sed Lear­ning) und das unüber­wachte Ler­nen (Unsu­per­vi­sed Lear­ning). Beim über­wach­ten Ler­nen wird dem Modell ein Daten­satz zum Ler­nen gege­ben, bei dem die Lösung für jedes Attri­but bereits vor­ge­ge­ben ist. Die Attri­bute oder Merk­male sind nichts ande­res als die ein­zel­nen Ein­träge der jewei­li­gen Spal­ten einer Tabelle. Im Gegen­satz dazu steht das unüber­wachte Ler­nen. Bei die­sem Ansatz muss das Modell die Mus­ter selbst erken­nen, die Daten sind nicht beschrif­tet. Bild­lich gespro­chen fehlt die Bau­an­lei­tung. Wenn man einem sol­chen Algo­rith­mus z.B. ein Satel­li­ten­bild vor­legt, weiß er nicht, dass die blauen Flä­chen Seen oder Meere sind und die grü­nen Wäl­der oder Wie­sen. Er ist aber in der Lage zu erken­nen, dass es diese unter­schied­li­chen Flä­chen gibt und kate­go­ri­siert sie selbständig.

Im Rah­men unse­res Bei­spiel­pro­jekts wer­den wir ein Modell ver­wen­den, das in die Kate­go­rie des über­wach­ten Ler­nens ein­ge­ord­net wird.

Das Bei­spiel Projekt

Um mit unse­rem Machine Lear­ning-Modell zu begin­nen, das wir dar­auf trai­nie­ren wer­den, Immo­bi­li­en­preise für den New Yor­ker Stadt­teil Sta­ten Island vor­her­zu­sa­gen, müs­sen wir zunächst, wie oben erwähnt, die vir­tu­elle Umge­bung für das Pro­jekt ein­rich­ten. Dazu erstel­len wir einen neuen Ord­ner. Öff­nen Sie dann die Kon­sole und navi­gie­ren Sie mit cd in den neu erstell­ten Ord­ner. Dort erstel­len Sie anschlie­ßend die vir­tu­elle Umge­bung in der Kon­sole mit:

python3 -m venv env

Das Modul venv ist Bestand­teil von Python ab Ver­sion 3.3. Der Name der vir­tu­el­len Umge­bung, in die­sem Bei­spiel env, kann frei gewählt wer­den. Der obige Befehl erstellt einen neuen Ord­ner mit dem Namen env in dem Ver­zeich­nis, in dem Sie sich gerade befin­den. Unter macOS und Linux genügt fol­gen­der Befehl, um die erstellte vir­tu­elle Umge­bung zu aktivieren:

source env/bin/activate

Unter Win­dows sieht der Befehl ein wenig anders aus:

env\Scripts\activate.bat

Dadurch wird das Skript activate.bat aus­ge­führt, das von der vir­tu­el­len Umge­bung venv erstellt wurde. Der Name der vir­tu­el­len Umge­bung (in die­sem Fall env) erscheint in Klam­mern vor der Ein­ga­be­zeile Ihrer Kon­sole, sobald diese akti­viert ist.

Nun müs­sen Sie nur noch Ihre Ent­wick­lungs­um­ge­bung (IDE) aus dem Ord­ner her­aus öff­nen, z.B. Visual Stu­dio Code mit dem Befehl „code .“ . Danach erstel­len Sie in der IDE eine neue Datei und benen­nen diese pas­send, z.B. NY_Housing_Market.ipynb. Wir spei­chern die Datei nicht als .py, son­dern als eine .ipynb-Datei (Jupy­ter Note­book) ab. Dies hat den Vor­teil, dass man den Code in der IDE über­sicht­lich ent­wi­ckeln und sich das Ergeb­nis anzei­gen las­sen kann.

Daten

Wie bereits erwähnt, wol­len wir Immo­bi­li­en­preise für den New Yor­ker Stadt­teil Sta­ten Island pro­gnos­ti­zie­ren. Dazu benö­ti­gen wir Daten. Wir wer­den einen frei zugäng­li­chen Daten­satz der Platt­form Kaggle ver­wen­den. Gehen Sie ein­fach zu Kaggle.com, regis­trie­ren Sie sich und laden Sie den Daten­satz NY-House-Dataset.csv her­un­ter. Spei­chern Sie den Daten­satz in dem Ord­ner, den Sie zuvor für das Pro­jekt ange­legt haben.

Der erste Schritt besteht darin, sich einen Über­blick über die Daten zu ver­schaf­fen und ihre Qua­li­tät zu beur­tei­len. Denn wie bereits erwähnt, ist es nicht ziel­füh­rend, das Modell ein­fach mit Daten schlech­ter Qua­li­tät zu füt­tern. Das Ergeb­nis wird ent­spre­chend schlecht ausfallen.

In der Kon­sole, im Ver­zeich­nis unse­res Pro­jek­tes, instal­lie­ren wir zunächst einige Python-Biblio­the­ken, die wir für die wei­tere Bear­bei­tung des Daten­sat­zes benö­ti­gen. Dazu ver­wen­den wir den Befehl:

pip install matplotlib pandas scikit-learn seabrorn

Pan­das wird benö­tigt, um die Daten aus der CSV-Datei zu laden und Mat­plot­lib und Sea­born, um die Daten anschau­lich zu visua­li­sie­ren. Für das Machine Lear­ning-Modell wird Sci­kit benö­tigt. Nun kön­nen Sie in die zuvor erstellte jypn-Datei in Ihrer IDE wech­seln. Dort müs­sen zunächst die zuvor instal­lier­ten Biblio­the­ken impor­tiert werden:

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import root_mean_squared_error
from sklearn.preprocessing import OrdinalEncoder

Die CSV-Datei mit den Daten des New Yor­ker Immo­bi­li­en­mark­tes muss eben­falls in unser Pro­jekt impor­tiert und les­bar gemacht wer­den. Ver­wen­den Sie dazu den fol­gen­den Befehl, wobei Sie den Pfad durch den Spei­cher­ort Ihres Daten­sat­zes ersetzen:

data = pd.read_csv("NY-House-Dataset.csv")

Mit „data.info()“ bekommt man einen Über­blick über die Anzahl der Daten im Daten­satz und der Spal­ten sowie über deren Datentyp.

Informationen zum Datensatz.
Abbil­dung 1 Über­blick über den Daten­satz mit­tels data.info()

Der Daten­satz ent­hält 4801 Immo­bi­lien, die durch 17 Attri­bute (Spal­ten) beschrie­ben wer­den. In die­sem Bei­spiel­da­ten­satz gibt es keine feh­len­den Werte. Die Rea­li­tät sieht in der Regel anders aus. Nach­dem wir uns einen Über­blick über die Spal­ten und ihre Namen bzw. Inhalte ver­schafft haben, kön­nen wir mit der Berei­ni­gung des Daten­sat­zes begin­nen. Einige Spal­ten, wie der Name des Mak­lers und die Adresse, sind für uns nicht rele­vant und kön­nen gelöscht wer­den. Ent­fer­nen Sie die nicht benö­tigte Spal­ten mit:

data = data.drop(['LOCALITY' , 'FORMATTED_ADDRESS', 'LONG_NAME', 'ADMINISTRATIVE_AREA_LEVEL_2', 'MAIN_ADDRESS', 'STATE', 'ADDRESS', 'BROKERTITLE', 'SUBLOCALITY'], axis = 1)

Als nächs­tes müs­sen wir schauen, in wel­chem Stadt­teil eine Immo­bi­lie liegt, da uns eigent­lich nur die Immo­bi­lien in Sta­ten Island inter­es­sie­ren. Die Spalte STREET_NAME lie­fert die gewünschte Information.

Mit „data[‚STREET_NAME‘].value_counts()“ erhal­ten wir zunächst einen Über­blick, wie viele Immo­bi­lien sich in den ein­zel­nen Stadt­tei­len befinden.

Liste der Bezirke mit Anzahl der Objekte.
Abbil­dung 2 Anzahl der Immo­bi­lien pro Stadtteil

Jetzt wer­den Inkon­sis­ten­zen im Daten­satz sicht­bar. Es scheint, dass einige Immo­bi­lien nicht kor­rekt einem Stadt­teil zuge­ord­net sind. Es gibt z.B. Immo­bi­lien, die als Stadt­teil „New York“ ein­ge­tra­gen haben. Dies ist nicht kor­rekt, da es in New York kei­nen Stadt­teil New York gibt. In der Rea­li­tät müss­ten die Daten auf­wen­dig nach wei­te­ren Inkon­sis­ten­zen durch­sucht und anschlie­ßend berei­nigt wer­den, da sonst unser Machine Lear­ning-Modell mit feh­ler­haf­ten Daten trai­niert würde. Für unsere Zwe­cke beschrän­ken wir uns jedoch auf die 480 Daten­punkte, die der Bezirk Sta­ten Island aufweist.

Visua­li­sie­rung

Zu den Auf­ga­ben eines Data Sci­en­tist gehört es auch, die Daten mög­lichst anschau­lich auf­zu­be­rei­ten und z.B. dem Auf­trag­ge­ber (Stake­hol­der) zu prä­sen­tie­ren. In unse­rem Fall könnte man mit den Infor­ma­tio­nen aus den Spal­ten LATITUDE und LONGITUDE eine Karte erstel­len, in der die ein­zel­nen Daten­punkte (Immo­bi­lien) dar­ge­stellt wer­den. Man sollte sich immer vor­her gut über­le­gen, was man mit wel­cher Gra­fik wie zei­gen möchte. Da wir uns für die Immo­bi­lien in Sta­ten Island inter­es­sie­ren, ist es sinn­voll, die direkt angren­zen­den Stadt­teile von Sta­ten Island mit in die Karte auf­zu­neh­men. So erhält man einen guten Über­blick über die Lage der Sta­ten Island Immo­bi­lien inner­halb von New York. Daher erstel­len wir zunächst eine Liste „dis­trics“ der Stadt­teile, die wir auf der Karte dar­stel­len möch­ten und fil­tern den Daten­satz anschlie­ßend mit dis­trics. Das Ergeb­nis wird in der Varia­blen map gespeichert.

districs = ["Manhattan", "Staten Island", "The Bronx", "Queens", "Brooklyn"]
map = data[data["STREET_NAME"].str.contains('|'.join(districs))]

Um die Daten­punkte der ein­zel­nen Stadt­teile farb­co­diert in einer Gra­fik dar­stel­len zu kön­nen, müs­sen diese zunächst in nume­ri­sche Werte umge­wan­delt wer­den. So wird z. B. aus Sta­ten Island eine 1, aus Brook­lyn eine 2 und so wei­ter und so fort. Dazu wird zunächst eine Instanz der oben impor­tier­ten Klasse Ordi­na­lEnco­der erzeugt, die mit der Methode fit_transform die Werte der Spalte STREET_NAME in nume­ri­sche Werte umwandelt.

oe = OrdinalEncoder()
street_name_oe = oe.fit_transform(map[['STREET_NAME']])

Um ein Streu­dia­gramm zu erstel­len, das die Stand­orte auf einer Karte basie­rend auf geo­gra­phi­schen Koor­di­na­ten dar­stellt, ver­wen­den Sie den Befehl „plot“ mit der Option „kind=’scatter‘“. Ver­wen­den Sie für die x‑Achse die Spalte LONGITUDE und für die y‑Achse die Spalte LATITUDE, um die Län­gen- und Brei­ten­grade kor­rekt dar­zu­stel­len. Die Trans­pa­renz der Punkte wird mit dem Para­me­ter „alpha“ ein­ge­stellt. Dadurch wer­den über­lap­pende Punkte sicht­bar. Mit dem Para­me­ter „color“ kön­nen Sie den Num­mern (bzw. Stadt­tei­len) Far­ben zuweisen.

map.plot(kind = 'scatter', x = 'LONGITUDE', y = 'LATITUDE', title = "Standorte", alpha = .3, color=street_name_oe)
plt.show()
Streudiagramm der Immobilien in New York, farbcodiert nach Stadtbezirken.
Abbil­dung 3 Streu­dia­gramm Immobilienstandorte

Die Gra­fik zeigt, dass bis auf wenige Aus­nah­men die meis­ten Immo­bi­lien den Stadt­tei­len rich­tig zuge­ord­net wurden.

Ana­lyse

Für die wei­tere Ana­lyse wer­den die Spal­ten LONGITUDE und LATITUDE nicht benö­tigt und kön­nen ebenso wie alle ande­ren Stadt­teile außer Sta­ten Island aus dem Daten­satz ent­fernt werden.

data = data.drop(['LONGITUDE', 'LATITUDE'], axis = 1)
data = data.drop(data[data["STREET_NAME"] != "Staten Island"].index)

Es sollte auch über­prüft wer­den, ob der Daten­satz Dupli­kate enthält.

data.duplicated().sum()

Die Prü­fung ergibt, dass in den ver­blei­ben­den Daten noch 23 Ein­träge dop­pelt vor­han­den sind. Auch diese müs­sen gelöscht wer­den. Anschlie­ßend ist es rat­sam, sich noch­mals einen Über­blick über die ver­blei­ben­den Daten zu ver­schaf­fen und zu über­prü­fen, ob auch die 23 Dupli­kate ent­fernt wurden.

data.drop_duplicates(inplace=True)
data.info()

Jetzt soll­ten nur noch 457 Daten­punkte im Daten­satz ent­hal­ten sein. Um einen sta­tis­ti­schen Über­blick über die Daten zu erhal­ten, kön­nen Sie die Describe-Methode ver­wen­den (data.describe()). Die Methode ermit­telt für alle nume­ri­schen Spal­ten den Durch­schnitt (mean), die mini­ma­len (min) und maxi­ma­len (max) Werte, die Stan­dard­ab­wei­chung (std) sowie drei Per­zen­tile (25%, 50% und 75%).

Statistische Auswertung der Daten.
Abbil­dung 4 Sta­tis­ti­scher Über­blick über den Daten­satz mit­tels describe()

Beim Anblick der sta­tis­ti­schen Aus­wer­tung fal­len einige Dinge auf, die einer nähe­ren Betrach­tung bedür­fen. Zum einen liegt der maxi­male Wert einer Immo­bi­lie im Daten­satz bei über 2 Mil­li­ar­den Dol­lar, was an sich schon bemer­kens­wert ist. Zum ande­ren liegt der Wert von 75% aller Immo­bi­lien unter einer Mil­lion Dol­lar. Der Mit­tel­wert hin­ge­gen liegt bei ca. 5,6 Mil­lio­nen Dol­lar. Die 2‑Mil­li­ar­den-Dol­lar-Immo­bi­lie scheint ein Aus­rei­ßer zu sein, der den Mit­tel­wert nach oben treibt. Obwohl man nicht leicht­fer­tig Daten aus einem Daten­satz ent­fer­nen sollte, ist es in die­sem Fall durch­aus sinn­voll, da Ihr Modell den Aus­rei­ßer eben­falls in die Berech­nung ein­be­zie­hen und die Ergeb­nisse ent­spre­chend ver­zer­ren würde. Die 2‑Mil­li­ar­den-Dol­lar-Immo­bi­lie wird mit die­sem Befehl entfernt:

data = data.drop(data[data["PRICE"] > 2000000000].index)

Anschlie­ßend sollte die Describe-Methode erneut ange­wen­det wer­den. Die sta­tis­ti­schen Werte sind nun ohne den Aus­rei­ßer aus­ge­wo­ge­ner, der Durch­schnitt ist von über 5 Mio. auf knapp unter 1 Mio. gesun­ken, was den Immo­bi­li­en­markt rea­li­täts­nä­her beschreibt. Unsere ursprüng­li­che Über­le­gung war es, den Wert einer Immo­bi­lie anhand der Wohn­flä­che zu schät­zen, wobei wir davon aus­gin­gen, dass ein linea­rer Zusam­men­hang zwi­schen der Größe der Immo­bi­lie und ihrem Wert besteht. Um dies zu über­prü­fen, kön­nen Sie ein Streu­dia­gramm erstel­len, in dem Sie den Preis der Immo­bi­lie gegen ihre Größe auftragen.

Zuvor müs­sen Sie die Daten jedoch split­ten. Das bedeu­tet, dass Sie die Daten in zwei Daten­sätze auf­tei­len. Mit dem einen Daten­satz wird das Modell trai­niert, mit dem ande­ren wird das Modell anschlie­ßend getestet.

Trai­ning und Anwenden

Sie müs­sen den Daten­satz jedoch nicht manu­ell auf­tei­len. Die Sci­kit-Biblio­thek stellt auch hier­für eine Funk­tion zur Ver­fü­gung, die diese Auf­gabe über­nimmt. Die Größe der bei­den Daten­sätze kön­nen Sie selbst bestim­men. In der Regel trai­nie­ren Sie das Modell mit 80 % des Daten­sat­zes und tes­ten es anschlie­ßend mit den rest­li­chen 20 %.

train_df, test_df = train_test_split(data, test_size=0.2, random_state=40)

Sie kön­nen nun die lineare Abhän­gig­keit zwi­schen dem Wert der Immo­bi­lie und ihrer Größe mit Hilfe eines Streu­dia­gramms visu­ell über­prü­fen. Dazu wird der Teil des Daten­sat­zes ver­wen­det, mit dem das Modell spä­ter auch trai­niert wird.

train_df.plot(kind = 'scatter', y = "PRICE", x = "PROPERTYSQFT" , title = "Immobilienpreise", ylabel = 'Preis pro Immobilie', xlabel = 'Square Feet', alpha = .2)
plt.axis([100, 10000, 20000, 5000000])
plt.show()
Prüfung der linearen Abhängigkeit zwischen dem Wert der Immobilie und ihrer Größe.
Abbil­dung 5 Prü­fung linea­rer Abhän­gig­kei­ten durch Streudiagramm

Aus dem Dia­gramm in Abbil­dung 5 lässt sich bereits eine lineare Abhän­gig­keit zwi­schen den Para­me­tern Preis und Größe einer Immo­bi­lie erah­nen. Um ganz sicher zu gehen, kann man auch den Pear­son-Kor­re­la­ti­ons­ko­ef­fi­zi­en­ten für alle Attri­bute (Spal­ten) berech­nen und in einer Heat­map dar­stel­len. Wir begnü­gen uns jedoch mit der rein visu­el­len Über­prü­fung. Damit kön­nen wir mit dem Trai­ning unse­res Modells, einer linea­ren Regres­sion, begin­nen. Dazu wer­den zunächst der unab­hän­gi­gen Varia­blen x die Werte der Spalte PROPERTYSQFT und der abhän­gi­gen Varia­blen y die Werte der Spalte PRICE zuge­ord­net. Anschlie­ßend kann die lineare Regres­sion direkt mit den x- und y‑Werten trai­niert werden.

y = train_df[["PRICE"]].values
x = train_df[["PROPERTYSQFT"]].values
model = LinearRegression()
model.fit(x,y)

Anschlie­ßend kön­nen Sie das trai­nierte Modell die Vor­her­sage (Pre­dic­tion) machen las­sen und diese als Gerade in das Streu­dia­gramm eintragen.

prediction = model.predict(x)
train_df.plot(kind = 'scatter',y = "PRICE", x = "PROPERTYSQFT" , title = "Lineare Regression", ylabel = 'Immobilienpreis', xlabel = 'Square Feet', alpha = .2)
plt.plot(x, prediction, label = 'model', color = 'black', alpha = 0.5)
plt.axis([100, 10000, 20000, 5000000])
Auf den Trainingsdatensatz angewandte lineare Regression
Abbil­dung 6 Gra­fi­sche Umset­zung der Modellvorhersage

Über­prü­fen

Jetzt wird es span­nend. Wir tes­ten nun unser erstell­tes Modell mit dem Test­da­ten­satz. Dazu müs­sen wir einige Schritte wie­der­ho­len. Der Voll­stän­dig­keit hal­ber und damit Sie alles nach­pro­gram­mie­ren kön­nen, sind alle Schritte noch ein­mal abgebildet.

y_test = test_df[["PRICE"]].values
x_test = test_df[["PROPERTYSQFT"]].values
test_prediction = model.predict(x_test)

test_df.plot(kind = 'scatter',y = "PRICE", x = "PROPERTYSQFT" , title = "Lineare Regression Testdaten", color = 'green', ylabel = 'Immobilienpreis', xlabel = 'Square Feet', alpha = .2)
plt.plot(x_test, test_prediction, label = 'model', color = 'red', alpha = 0.5)
plt.axis([100, 10000, 20000, 5000000])
plt.show()
Auf die Testdaten angewandte lineare Regression.
Abbil­dung 7 Auf den Test­da­ten­satz ange­wandte lineare Regression

Auf den ers­ten Blick wer­den die Test­da­ten durch die Gerade (das Modell) recht gut wie­der­ge­ge­ben. Sie kön­nen das Modell auch kon­kret den Wert einer Immo­bi­lie mit einer bestimm­ten Flä­che vor­her­sa­gen las­sen. Zum Bei­spiel für eine Immo­bi­lie mit einer Größe von 800 Qua­drat­fuß (ca. 74 m²).

model.predict([[800]])

Nach dem Modell würde der Preis für eine 74 m² große Immo­bi­lie auf Sta­ten Island 376.481 Dol­lar betra­gen. Doch wie rea­li­täts­nah sind die vom Modell berech­ne­ten Werte? Um diese Frage zu beant­wor­ten, gibt es bestimmte Güte­kri­te­rien wie das Bestimmt­heits­maß R2 oder die Wur­zel der mitt­le­ren qua­dra­ti­schen Abwei­chung RMSE. R2 gibt den Anteil der Vari­anz in den Beob­ach­tun­gen an. Der Wert liegt zwi­schen 0 und 1, wobei ein Wert von 1 bedeu­tet, dass das Modell die Daten per­fekt erklärt, und ein Wert von 0 anzeigt, dass das Modell kei­nen Erklä­rungs­wert hat. Der RMSE ist etwas anschau­li­cher, da er die Feh­ler in den glei­chen Ein­hei­ten angibt wie die Vor­her­sa­ge­werte. Auch hier unter­stützt uns Sci­kit mit ent­spre­chen­den Funktionen:

print(f'R2: {model.score(x_test, y_test)}')
print(f'RMSE: {root_mean_squared_error(y_test, test_prediction)}')

Als Ergeb­nis erhält man einen Wert für R2 von 0,72 und für RMSE von 283.713 Dol­lar. Diese Resul­tate sind nicht berau­schend, aber auch nicht schlecht. Das Modell kann 72% der Streu­ung der abhän­gi­gen Varia­blen auf der Basis der unab­hän­gi­gen Varia­blen vor­her­sa­gen. Ein RMSE von 283.713 Dol­lar bedeu­tet, dass die durch­schnitt­li­che Abwei­chung der vom Modell vor­her­ge­sag­ten Immo­bi­li­en­preise von den tat­säch­li­chen Prei­sen etwa 283.713 Dol­lar beträgt. Bei einem durch­schnitt­li­chen Immo­bi­li­en­preis von ca. 1 Mil­lio­nen Dol­lar wird der hohe RMSE-Wert etwas relativiert.

Fazit

In der Rea­li­tät wäre man mit den Ergeb­nis­sen nicht zufrie­den. Die erste Über­le­gung zur Ver­bes­se­rung des Modells wäre sicher­lich einen grö­ße­ren Daten­satz zu ver­wen­den. Außer­dem gibt es noch wei­tere Eigen­schaf­ten, die den Wert einer Immo­bi­lie bestim­men, wie z.B. die Lage und das Bau­jahr. Sie könn­ten also meh­rere Attri­bute (Spal­ten) in Ihr Modell ein­fü­gen, um die Rea­li­tät bes­ser abzu­bil­den. Oder Sie pro­bie­ren gleich ein ande­res Modell aus. Um jedoch einen ers­ten Ein­blick in das weite Feld der Data Sci­ence und des maschi­nel­len Ler­nens zu bekom­men, reicht ein ein­fa­cher Algo­rith­mus wie die lineare Regres­sion aus. Sie lässt sich gra­fisch dar­stel­len und ihre Funk­ti­ons­weise ist leicht zu verstehen.