Transcript: PP07 - Machine Learning am Beispiel Textklassifikation

Ja, dann hallo, liebe Hörerinnen und Hörer, schön, dass ihr wieder da seid, dass ihr wieder zugeschaltet habt beim Python-Podcast in der siebten Episode heute.

Heute geht es um Machine Learning und ja, wir haben heute wieder einen Gast dabei im Wintergarten.

Hallo Nico.

Hi, schön, bei euch zu sein.

Ja, und Jochen ist natürlich auch wieder da.

Ja, Jochen ist auch da, genau.

Genau, ich bin der Dominik.

Wir sollten uns, glaube ich, nochmal kurz vorstellen für den Nico, weil wir wahrscheinlich diese Folge irgendwie auch bei Nico veröffentlichen dürfen.

auf Nicos tollen Podcast

InnoCast heißt der noch?

InnoTechCast, genau.

Der InnoTechCast

ist mein Podcast-Projekt, läuft auch so seit

ein bisschen über einem Jahr jetzt

und da geht es halt nicht nur konkret um Python,

sondern um alle möglichen

Sachen, die irgendwie

Nerds und ITler interessieren könnten,

irgendwie von Containern über

irgendwie so DevOps-Geschichten,

einzelne Programmiersprachen.

Was haben wir so gemacht? Wir haben Go gemacht,

wir haben Rust behandelt,

Wir hatten auch schon mal eine Folge so ein bisschen zu peisen.

Also es ist auf jeden Fall sehr spannend, hört da mal rein.

Kann ich empfehlen, klingt gut.

Genau.

Ja, dann fangen wir doch mal mit dem richtigen Thema an jetzt

und gehen das Beispiel durch, was wir für das Machine Learning machen wollen.

Ja, wahrscheinlich sollten wir erstmal so ein bisschen...

Erstmal nochmal so allgemein vielleicht, was ist denn das überhaupt, das Machine Learning?

Was macht das denn?

Ja, das denke ich auch.

Wie viel Statistik ist das eigentlich oder ist das Statistik oder was ist das

oder macht da irgendwelche magischen

Dinge, der Computer einfach magische

Sachen und dann kommt irgendwie wusch

künstliche Intelligenz daraus.

Ja, das ist ja das Gefühl, was man heute in den Medien, finde ich,

irgendwie immer bekommt. Also es ist halt so ein

Buzzword, was überall rumschwirbt, genauso wie

irgendwie künstliche Intelligenz.

Genau, aber im Wesentlichen geht

es ja darum, im Endeffekt gewisse

Strukturen in den Daten zu finden,

um eben Prognosen

über die Zukunft zu lernen.

Das heißt einfach, ich programmiere nicht mehr alles

komplett deterministisch runter, was

ich irgendwie wie von einem gewissen

Eingabewert zu einem gewissen Ausgabewert komme,

sondern ich habe halt eine gewisse

große Menge an Trainingsdaten

und habe dann Algorithmen,

die gewisse Parameter

anpassen bei solchen sogenannten

Trainingsläufen und daraus

quasi generelle Strukturen aus den Daten erkennen,

um dann damit letztendlich

Schlussfolgerungen für die Zukunft

oder für unbekannte Daten

zu ermöglichen. So hätte ich das

zusammengefasst. Ja, würde ich

prinzipiell genauso. Der Computer lernt so,

was er mit neuen Sachen dann anfangen

muss, aus alten Dingen.

Genau, es gibt einmal, es gibt keine

allgemeingültige Definition, was jetzt Machine Learning

ist, aber also

eine von Tom Mitchell wäre halt

so ganz allgemein gehalten, ja,

Machine Learning führt

halt dazu, dass Computer oder dass Programme

aus Erfahrung lernen irgendwie,

mit Erfahrung besser werden.

Genau,

wenn man das jetzt mit traditionellem

Programmieren vergleichen würde, dann ist es halt so,

Dass man eben selbst, wenn man damit programmiert, sozusagen diese Zuordnung von, man bekommt irgendwelche Eingaben und dann soll halt irgendwie irgendwas rauskommen am Schluss, machen muss. Und wenn man jetzt Machine Learning verwendet, dann macht diesen Schritt halt wie ein mathematisches Optimierungsverfahren. Und das sich orientiert an Trainingsbeispielen, an Beispielen für, das ist reingegangen und das ist rausgekommen und so sollte das halt sein.

Aber genau das ist ja auch das, was dann der Mensch dann doch wieder macht. Das heißt, der Mensch macht ja diese Vorarbeit, indem er die Trainingsdaten mit den richtigen Zuordnungen, mit den richtigen Labels bereitstellt.

Genau, richtig. Aber es ist halt schon ein Unterschied, ob man jetzt quasi einem Computer nur zeigen muss, was er tun soll oder ob man ihm tatsächlich explizit Schritt für Schritt sagen muss, was passieren soll. Das eine ist halt deutlich einfacher als das andere. Und damit kommen halt natürlich viel mehr Probleme in den Bereich der Lösbarkeit, als man halt vorher hatte.

Und es gibt auch diverse Probleme, die man sonst gar nicht in den Griff kriegt. Also wo man tatsächlich versucht hat, einen Algorithmus zu schreiben, der das tut, wie zum Beispiel eben sowas wie bei Bildern Katzen von Hunde unterscheiden oder so. Aber das geht halt gar nicht, weil man das halt nicht wirklich in einen Algorithmus reinbekommt.

Man kann nicht so ein Gegenstand definieren. Eine Katze ist irgendwie so ein kleines Tier und grau und weiß und so weiter. Das ist schwer zu unterscheiden.

Ja, oder auch das Arbeiten mit Sprache finde ich ein gutes Beispiel, da hat man halt viele, viele Algorithmen entwickelt, die auch zu einem gewissen Grad funktionieren, aber man ist mit Übersetzungen halt einfach quasi dann auf so einem Plateau spähen geblieben und kam da nicht mehr weiter und dank Deep Learning Verfahren, also tiefen neuronalen Netzen ist es halt eben dann möglich geworden, dann nochmal ganz neue Lernraten zu erreichen.

Ja, das ist genau, das ist halt auch Stichwort Deep Learning eigentlich das Ding, was in den letzten paar Jahren halt diesen Hype irgendwie befeuert hat und da ist durchaus irgendwie ordentlich was dran, also es gehen inzwischen viele Sachen, die früher überhaupt gar nicht gingen und ja, aber natürlich ist es immer schwer für Leute, die das jetzt nicht so ordentlich verfolgen können und wer tut das halt, außer die irgendwie tatsächlich damit arbeiten, zu unterscheiden, was denn jetzt irgendwie geht und was nicht geht und was eigentlich das Coole daran ist,

Und in den Medien hat man dann doch oft das Gefühl, dass man davon ausgeht, dass das irgendwas Magisches ist, dann geht halt alles und das ist ja jetzt auch nicht so.

Das ist genau der spannende Punkt. Du hast nämlich gerade versucht zu erklären, dass das, was da passiert, irgendwelche mathematischen Algorithmen sind und die halt zu verstehen als Mensch oder daran zu schrauben zu können, die Parameter, die man halt irgendwie bei Maschinenlöhnen noch einstellt und das halt dann so durchblicken.

Also was das zu tun hat jetzt mit Statistik oder so, das ist vielleicht nochmal ganz spannend, weil dann würde man vielleicht auch nicht nur glauben, dass Magie, also ne, vielleicht sowas mit zu tun, wenn irgendjemand neue Sachen erfindet, irgendeine Geometrie entdeckt, dann ist das vielleicht auch ganz magisch für jemand, der sowas noch nie gesehen hat und deswegen ist halt diese künstliche Intelligenz gar nicht so künstlich, wie wir dachten, aber dann trotzdem so ein Phänomen, was gerade ja bei den Leuten, die sich damit nicht auskennen, so ankommt.

Ja, also wenn man das guckt, wenn man sich einfach nur die Ergebnisse anschaut, dann wirkt das so ein bisschen magisch.

Genau, also warum kann der Computer jetzt einen Hund von einer Katze unterscheiden? Wie soll das denn gehen?

Wie, der Computer weiß, was ich da gerade gesagt habe und kann mit mir sprechen. Das ist schon phänomenal irgendwo.

Aber ist das nicht eigentlich immer so? Also wenn man halt quasi irgendein Blackbox-Modell hat und da nicht reinschauen kann, dann wirkt das wie Magie.

und wenn man halt nach und nach die

Informationen da drin versteht,

dann, ja, blickt man halt, okay, das

hat gewisse Schlussfolgerungen. Ich meine, es hat schon

Verstehen wir die wirklich bei Machine Learning? Das habe ich jetzt nämlich auch noch nicht

so ganz verstanden. Nee, genau,

da gibt es natürlich einen Unterschied zwischen

so eben Blackbox, Whitebox-Verfahren,

bei denen man, also bei denen

sozusagen, ja,

Whitebox-Verfahren, sowas wie Decision Trees

kann man prinzipiell verstehen, wie die funktionieren, weil man

einfach sicher den Entscheidungsbaum

aufmalen kann, dann kann man den halt von Hand durchgehen.

Bei eben

Blackbox-Verfahren wie so neuronalen Netzen

oder so, kann man das prinzipiell eigentlich

nicht wirklich. Also man kann zwar sehen,

welche, was das Ding gemacht hat

und

auch irgendwie, was es erkannt hat und

woran es sich orientiert, aber so letztlich

genau verstehen, warum es jetzt zu einem bestimmten

Ergebnis gekommen ist, kann man eigentlich

nicht mehr. Und ich fürchte auch, einer der

größten, wichtigsten Punkte,

weshalb das so prinzipiell eine schwierige Geschichte

ist, ist, dass die Modelle, je komplexer

sie werden und desto mehr Parameter sie

haben, werden sie halt auch sehr groß.

Also wenn ich dann mehrere,

ja, Millionen reicht ja schon, aber wenn ich

mehrere hundert Millionen Parameter habe,

dann ist das eine Menge, die ich

als Mensch ja überhaupt nicht mehr überlegen kann.

Das ist halt...

Ja, wobei es inzwischen da ja schon viel

Forschung gibt, gerade auch um

neuronale Netze

eben verständlich zu machen.

Zum Beispiel ja irgendwie

Lime ist ja da so ein Paket, was da in der Zeit

total gehypt wurde, in dem es halt

eben möglich ist, quasi an gewissen

Zumindest für gewisse Objekte zu verstehen, wie das Modell quasi zu diesem Schluss kam.

Also so blackboxig sind diese neuronalen Netze jetzt gar nicht mal mehr.

Auch da gibt es Möglichkeiten, die zu verstehen.

Aber ja, also klar, das ist natürlich deutlich komplexer als jetzt ein Entscheidungsbaum,

den ja wahrscheinlich jeder mehr oder weniger kennt, was nicht viel anders ist als ein Flussdiagramm.

Aber vielleicht wollen wir kurz noch mal ein, zwei Schritte zurückgehen und so ein bisschen die Hörer da abholen.

Wir wollten ja so ein bisschen das Beispiel erzählen und vielleicht kommen wir dann,

welche Methoden man denn verwenden kann für bestimmte

Datensätze. Darum, ob wir jetzt so ein

neuronales Netz oder so ein Decision Tree

verwenden möchten.

Würde das Sinn machen? Was sagt ihr?

Ja, also ich finde, man muss

erstmal festhalten, dass es halt irgendwie

nicht so ist, dass jetzt plötzlich

für alles man Deep Learning benutzen sollte,

nur weil es jetzt gerade gehypt ist, sondern

es gibt ganz, ganz viele Verfahren,

die schon lange existieren, die bewährt

sind und die für einige Tasks

halt auch sehr gut funktionieren. Also wenn ich

jetzt zum Beispiel einfach eine

Zeitreihe vorhersagen möchte

mit

relativ einfachen Mitteln, um vielleicht den Abverkauf

von einem Produkt vorherzusehen oder

die Temperatur oder sowas, dann

gibt es da jetzt erstmal Regressionsverfahren,

die so schon sehr gut funktionieren

und da muss man jetzt nicht zwangsläufig

irgendwie Deep Learning draufwerfen.

Ist halt eben was anderes wie bei der

Bilderkennung, die du jetzt zum Beispiel erwähnt hast.

Regression ist natürlich immer nur so gut, wie

die Zukunft

der Vergangenheit entspricht. Das ist ja vielleicht

Ja, klar, genau.

Aber das Problem haben Deep Learning Algorithmen

an der Stelle genauso.

Ja?

Okay. Also natürlich hast du

da nicht unbedingt dann immer so einen linearen

Zusammenhang, aber

ja, im Grunde natürlich

so Dinge, die komplett neu sind.

Ja, wenn es einmal

Alph oder sowas ist, ein Hund oder eine Katze, weiß man nicht so genau.

Ja, dann kommt was

Neues auf die Welt.

Genau, also es gibt auch

Verfahren, die total einfach zu verstehen

sind. Also sowas wie NaiveBase

zum Beispiel. Das ist eine der ersten

Geschichten, die

also ich glaube 2004 hatte Paul Graham

halt da irgendwie den Artikel

veröffentlicht, The Plan for Spam.

Jetzt musst du nochmal einmal kurz sagen, was

NaiveBase überhaupt ist, für alle, die das noch nie gehört haben.

Das ist auch ein Klassifikationsverfahren und zwar

also ich, genau, ich wollte, also wenn man

jetzt ein bisschen erklären möchte, wie funktioniert das oder wie

funktioniert Machine Learning, dann ist der

allereinfachste Fall, den man beschreiben kann,

halt binäre Klassifikationen, vielleicht.

So, womit man anfangen kann.

Und

ja, NaiveBase

ist halt ein... Also binäre

Klassifikation. Also drin oder nicht drin.

Genau, man unterscheidet eigentlich nur zwei Klassen.

Genau. Und

Merkst du ganz kurz, genau, wenn man

das mal zusammenfassen darf, man hat halt

vom Prinzip her Supervised Machine Learning

und Unsupervised Machine Learning, solche, wo

ich irgendwie Daten habe, wo ich quasi

Labels habe, wo ich sagen kann,

okay, das soll quasi nachher rauskommen,

das ist Supervised Machine Learning. Und es

gibt solche, wo ich diese Information nicht habe,

Das ist das Feld der Unsupervised-Machine-Learning-Sachen.

Und im Feld von Supervised-Machine-Learning

gibt es dann im Wesentlichen unterschiedliche Tasks.

Es gibt eine Regression oder es gibt eine Klassifikation

als die beiden typischsten Fälle.

Und genau, der einfachste Fall wäre dann halt eben

eine binäre Klassifikation, wo ich einfach nur sage,

in folgendem Fall, Daumen hoch, Daumen runter, ja oder nein.

Genau.

Ich suche mal gerade, ob ich das hier...

Ja, schau mal.

finde, Moment.

Wir wollten noch mal kurz erklären, was Space

macht mit einer binären Klassifikation.

Bevor

wir dann vielleicht tatsächlich darauf eingehen, was für eine Möglichkeit

man hat, jetzt so diese Klassifikation durchzuführen,

weil, weiß ich, mehr als zwei

Dinge, also wenn du zwei Merkmale hast, dann

kannst du ja relativ einfach voneinander trennen, wenn die

homogen sind untereinander

in ihren eigenen Klassen. Und das wird ja umso

komplexer, umso

weniger heterogen die untereinander sind, also

umso mehr die sich gleichen, dann hast du natürlich größere

Probleme, dann ist es vielleicht auch so, dass du die Merkmale falsch

anguckst oder so. Also du sollst halt schon

unterscheidende Merkmale finden können.

Und das ist halt im Prinzip das, was du mit Base dann relativ

gut machen kannst. Du kannst halt dann sagen, ey, ist jetzt

der Falter grün oder nicht? Oder schwarz

oder so? Oder ist das halt eine Katze?

Woran erkennt man das? Ich weiß nicht, ob sich

jetzt Base für Katzen und Hunde schon

eignen würde, weil das wird vielleicht schon

schwierig. Ja, also für Bilder

wird das sicherlich nicht gut funktionieren,

aber wenn ich jetzt, eben

das ist halt auch so ein klassisches Beispiel habe,

wenn ich jetzt Spam von Nicht-Spam-Mails unterscheiden

möchte, da ist es halt

genauso, das war früher, waren die ganzen

Spam-Filter irgendwie

regelbasiert, also man erinnert sich da vielleicht noch so an

Zeiten, ich habe das auch selber noch benutzt,

ja, das war so ein

Spam-Assassin,

das hat sich dann halt die Header angeguckt

und dann hat es halt manchen

Providern mehr und manchen weniger vertraut

und

irgendwelche, insgesamt halt irgendwie

einen Score ausgerechnet und gesagt, ah, okay,

das hat jetzt einen Spam-Score von so und so viel

oder so und so viel und ab einer bestimmten Grenze

wurde dann halt abgeschnitten und gesagt, das ist Spam.

Das hat

ganz okay funktioniert, aber das war immer

leicht zu unterlaufen von Spammern

und Spam war immer eine relativ

ärgerliche Geschichte.

Bis dann halt eben

Paul Graham, halt der

ähm

ähm

ja, wie heißt der Inkubator, den er gegründet hat?

Darüber ist er sehr bekannt geworden.

habe ich jetzt gerade, ist mir entfallen,

also der schreibt auch viele Essays und

hat auch ein Buch geschrieben.

Y Combinator tatsächlich.

Vorher hat er es auf der Zunge, ich habe mich nur nicht getroffen.

Ja, der

schrieb dann halt irgendwie 2004

ein Essay, so

A Plan for Spam, also ich habe da irgendwie so eine Idee,

wie wir dieses Problem endgültig in den Griff kriegen.

Und da schlägt er halt vor, irgendwie so

Naive Base zu verwenden, um

inhaltsmäßig irgendwie

Spams von Nicht-Spams zu

unterscheiden, weil, naja, irgendwie

ein Spammer muss ja reinschreiben, dass er was

verkaufen will oder muss ja irgendwie, er kann ja

den Content kann er im Grunde nicht wirklich

so ändern,

dass man das nicht mehr als Spam erkennen

kann, weil dann kann es auch der Mensch

nicht mehr als Spam erkennen und dann

verfehlt das ja seinen Zweck.

Liebe Freund, ich brauche Hilfe.

Ja gut, okay, das ist jetzt eine bestimmte

Art von Spam.

Das sind die, die bei mir gerade immer durchkommen, immer wieder.

Die kommen durch? Da ist aber irgendwas mit

deinem Spam-Filter nicht in Ordnung. Was für ein Spam-Filter?

Okay.

Nein, also sie landen bei mir im Spam-Filter

und ich kann dann immer sehen,

okay, es war eine Message im Spam-Filter,

was auch nicht so häufig passiert.

Ach so, okay, gut, ja.

Genau, und zwar das Verfahren ist halt super einfach.

Das ist halt, mach einfach aus den Mails,

aus dem Inhalt deiner Mails im Spam-Ordner

eine lange Liste von Wörtern,

zähle, wie oft ein Wort da drin halt vorkommt,

merke die Gesamtzahl der Wörter

und die Gesamtzahl der Mails, die da drin waren

und mach das Ganze auch nochmal für den Ordner

mit den Nicht-Spam-Mails

und

das ist schon das Training.

Das war's. Also man hat jetzt

quasi an jedem Wort sozusagen nur dranstehen

quasi

wie oft das halt

vorkommt und man hat nochmal eine Zahl für

wie viel

Mails man gesammelt hat.

Er hat Penis gesagt und dann sagt er, nee, ist wahrscheinlich Spam.

Also so in etwa.

Genau. Und die Klassifikation,

also wenn man das gemacht hat,

ist man mit dem Training schon fertig und das ist auch schon das

Modell. Und die

Klassifikation funktioniert jetzt so,

wenn man jetzt eine zu prüfende Mail hat, dann zerlegt man die

eben auch wieder in eine Liste von Wörtern.

Man macht aus

dieser Wortliste eine Liste von Zahlen

und man ersetzt jetzt

jedes Wort eben durch die Kategoriefrequenz.

Das hatte man ja vorher schon

ausgerechnet, sozusagen. Man wusste halt, wie oft

jedes Wort im Spam- und im Nicht-Spam-Ordner

vorkommt. Und

sozusagen, ja,

man ersetzt jetzt die Wörter eben durch die Kategoriefrequenz

und

multipliziert jetzt einfach alle diese Zahlen

miteinander und

bekommt dann halt eine Wahrscheinlichkeit, dass eine Mail Spam

oder nicht Spam ist. Und

ja, die Zahlen werden relativ klein

sein, weil das sind alles relativ kleine Wahrscheinlichkeiten.

Wenn die noch miteinander multipliziert, ist es

super nahe Null. Das heißt,

man muss das Ganze noch so normalisieren, dass hinterher ja halt

irgendwie quasi

der Wert für Spam und nicht Spam, wenn man das addieren würde,

eins ergibt. Aber ja, ist ja auch

kein Problem. Und das war es schon. Also es ist wirklich

nicht, ist keine große

Hexerei.

Wie sagen wir, Raketenchirurgie.

Das ist eigentlich eine ziemlich einfache Geschichte.

Genau, das kann man ja einfach sich eigentlich auch noch so

in einem Algorithmus darstellen. Da braucht man

ja, keine komplexen

Selbstlernverfahren eigentlich noch, nicht wahr?

Ja, also gut, das Ding

lernt ja tatsächlich. Also wenn ich jetzt sage,

eben, ich habe bisher nur

Mails,

die mir Produkte zur

Vergrößerung meiner primären Geschlechtsmerkmale

irgendwie mir so ein Zeugs andrehen

wollen, bekommen und ich kriege jetzt zum ersten Mal

ein Nigeria-Spam, wo mich jemand halt

dazu bringen will, einen kleinen Betrag

ihm zu geben,

um einen viel größeren zu bekommen,

dann würde ich halt

das halt auch mit in die Spams

reintun und dann müsste ich halt wieder neu

diese Zahlen

ermitteln. Genau, die müssen halt

wieder neu gebildet werden, aber

dann würden sich die Frequenzen wahrscheinlich zum Beispiel

für so ein Wort wie Prinz oder so oder Schweizer

Bankkonto entsprechend verändern

und dann hoffentlich beim nächsten Mal werden wieder so

eine Mail dieser Art... Ziemlich ärgerlich für Prinzen mit Schweizer

Bankkonto. Ja, die haben

ein Problem mit, die werden

ja,

die haben mit Meldern keinen Spaß mehr seitdem.

Genau

und das, ja, und dann

passt sich das durchaus halt

quasi neuen Mustern an, wenn

die nächste Masche um die Ecke kommt, dann braucht man halt nur die

ersten paar

sozusagen richtig zu sortieren und dann sollte das

automatisch funktionieren und mitlernen.

Ja.

Ja, jetzt haben wir kurz an Base-Klassifikationen erklärt. Wir sind aber immer noch nicht bei dem Beispiel angekommen, was wir irgendwie den Menschen, also wie macht man das denn überhaupt?

Wir haben versprochen, dass wir irgendwie praktisch durchgehen wollen. Da hätte ich mal gesagt, lass uns das mal machen. Wir packen mit Sicherheit unter die Folgen mal einen Link zu dem Repository, was wir dafür benutzen wollen. Das ist vom Jochen. Da hat er halt eben eine Schulung drin, eine Data Science Schulung, woraus wir jetzt vor allem gleich mal das Beispiel nehmen wollen für die Text-Klassifikation.

und genau, wenn man da drauf geht,

sieht man in dem Readme auch erstmal irgendwie alle

Informationen, wie man sich das Ganze zieht, also

man klont sich halt erstmal das Git-Repository

soweit, so gut

und dann kommen auch schon die ersten Python-spezifischen

Sachen, denn dann müssen

wir uns erstmal irgendwie mit Conda

eine entsprechende Umgebung aufsetzen. Jochen,

sag doch mal, warum sollte man das immer machen?

Und warum denn Conda?

Ja, also Conda ist

sozusagen der Paketmanager

des Teils

von Python,

der sich mit so Data-Science-Maschinen-Learning-Geschichten beschäftigt.

Da steckt halt auch so eine Firma dahinter, Continuum Analytics.

Das sind auch die, oder die Leute, die die Firma gegründet haben,

sind auch die, die ursprünglich mal NumPy mitentwickelt haben und so.

Und ja, es ist, früher hatte man ja irgendwie mal so die Hoffnung,

dass die Distribution, das ganze Paket-Installations-Ding

halt irgendwie überflüssig machen würden

Und sich halt um Abhängigkeiten und sowas kümmern und das ist irgendwie nicht passiert. Also stattdessen ist es so, dass irgendwie jede Programmiersprache so gefühlt irgendwie ihren eigenen Paketmanager hat.

Und bei Python ist es ein bisschen

besonders schlimm, weil da gibt es halt nicht nur einen,

sondern mehrere. Je nachdem, in welcher

Community man sich da aufhält.

Wenn man irgendwie eher Web-Entwicklung oder sonst

wie Python-Entwicklung macht,

dann ist es eher Pip und

als Repository für Pakete

halt PyPI.

Lass dir sagen, das Problem hat nicht nur Python.

Rust ist da auch ganz schlimm, habe ich schon

gelernt, aber ja.

Ja, es ist auf jeden Fall ziemlich

anstrengend. Ich weiß gar nicht, ob ich Conda so verwenden

würde, so außerhalb von Daten.

Ne, würde ich glaube ich auch nicht, mache ich auch nicht.

Also wenn ich Web-Projekte mache, dann nehme ich

eher PIP und

tatsächlich funktionieren

die meisten Sachen auch, wenn man sie mit PIP installiert.

Also tatsächlich auch die ganzen

Datensachen funktionieren über PIP?

Ja, schon.

Sie

funktionieren zumindest gut genug, als dass man das

meistens einfach so verwenden kann. Wenn ich jetzt

irgendwie tatsächlich

ein Modell trainieren wollte,

aber das will man halt, wenn man

wenn es einen Web-Server hat, der irgendwie auch nur

Pandas noch mitbraucht, um halt irgendwelche

Sachen anzunehmen, oder

selbst ein Web-Server, der jetzt halt hinter

irgendeinem ARP-Modell hat, was irgendwas vorhersagt

oder was irgendwas klassifiziert und dann die Ergebnisse zurückgibt,

da ist es im Grunde egal, da kann man

das bei PIP installieren, aber wenn ich jetzt

irgendwie was trainieren wollte,

dann würde ich eher

die Conda-Pakete nehmen

oder vielleicht sogar

spezielle Docker-Images oder sowas.

Ja, aus meiner Sicht

hatte halt Conda vor allem zwei Vorteile. Zum einen

ist es halt schon mal

zusammen das, was sonst

PIP und Virtual Env ist. Also ich habe die

Möglichkeit, sowohl eine virtuelle Umgebung

mit zusammenzubauen und dann

halt eben in die die Pakete mit rein zu installieren.

Was man häufig möchte,

wenn man gerade zum Beispiel so ein Experiment macht,

dann möchte ich vielleicht meine

Basis-Version an Paketen so lassen,

wie ich sie hatte und dann halt mal für jetzt

eine Konferenz zum Beispiel mir nochmal eine zweite

daneben stellen. Das müsste ich ja sonst mit

Virtual-End-Pip quasi in zwei

Schritten machen. Ja gut, aber normalerweise

machst du ja Virtual-End-Wrapper, dann einen Befehl

und dann ist das Ding ja oben. Genau.

Ich habe tatsächlich einen Python-Skript für sowas

geschrieben, der auch genau das gleiche macht, wenn ich das will.

Aber ja. Genau, und der zweite Punkt ist,

Conda kann halt

einfach ja noch ein bisschen mehr als Pip.

Es kann halt vor allem auch quasi Abhängigkeiten,

die außerhalb von Python-Paketen

liegen, lösen, was dann halt auch

interessant wird, wenn es halt um Treiber-Support und so weiter

geht.

Genau, aber ich glaube, du hast schon recht,

dass es auch so ein Stück weit ein Community-Ding ist,

dass es sich halt im Data-Science-Umfeld

auch durch den starken Support von Continuum da

und den finanziellen Mitteln, die dahinter stecken,

so durchgesetzt hat.

Ja, ja, also ich...

Weil es so einfach zu installieren ist auch.

Es gibt halt auch, glaube ich, nur Windows-Binarys einfach

und da ist dann alles mit dabei an Modulen, was man so hat

und man muss das gar nicht mehr groß bedienen.

Ich glaube, das ist auch so ein low-leveliger Ansatz.

Das ist ein Grund, warum sie das so verbreitet hat.

Wobei ich jetzt ehrlich gesagt zum Beispiel

die große Anaconda-Distribution habe ich nie benutzt,

habe ich nie installiert.

Also das Anaconda-Distribution ist

eigentlich sozusagen das eigentliche

Ding, was irgendwie da produziert

wird. Ich habe immer Miniconda verwendet

und dann halt das installiert, was ich

gerade gebraucht habe. Also der Unterschied ist, Anaconda

bringt halt schon mal irgendwie alle möglichen Pakete mit,

die man potenziell so gebrauchen könnte und Miniconda

ist halt erstmal klein und schlank und

dann muss man halt alles quasi mit

dazu installieren, was man dann noch gerne hätte.

Ja, und eben

der Vorteil gegenüber PIP oder

sagen wir mal so, das ist halt auch nicht mehr so

ganz, das war früher ein Riesen

Unterschied, ist heute nicht mehr ganz so relevant,

ist halt, dass man halt binäre Geschichten

bei Conda auch installieren kann. Also man kann

halt auch Bibliotheken, die unten

drunter liegen, also eben nicht nur Python-Pakete,

sondern eben auch sowas, man kann auch theoretisch sowas wie

Libc irgendwie mit Conda

installieren und die dann halt

in einem Conda-Environment verwenden

und muss halt, also das ist

auch so ein Problem, wenn man jetzt auf größeren

Servern unterwegs ist, die halt

unter Umständen irgendwie

so eine antike Debian-Version

irgendwie haben und eine uralte Lib C

und die funktioniert dann mit neueren

anderen

Bibliotheken nicht mehr gut, dann

habe ich, hatte auch schon den Fall, dass ich dann

per Conda irgendwie eine neue Lib C

in meinem Environment installiert habe, um überhaupt

irgendwie bestimmte Sachen benutzen

zu können. Und das geht halt mit Conda und mit

PIP wäre man da halt relativ aufgeschmissen.

Daher, ja,

für so

wirkliche Data Science Projekte ist das

halt schon irgendwie deutlich netter.

Es ist ein bisschen schade, dass jetzt man halt

zwei Repositories von Paketen hat und

ja, manchmal ist es halt auch so ein bisschen

kompliziert, dann sich zu überlegen, was man gerade

machen will, aber ich würde die

Faustregel einfach nehmen, wenn es ein reines

Data-Science-Projekt ist, ja dann

Conda und wenn es irgendwie eine Web-Geschichte ist oder

was ganz anderes, eher Pip.

Ist das denn immer genauso aktuell in Conda

wie auf PyPy?

Nee, Conda ist nicht so aktuell.

Es gibt dann noch CondaForge, also sozusagen

ein...

Da kann man sich selber Sachen bauen.

Ja, das kann man sowieso, aber

es gibt halt einmal die Pakete,

die sozusagen von der Firma

gebaut werden und ein Repository

von Paketen, das halt

also eine Distribution, die halt

sozusagen redaktionell von

Continuum Analytics gepflegt

wird und es gibt halt

ein Community-basiertes Repository,

das nennt sich dann CondaForge

und man kann das halt

in dem, man hat immer so ein Konfigurations-File

und da kann man

halt die Channels sozusagen

aus denen man Pakete bekommt, halt eintragen

und ja, die meisten verwenden

ContaForge. Es ist jetzt auch irgendwie so,

dass, glaube ich,

Anaconda selber irgendwie auf ContaForge umgestellt

hat oder so. Ja, genau, die haben sich tatsächlich umgestellt.

Das haben wir gehört auf dem Parkcamp jetzt.

Ja, richtig, das hatte ich

auch gar nicht klar, aber ja.

Das fand ich manchmal auch echt so ein bisschen nervig, wenn man ein Paket

installieren wollte, habe ich dann doch meistens mal gegoogelt,

was ist denn jetzt hier das richtige

Repo dafür und das ist jetzt aber

seitdem quasi weg.

Ja, ist tatsächlich anstrengend, wenn man halt schon

unterschiedliche Paketmente hat und dann auch seine eigene Source

dafür irgendwie bestimmen muss.

Ich kann mich da an andere Experimente

erinnern mit so Paketsachen und Sources.

Alles nicht einfacher, aber

hatten wir das schon erwähnt, warum man das überhaupt machen

sollte? Ja, das Problem ist eben, dass die

Pakete in der Distribution halt

nicht wirklich aktuell sind meistens.

Also, wie sagte Barry Varsaw,

glaube ich, einer

Python-Core-Entwickler

sagt man mal, the first rule of Python

is, you don't use system Python.

Das ist halt einfach

üblicherweise veraltet bei vielen

Distributionen, weil sie halt auch das,

weil sie Python halt auch für so

distributionsinterne Zwecke benutzen, mit halt

Python 2 irgendwie noch als Default-Interpreter

bei Mac auch. Es gibt einen

Counter für Python 2 mittlerweile, habt ihr den gesehen?

Desk Clock, ja, gibt's.

Bin mal gespannt, wann die Vertriebssysteme es dann auch mal

sich trauen, also schon ein bisschen halbern so langsam.

Ja, die haben halt alle Angst davor,

dass irgendwie, wenn sie das

ändern, irgendwie ihre Installationsroutinen

nicht mehr funktionieren, weil die halt Python brauchen und

vielleicht noch nicht umgestellt sind. Und die sind halt

alle uralt. Ja, doof.

Und daher muss man

sowieso eigentlich immer einen anderen

Python-Interpreter verwenden, als der, der vorinstalliert

ist. Und dann ist es

halt so, wenn man unterschiedliche Projekte hat,

dann haben die halt unterschiedliche

Abhängigkeiten, was bestimmte Bibliotheken

angeht. Und die

widersprechen sich halt. Und das kriegt man halt auch,

wenn man in einem Filesystem ist.

und das kriegt man halt nicht irgendwie unter einen Hut.

Und daher macht man normalerweise pro Projekt

ein eigenes sozusagen virtuelles Environment,

in dem man halt irgendwie alle Abhängigkeiten installiert,

die man braucht.

Ist dir schon mal vorgekommen,

dass du für ein Projekt zwei Virtual Environments brauchtest,

weil da innerhalb des Projektes

sich unterschiedliche Module besprachen?

Nee, das geht auch gar nicht.

Oder ja, also natürlich doch, stimmt,

man könnte es theoretisch machen,

aber nee, das ist mir jetzt auch noch nicht untergekommen.

Was meinst du innerhalb von einem Projekt?

Ja, es könnte ja irgendwie sein,

dass es zwei Module in einem Projekt gibt,

die unterschiedliche Versionen brauchen,

Python-Version, weil die Module das sonst nicht können

und die man dann irgendwie pipen muss, damit die

man da reden kann. Und um das dann zu bauen,

müsste man halt dann zwei Versionen benutzen.

Nehmen wir zum Beispiel mal an, man hätte

ein OCR-Projekt und man möchte jetzt

irgendwie ein aktuelles

Ding gegen was Älteres

wie Oceropi oder

Kraken oder so verwenden.

Angenommen, Kraken kann auch Python 3, aber

Oceropi kann nur, oder Oceropus

kann nur Python 2. Und jetzt möchte man

halt das Ding aber testen gegen was Neues,

was halt vielleicht nur Python 3 kann. Und dann müsste man

zwei Interpreter halt haben, irgendwie

in dem, ja, das wäre

hässlich.

Aber ich glaube, so kompliziert müssen wir es gar nicht

machen.

Also wenn ihr euch inzwischen das Repo ausgeklont

habt, dann ist jetzt vielleicht der

richtige Moment, einmal corner.env.create

auszuführen, um die Umgebung euch aufzusetzen.

Was an der Stelle ja passiert ist,

er zieht sich von lokal eben

eine hinterlegte

Environment-Datei, die

die ganzen Pakete und die jeweiligen

Versionen beinhaltet, die man bitte

zu installieren hat.

Und danach kann man das dann eben aktivieren

und hat das dann quasi als sein

Default-Python-Interpreter gesetzt.

Also Connor M. Great macht dann genau das,

dass er einfach ein Environment setzt, die heißt dann

Great, oder was? Ne, das steht in dem

in dem File halt

auch mit drin. Der Name von dem?

Von dem

Environment, genau.

Warte mal.

Das ist auch einfach ein YAML-File

und da steht dann eben das erste Name

ds-tutorial

ds-tutorial und dann dependencies,

ach, und dann werden die Pakete danach geploppt.

Und, achso, ist auch so, man kann halt

auch Sachen

per PIP installieren.

Ja, das ist auch sowas, also es ist halt irgendwie,

ja, Conda ist quasi

eine echte Obermenge von PIP,

man kann halt Conda und halt auch PIP,

aber umgekehrt geht es halt nicht, PIP kann halt nicht

Conda Sachen installieren.

Ja, und manche Sachen installiere ich

via PIP, weil das einfach aktuellere Versionen

dann sind.

Ja, oder halt, wenn man was sehr Spezielles

will, ist es vielleicht auch nicht unbedingt immer

in jedem Conda-Repository eben drin.

Da ist PIP, glaube ich, einfach ein bisschen

größer. Also ich kann auch einfach die Version angeben,

wie bei PIP auch, mit gleich oder sowas.

Genau.

Genau. Und danach müsst ihr, um das Repo

quasi so ausführen zu können, noch mal

das lokale Paket bauen

und zwar mit "-e".

Warum wollen wir denn

erstmal überhaupt ein lokales Paket

und warum wollen wir "-e"?

Ja, ein lokales Paket

deswegen, weil man in

vielen Notebooks halt, also ich habe das

Ganze quasi ein bisschen in unterschiedliche

Notebooks aufgeteilt und da gibt es dann

einige, die halt immer wieder den gleichen

Code enthalten. Und jetzt könnte man

natürlich auch in jedes Notebook irgendwie reinkopieren,

aber wenn man dann gemerkt hat, oh, ich habe hier

einen blöden Fehler gemacht, dann muss man das halt auch

in allen Notebooks wieder ändern, was ja ein bisschen

umständlich wäre. Und Code, den man halt

in mehreren unterschiedlichen Notebooks

benötigt, den

kann man ja aber auch einfach eine

Bibliothek und das ist halt im Grunde

dieses Paket, was man da installiert,

rausziehen und

den importiert man dann halt einfach nur in

allen Notebooks und wenn man da jetzt einen Fehler

fixt, dann ist der halt

in allen Notebooks gleichzeitig gefixt

und Minus E installiert man

deswegen, um Änderungen,

wenn man da jetzt eine Änderung macht,

die sofort sichtbar

werden zu lassen. Also ansonsten müsste man

ja eigentlich, wenn man ein Paket

zum Beispiel via PyPI oder so

installiert oder normal installiert sozusagen,

jedes Mal, wenn man was ändert, ein neues Paket bauen

und dann dieses Paket wieder installieren.

Und am besten auch nochmal das Notebook neu starten.

Und das ist natürlich ein bisschen umständlich.

Und wenn man sagt pip install –i,

dann macht das sozusagen keine wirkliche Paketsinstallation,

sondern legt nur einen Link auf das entsprechende Verzeichnis

sozusagen mit nach Side-Packages.

Und wenn sich da irgendwas ändert am Code,

dann ist das halt sofort irgendwie sichtbar.

Und dann kann man das auch für alle einstellen

oder für einige auf Notebook-Seite kann man zum Beispiel sagen,

A-Import statt Import, ein bestimmtes Modul,

dann wird halt die Aktualisierung auch sofort wirksam,

ohne dass man das neu starten muss, was ja auch praktisch ist.

Also man kann das sehr feigengranulär einstellen.

Man will das vielleicht auch nicht für alle Module machen, aber wenn man das richtig eingestellt hat, sozusagen, kann man halt, wenn man jetzt beispielsweise bei einem Code-Teil, der halt in vielen Notebooks verwendet wird, einen Teil ändert, dann ist die Änderung sofort da und bei der nächsten Ausführung einer Zelle hat man halt auch schon den geänderten Code mit ausgeführt und muss da nichts neu installieren, neu starten oder so.

Da kann ich auch jeden nur zu ermutigen,

zu gehen. Also ich habe mich da am Anfang lange

vorgescheut und habe einfach quasi

am Anfang von meinem Notebook einfach immer

mit der Runmagic quasi

in ein anderes Notebook gestartet, wo ich alle diese

Sachen initialisiert habe. Das geht auch.

Aber das muss man halt dann doch, wenn man

in einem anderen Notebook was ändert, immer noch einmal ausführen.

Und so viel

Zauber ist es gar nicht, quasi sich selber

so ein Paket zu erstellen. Vor allem ist es auch ein ganz cooles

Gefühl. Man kann es danach auch wirklich direkt mal weitergeben

und weiterleiten und es

verleitet zu ein bisschen besserer

Ja, Art Software-Code dann auch zu schreiben

an der Stelle. Man kann dann eine ordentliche

IDI dafür vielleicht auch benutzen und

entwickelt dann diese ausgelagerte

Funktionalität vielleicht nicht direkt im Notebook.

Welche IDI benutzt du?

PyCharm, halt ganz klassisch, wie die meisten, glaube ich.

Wir sind beides umgestiegen auf Visual Studio.

Studio Code? Ah ja, okay.

Ich benutze immer noch alles. Also ich benutze

auch immer noch, also vor allen Dingen häufig

eigentlich Wim.

Ich benutze auch PyCharm und auch VS Code.

Ich hatte das mir auch gezeigt.

Ja, ist schon ziemlich gut, muss man sagen.

Genau. Ich meine, am Anfang ist so ein bisschen

overhead mit dem Anlegen von so einer Klasse da,

aber ihr benutzt, glaube ich, so

Cookie-Cutter-Templates. Ja.

Ich benutze PyScaffold,

was ein Projekt ist, was von Kollegen

von mir entwickelt wird, was mir da sehr geholfen

hat, einfach am Anfang quasi so

Scaffolding, mir

mein Gerüst einmal aufzusetzen, da kenne ich mich

dann direkt drin aus und dann dränge ich dann noch meine zwei, drei

Zeilen ein und ja, bin gleich

da und das hat mir so ein bisschen

die Angst davor genommen, eigene Pakete

an der Stelle zu schreiben.

Ja, genau.

Gut, und dann

können wir letztendlich wirklich unser

Notebook starten.

Du benutzt noch Jupyter

Notebooks. Ja, stimmt.

Magst du JupyterLab lieber, also

warum magst du kein JupyterLab?

Doch, stimmt, mag ich auch.

Das ist jetzt auch nur so reine Gewohnheit eigentlich.

Aber ja, eigentlich im Grunde

müsste ich auch mal auf JupyterLab umsteigen.

Ja.

Genau, also gerade die neuen Versionen mit den Plugins

finde ich, es kommt, also am Anfang

haben wir noch ein paar Funktionalitäten von JupyterNotebooks

gefehlt, aber jetzt

gerade mit dem sich ausbreitenden

Plugin-System gibt es da echt coole

Sachen, zum Beispiel, was ich total liebe

gerade, ist halt die Sublime Keybinding

Magic-Funktionalität, die man jetzt einfach

sich so in die JupyterLab

Notebooks reinladen kann.

Und so. Aber genau.

Ja, ja, ja, nee,

das, genau, das hatte ich auch, habe ich auch schon lange vor.

Ich habe es halt bisher nur immer ausprobiert, aber noch nicht

wirklich verwendet.

Und genau, ja, nee, sieht sehr, sehr gut aus.

JupyterLab ist, ja.

Genau.

So, egal, ob ihr jetzt ein

Jupyter Notebook oder ein ehemaliger,

ja, egal, ob ihr jetzt ein Jupyter

Notebook oder halt schon JupyterLab gestartet

habt, müsstet ihr jetzt quasi

eine Reihe an

Ordnern sehen und

im DS-Tutorial,

nee, im

Ordner Notebooks gibt es halt eben

das Projekt Text Classification

und dem wollen wir uns mal ein bisschen widmen.

Genau. Ja,

vielleicht kann man einfach direkt mal das

Explorer Data Notebook aufmachen.

Das ist

das Dataset, also

ist man natürlich auch mal ein bisschen darauf angewiesen, dass es

halt irgendein frei verfügbares

Dataset gibt, das ich

da verwendet habe, ist

Reuters

21578

Textklassifikations

Dataset, das ist so ein klassisches Ding,

wo

irgendwie eben entsprechend viele

21578

so Ticker

Meldungen drin sind

und die sind halt klassifiziert

in

unterschiedliche Kategorien und

bei dem Set geht es auch

im Grunde darum, Modelle zu

bauen oder das benutzt man eigentlich mal

als Trainingsdatum

für

Textklassifikationsmodelle,

weil man halt dann damit vorhersagen kann,

versucht zu vorhersagen, wenn man jetzt

eine neue Tickermeldung reinbekommt, welche Kategorie ist

das? Also es ist im Grunde so ähnlich wie das

Spam-Klassifikationsbeispiel

von eben, nur dass man halt nicht

nur zwischen Spam und Nicht-Spam unterscheiden

können will, sondern halt zwischen

allen Kategorien, in denen halt

so eine Tickermeldung liegen kann

beziehungsweise auch noch ein Unterschied ist,

es ist nicht, man würde,

das wäre jetzt Multiclass, wenn es nur eine gäbe,

aber das ist eigentlich ein Multilabel

Dataset, das heißt, man möchte

alle Kategorien, in denen so

eine Ticker-Meldung

drin liegt, rausfinden.

Also vielleicht halt auch, es gibt welche,

die halt, wo es

nicht nur um Politik geht oder Sport, sondern auch

Sport und Politik oder sowas.

Genau.

Das Erste, was man, finde ich, bei so einem Datascience-Projekt

ja am Anfang immer machen muss, vor

lauter Tools und Frameworks und sonst was.

Das Wichtigste sind immer noch die Daten.

Und wenn die Daten nicht passen, dann hilft es nicht.

Und da muss man sich halt echt erstmal reinknien

und richtig verstehen, was haben wir denn da überhaupt alles.

Und

ich weiß nicht, da gibt es so ein paar Befehle, die ich immer

als erstes so benutze. Also ich lad

mir mein Dataset irgendwie

in Pandas DataFrame rein.

Und

dann nutze ich darauf erstmal

meist ein Head, um einfach mal zu gucken, was

habe ich überhaupt drin. Dann

D-Types, um mir anzugucken,

okay, welche Spalten haben denn hier

welchen Typ? Und danach

mache ich dann eben einen Describe,

was mir dann für alle numerischen

Spalten da drin schon mal so ein bisschen

eine erste Übersichtsstatistik gibt.

Also irgendwie, wie viele Einträge habe ich?

Was ist der Mittelwert?

Was sind quasi die Maximalwerte?

Und so weiter. Machst du das ähnlich?

Oder wie gehst du? Ja, ja, doch, durchaus.

Also ich habe das jetzt auch hier

gerade nochmal ausgeführt.

Genau, ja, also wenn man jetzt zum Beispiel einige der ersten Zeilen ausgeführt hat, dann hat man hier auch eben ein Data-Frame, in dem all die Dokumente halt drin sind und wenn man DF-Head macht, dann sieht man halt eine Spalte Mod-Update, das ist halt sozusagen so der klassische Split in Trainings- und Testdaten.

Das ist halt auch ganz praktisch bei dem Dataset, dass man das nicht selber machen muss, weil das ist halt auch noch, eigentlich müsste man dann irgendwie erklären, was Cross-Validation ist und wie man K-Fault-Cross-Validation, hier ist das schon fertig.

Da muss man sich dann keine Gedanken mehr drum machen,

sozusagen. Das ist vielleicht ganz gut.

Dann gibt es eine Spalte mit den

Kategorien drin. Das ist dann einfach nur eine Liste der

Kategorien,

in denen halt diese

Meldung halt drin ist.

Und genau, das Ganze nochmal

sozusagen nicht als

Textkategorie, sondern eben

numerisches Label, weil

wenn man später das an irgendwelche Modelle

verfüttert, dann brauchen die das halt als

ja, als

Zahl und am besten auch

als Zahlen, die halt keine Lücken haben.

Sonst geht das halt nicht gut, weil man

das halt, One-Hot-Encoded

nimmt man das sozusagen, hinterher kriegt

halt jedes Label eine eigene

Spalte und das geht eigentlich natürlich nur dann

gut, wenn das halt irgendwie keine Lücken hat.

Ja, dann gibt es da irgendwie

noch ein Datum, was da dran ist,

einen Titel, irgendeine komische

Dateline, ich weiß jetzt gar nicht genau, was das ist und ein Body

von dem Artikel,

dann noch eine ID und

ich glaube, das habe ich irgendwie mal dran gebastelt,

einfach nur um,

weil die Idee war halt,

dass in dieser

Machine Learning-Schulung

man

ja, als Übung sozusagen

vielleicht ein paar neue Features dazu tun sollte,

um zu gucken, ob das irgendwie die

mit, ob das den Score irgendwie

verbessert, der Modelle. Und da war

halt so ein erstes Beispiel, man könnte einfach mal

den Wochentag reinschreiben, der

an dem das irgendwie erschienen ist

und vielleicht steckt da ja irgendwelche Informationen drin.

ja genau, DF-Info

Wenn ihr irgendwie wissen wollt, wie man

mit diesen Data-Frame-Operationen noch

ein bisschen besser einen Einstieg findet, da gibt es ein ganz spannendes

Buch von Jake Wanderplast zu

Data Science mit Python, das hat er

auch frei auf seinem GitHub-Account

veröffentlicht und auf einer Webseite

findet ihr irgendwie, da kann man auch mit

Dupade der Notebooks das tatsächlich auch mal live noch an anderen

Datensätzen üben, also gerade für Pandas

Einführung ist da nochmal ein großes Kapitel

Ja, also die Pandas-Dokumentation

ist auch ziemlich gut, die ist halt nur etwas

länglich und trocken, aber ansonsten ist sie auch super

zu empfehlen.

Und ja, ich finde

die Modern Pandas

Blogartikel-Serie von Tom Augsburger

auch super.

Was ich ansonsten immer noch ganz gerne

mache, wenn ich am Anfang so ein Dataset habe, es gibt

eine Library, die nennt sich Pandas Profiling.

Der wirft so einfach so ein DataFrame rein

und die generiert dir daraus so einen

kleinen HTML-Report,

worin man dann quasi so ein paar

Summary-Statistiken nochmal ein bisschen hübscher aufbereiten

bekommt. Das sieht ja auch super aus.

Wie viele Zeilen hast du, wie viele

Spalten natürlich. Aber dann schaut die halt eben

auch quasi, wie viel Prozent der Daten sind jetzt

halt irgendwie fehlen, sind Nullwerte.

Du kriegst

eine Übersicht quasi, welche Typen

hat das Ganze und der sucht auch quasi

nach Korrelationen in den Daten. Also wenn du jetzt

zwei Spalten hast, wo du eben zum Beispiel

schon so ein Feature Engineering gemacht hast und

hast, keine Ahnung,

den Tag und dann nochmal

irgendwie den Tag um ein Jahr

verschoben oder so, dann korrelieren diese

beiden Spalten ja komplett, sowas würdest du dann

da drin direkt sehen und der würde dich zum Beispiel

vorwarnen.

Ja, das wäre ganz praktisch, wenn man die cleanen muss, dann irgendwie

erstmal so zu gucken, ah ja, das könnte ja ein Problem

sein, dann fangen wir doch mal an da oder so.

Genau.

Genau, das ist immer irgendwie, finde ich, ganz praktisch,

um so einen ersten

Übersicht zu bekommen.

Was würdet ihr dann machen? Würdet ihr dann die Daten, die dann da

zum Beispiel fehlen, irgendwie versuchen zu füllen?

Oder lässt man dann einfach

erstmal die Spalten weg, weil die irgendwie Quatsch sind?

Ja.

Kommt halt komplett drauf an.

Ja.

Also, was du jetzt ansprichst,

ist ja Ausreißerbereinigung im Wesentlichen

und Nullwerte füllen.

Die Frage ist, warum fehlen die Werte

und kannst du sie sinnvoll ersetzen?

Also, im Endeffekt hat man drei Optionen.

Man wirft die Daten einfach weg.

Man versucht sie zu füllen

mit einem Art von statistischem Maß,

was quasi zum Beispiel den Durchschnitt

von allen Spalten wiedergibt.

Oder, vielleicht habe ich ja nur die beiden Optionen.

Ich dachte, ich hätte nur eine dritte.

Ja, man könnte ja irgendwie.

Es gibt diverse, also man kann auch bei,

also es gibt dann Cyclic Learn zum Beispiel,

das ist so eine Bibliothek für Maschinen und Geschichten,

diverse, unterschiedliche, also da ist die Oberklasse quasi

für all diese Verfahren im Pewter

und man kann halt diverse unterschiedliche benutzen,

um eine Strategie dafür zu haben,

weil eben, es kommt halt darauf an,

wofür man die, was der Grund dafür ist,

warum das fehlt und wie man das am besten ausgleicht.

die dann sozusagen da irgendwas reinschreiben

oder irgendwas mit den Daten machen, ja.

Ja, die Frage ist halt, ob man die rausrechnen kann,

die Daten oder nicht, also ob das sinnvoll ist

und was man halt mit der Spalte sonst macht

oder mit den Datensätzen, die fehlen oder Korrelationen,

ob man da einen Dummy reinsetzt, weil man den noch irgendwie braucht

und dann immer merkt, oh, das ist das bei dem Dummy so.

Ja, und auch, wie rum droppst du sie, wenn du sie droppst?

Also schmeißt du die Zeilen raus oder schmeißt du die Spalten raus?

Hängt halt immer von dem Tast ab.

Ja, aber das sieht man genau gerade.

man hat ja irgendwie die Warnings gesehen, wie viel irgendwie

das ganz viele aus einer Teile oder

Spalte dann da fehlen oder so bei irgendwelchen Einträgen.

War bei den Warnings irgendwie mit dabei. Wie hieß das nochmal?

Ich hab das... Pandas Profiling.

Profiling, okay. Genau. Interessant.

Muss auf jeden Fall auch in die Shownotes.

Mach ich.

Ja, genau.

Also, hängt halt

dann immer auch von den Operationen ab,

die man halt danach drauf irgendwie anwenden möchte.

Genau. Ansonsten ist, glaube ich,

so eine gute Möglichkeit, am Anfang

sich auch nochmal so ein bisschen einfach erstmal zu plotten.

Also irgendwie diese statistischen Maße

sind immer irgendwie ganz nett, um

ein erstes Gefühl zu bekommen, wie groß ist

denn meine Spanne an Werten und so weiter.

Aber

da können halt einzelne Ausreißer das Ganze

eben ja komplett verziehen.

Oder ich habe zum Beispiel so einen leichten Shift

in den Daten, sowas in Kennzahlen zu erfassen

geht zwar, aber ist irgendwie immer nicht ganz so

eingängig. Und dann hilft halt meist

erstmal irgendwie so ein Histogramm oder so.

Ja, genau. Würde ich auch sagen,

dass

Das ist das nützlichste Ding, wenn man so ein bisschen sehen will, wie das eigentlich verteilt ist.

Oft ist es halt, sich ein Histogramm von der Werte anzugucken.

Vor allen Dingen auch, wenn man jetzt unterschiedliche Klassen hat, einfach mal die Histogramme gegeneinander zu plotten.

Das ist etwas, was ich mir oft angucke, um zu sehen, ob das irgendwas ist, wo interessante Informationen für Klassifikationen oder so drinsteht.

dass man halt sagt so, okay, man plottet

das Histogramm der einen Klasse gegen das der anderen

und man halt sieht, okay, da gibt es einen großen Unterschied, dann ist

schon mal, oder auch selbst ein kleiner

Unterschied ist natürlich schon hilfreich irgendwie.

Wenn man sieht, die sind genau gleich verteilt, dann ist das natürlich doof.

Aber genau.

Genau, in dem

Explore-Data-Monbook sieht man auch ganz unten

eben, finde ich, ein ganz klassisches, aber

sehr, sehr hilfreiches Diagramm an der Stelle,

wo du einfach mal so die

Länge der Texte

abgetragen hast, den Zeichen,

und da sieht man auch so ein ganz typisches Verhalten.

Man hat halt irgendwie so einen Peak der Daten, der relativ am Anfang liegt. Also irgendwie, wir haben ja jetzt, würde ich sagen, wahrscheinlich mal 80 Prozent irgendwie im Bereich von 0 bis 600 Zeichen oder bis 750, glaube ich, sind das. Und dann wird es weniger und dann gibt es so einen Longtail hinten mit so ein paar einzelnen Einträgen, die dann halt irgendwie 3.000, 4.000, 5.000, 6.000 plus Einträge haben.

Irgendwann hat ja jemand sein Buch bei Reuters hochgeladen, oder?

Ja, genau. Aber das ist so ein ganz klassisches Problem, was man halt im echten Welt-Data-Science halt immer hat, dass es halt irgendwie so Ausreißer gibt, die die Degagramme verzerren und die dann auch immer den Aufwand beim Programmieren eigentlich bedeuten, weil das dann immer die Fälle sind, an die man vielleicht so nicht gedacht hat.

Ja, genau. Ja, wir sehen hier, dass es halt so irgendwie ungefähr 10.000 Dinge gibt, die irgendwie Test oder Training zugeordnet sind. Also dieser Mod-Up-Split teilt diese Ticker-Meldung halt in die, auf denen man trainieren kann und die sozusagen, die man hinterher benutzt, um zu evaluieren, wie gut denn jetzt die Modelle funktioniert haben.

es gibt 119 Klassen, aber

tatsächlich sind es

deutlich weniger, wenn man jetzt

alle

Also gibt es so

Meta-Superklassen quasi, die bestimmte Dinge

beinhalten, sowas wie Sport und dann gibt es

Unterkategorien, Fußball, Hockey.

Es gibt einige, die deutlich häufiger sind,

aber es ist halt so, dass

wenn man jetzt alle rausnimmt,

auch alle Beispiele rausnimmt,

alle Kategorien rausnimmt, zu denen es nicht mindestens

ein Trainings- und ein Testbeispiel

gibt, weil das ist ja auch irgendwie so ein bisschen sinnlos.

Also Sachen, die man nicht gesehen hat, kann man auch schlecht vorhersagen.

Dann sind es

nochmal deutlich weniger, sind es irgendwie nur 90 Kategorien,

die übrig bleiben, glaube ich, und halt irgendwie

Vielleicht sind die Kategorien herausgefallen, so Donziges oder so.

Ja, ich weiß

es gar nicht genau. Ich habe es mir auch nicht

angeguckt, was das genau für Kategorien sind, aber

ja, also

das sind tatsächlich die Zahlen für alle, aber

in Wirklichkeit

ist es halt nochmal ein bisschen weniger.

Also die dann hinterher tatsächlich

zum Trainieren verwendet werden, dann

eben durchschnittliche Anzahl

von Wörtern ist halt irgendwie auch so 90

und

genau, die

also es gibt so eine Quote

Anzahl der Beispiele,

also das ist sozusagen Anzahl der Zeilen im DataFrame

geteilt durch die Anzahl der Wörter

pro

Tickermeldung, ist halt auch

eine ganz

interessante Zahl, die man später benutzen kann,

um halt irgendwie rauszukriegen,

welche Art von Modell da irgendwie besser

funktionieren könnte.

Ja,

genau, also überhaupt diese ganze,

also das ist halt irgendwie explorative Phase

irgendwie bei so einem Projekt.

Man versucht halt rauszukriegen, gibt es

irgendwelche interessanten Regelmäßigkeiten,

wie groß sind die Daten,

was prinzipiell kann ich da eigentlich

für Modelle verwenden und so.

Also erstmal visualisieren ist glaube ich tatsächlich

die beste Idee. Auch verschiedene Arten, mal gucken,

Wordcloud bauen vielleicht oder so und dann

schauen, was ist das denn.

Und nebenher finde ich durchaus irgendwie nochmal so ein Scratchpad

offen haben und wenn man da irgendwie eine

Auffälligkeit hat, die immer gleich

reinschreiben. Also man verfällt dann

finde ich auch relativ leicht in so einem

Liebe zu Charts, weil

so Charts basteln ist was, was ich

zum Beispiel total gerne mache. Also ich finde es

total spannend, dann mir die Daten

irgendwie so in Diagrammen zu visualisieren

und die irgendwie hübsch zu machen und mächtig

von ihrer Aussagekraft und so weiter, aber

dabei verfalle ich da manchmal

so ein bisschen in der Liebe zum Tun

und eigentlich geht es ja darum

Insights zu generieren. Deswegen

finde ich es dann immer relativ wichtig, sich irgendwo

nochmal so eine Liste runterzuschreiben mit den Auffälligkeiten,

wo man so gedacht hat, ah ja, stimmt,

das ist ja interessant und das ist interessant,

weil im Endeffekt sind das nachher dann Sachen,

aus denen man dann Ideen bekommt,

um zum Beispiel Features zu generieren,

die dann eben meinem Modell wirklich

weiterhelfen könnten.

Ja, also das ist halt an der Stelle auch definitiv

dann ein iterativer Prozess,

wo man quasi

sich die Daten anschaut, man entwickelt

eine Idee dafür, man probiert sie aus und

Man geht dann wieder zurück und guckt sich mal wieder die Daten an und guckt, ah ja, jetzt habe ich aber ja ein besseres Verständnis dafür bekommen, weil ja, da ist so viel Information in so einem Datensystem, dass es eine ganze Zeit lang braucht, bis man wirklich versteht, was man damit alles machen könnte.

Da muss man sich natürlich auch immer das Problem erstmal so ein bisschen reindenken, damit man irgendwie dann mit den Daten überhaupt was anfangen kann.

Ja, genau und ja.

Dabei hilft halt diese explorative Sache.

Und ja,

neben diesem ganzen Histogramm, ich glaube,

wir haben angefangen erstmal mit, wie man die Daten noch bekommt.

Damit waren wir noch gar nicht so durch.

Achso, richtig. Ja, stimmt.

Wir sollten irgendwie noch so die Art und Weise der Methode,

wir haben jetzt irgendwie das Describe von DataFrames

ein bisschen gemacht, aber wie bekomme ich denn die Daten

überhaupt irgendwie so rein? Das ist ein guter Punkt, ja.

Ja, also

das ist irgendwie eine

URL, die da irgendwo

mit drin steht. Moment, ich glaube,

das ist jetzt mittlerweile gut versteckt irgendwie

in dem

DS-Tutorial-Paket

Datasets, da gibt es so ein

Pfeil. Genau, normalerweise in der echten Welt

würde ich sagen, ist der Pfeil meist, entweder

habe ich den CSV irgendwo rübergeworfen bekommen,

dann lese ich die einfach über Pandas ein, oder

ich habe halt irgendwie für ein Spielprojekt

eine Web-URL, dann ziehe ich es mir direkt

von dort. Kann man ja

direkt auch mit Pandas, glaube ich.

Oder eigene Webdaten-Scrapes mit einer eigenen Datenbank oder

sowas. Oder von irgendwelchen Sendoren,

die Sachen in irgendeine Datenbank packen.

Eine Datenbank-Anbindung ist natürlich auch ein guter Punkt,

definitiv. Ist irgendwie in der

echten Welt gefühlt zu selten bei so

Notebooks. Irgendwie landen die Dateien dann doch immer

als Datei da, aber

genau, in dem Fall ist es ja relativ

tief im Code direkt versteckt, wie du es lädst.

Also wenn die Dateien da laden,

also wirklich big ist die Datei dann aber irgendwie noch nicht.

Nee, das hier ist alles

super, super small.

Man will in so einem Notebook auch kein Big Data

haben. Kann man

schon, aber... Kann man schon,

aber ich weiß nicht,

Also meine Präferenz an der Stelle ist

vor allem immer erstmal auch Latenz niedrig zu halten

und schnell mit Daten zu iterieren

und lieber erstmal ein kleines Sample ziehen

und erstmal viel Zeit mit diesem kleinen Sample

zu verbringen und dann

natürlich sehr bewusst wählen,

wie wähle ich jetzt mein Sample? Mache ich es wirklich

komplett random oder habe ich eine Zeitreihe? Muss ich jetzt gewisse

Aspekte dabei berücksichtigen?

Aber erstmal darauf eine Weile iterieren

und dann sich nachher

die Modelle auf dem Kompletten ausprobieren.

Machst du das anders?

Nee, nee, also genau. Subsamplen

ist halt auch, wenn die Daten groß sind, auf jeden Fall

eine super Strategie, um halt

schnell integrieren zu können.

Man kann aber, wenn man jetzt

tatsächlich irgendwie

größere Daten hat

und das auch nicht irgendwie vielleicht

kleiner machen will,

sich zum Beispiel von, dann importiert

man sich halt ein DataFrame nicht direkt von Pandas

sozusagen, sondern man importiert das halt von

Dask und

das Ding

verteilt dann automatisch

irgendwie die Sachen, die man da drauf tut, halt auf

zum Beispiel, das ist schon

ziemlich cool, das hat eine Anbindung an

Kubernetes und halt auch an die ganzen

Cloud-Geschichten wie so

Google Computer Engine und so

und da kann man dann halt einfach sagen,

okay, ich nehme mir jetzt mal so hier 100 Maschinen

und füge die dann

hinzu und man kann auch

während Sachen da drauf laufen, also

während man auf einem DataFrame halt irgendwas

gruppiert oder so, kann man sagen, okay, ach,

das geht mir zu langsam, nochmal 10 Maschinen dazu oder so

und dann wird das

automatisch halt irgendwie,

werden die mit reingenommen und

werden die Sachen halt irgendwie magisch schneller

und man sieht halt auch irgendwie sehr schön,

was da passiert.

Habe ich jetzt normalerweise kein Beispiel für, aber

das geht

durchaus auch und das

Benutzerinterface ist sozusagen da auch nicht anders,

als wenn man das jetzt auf einer lokalen Maschine macht,

sondern ist auch immer ein Notebook eigentlich.

Ich glaube, zu diesem Big-Data-Ding

müssen wir nochmal eine eigene Folge machen, so mit

Kubernetes, das ist ja nochmal spannend.

Genau, an der Stelle kann ich mal meine

Kubernetes-Folge droppen.

Ja, genau. Es gibt eine zu Docker

und eine zu Kubernetes.

Ja, und das Schöne ist halt,

dass die Sachen dann auch, wenn man sie nicht mehr braucht, wieder verschwinden.

Während halt, das ist ja auch etwas, was man sonst,

also gibt es dann vielleicht auch irgendwie,

in vielen Firmen gibt es dann halt so ein Cluster,

wo man Sachen machen kann, aber die Maschinen sind dann halt da

und man braucht

sie aber irgendwie nur, irgendwie, man braucht

eigentlich so alle halbe Stunde mal so wirklich volle Power

und, aber ansonsten braucht man das eigentlich nicht.

Und,

ja, das ist

glaube ich auch irgendwie, also das ist schon ein sehr

gutes Argument für diese ganzen Cloud-Geschichten,

weil man zahlt halt tatsächlich nur in dem

Moment, wo man halt die Rechenzeit

braucht.

Also du hast Dasks jetzt auch schon öfter

eingesetzt und das funktioniert für dich gut? Ja,

für mich funktioniert das eigentlich ziemlich gut. Ich habe damit nämlich praktisch

so noch keine Erfahrung. Ich habe nur irgendwie

im Hinterkopf, dass man dafür einiges umschreiben

muss, dass das nicht komplett kompatibel ist mit den Pandas.

Nicht komplett, aber also

das meiste geht eigentlich schon.

Es gibt also ein paar, ja natürlich,

es gibt natürlich immer so ein paar Ecken,

Ja, intern ist es halt so, dass der das auf eine Menge

Data Frames aufteilt und das

muss man halt irgendwie, die unterschiedlichen

Teile liegen halt auf unterschiedlichen Rechnern und

ja. Ansonsten, wenn man

Pandas einfach nur Multicore

betreiben möchte, was ja Pandas

per Default jetzt aktuell noch nicht bietet,

gibt es auch ein paar nette Projekte. Da gibt es

einmal Modin, das ehemalige

Pandas on Ray,

was quasi einfach über einen Import

einfach nur,

du änderst den Import und dann kannst du prinzipiell

Multicore für die allermeisten

Pandas-Operationen.

Wenn du sehr in die Nische kommst, geht's

da vielleicht dann irgendwann nicht mehr. Und was ich

heute kennengelernt habe und noch nicht ausprobiert habe, ist

Pandarallel.

Also so wie Panda

und dann Parallel

quasi. Und das unterstützt

halt eben auch quasi oder verspricht ein Multicore-Processing

für Pandas-Operationen.

Genau. Also bevor man vielleicht

wirklich auf den Cluster muss, ist das

noch eine gute Option.

Ja.

Ja, ja, ja.

Nee, das kann ich auch noch nicht. Also, ja.

Das ist interessant.

Genau, aber wir waren hier bei dem...

Wie bekomme ich eigentlich meine Daten?

Ich hatte einfach das entsprechende Notpunkt nicht aufgemacht.

Das heißt hier

Preparing Data.

Und das ist einfach

das Ding, also David Lewis,

das ist auch der, der den Mod-Up-Display gemacht hat

und auch überhaupt der, der das ganze Dataset

kuratiert hat, hat das halt irgendwie auf seiner

Seite liegen. Und

genau, dann

ja.

Was du auch benutzt an der Stelle im Notebook

ist ja die

die Path Library.

Ja.

Habe ich auch noch nicht so lange in Benutzung, aber ist eigentlich

mega cool. Ja, genau. Sag dazu doch nochmal zwei Sätze.

Ja, also

früher habe ich das auch mal mit

OS und ListDir und

OS Path Join und so gemacht, aber das ist alles

ganz schön, genau, glaube

ganz schön umständlich und

da

gibt es halt, ich weiß gar nicht,

seit wann das in der Standard-Library ist, aber

also es gibt da

ein Modul namens Parslip

und

da kann man

also

es geht hier los mit Pars.home

ist halt sozusagen dann ein Pfad

und das Ding

funktioniert im Grunde, wenn man jetzt Pfade erweitern möchte

oder so über so Operator

Overloading und

die haben dann halt einfach das

den Slash überladen und jetzt kann man

halt schreiben, irgendwie pass.home

gibt einem das Home-Verzeichnis, Slash

Data Slash TMP

und das ist natürlich viel kürzer, als würde man jetzt

schreiben, OS Pass Join

Klammer auf und dann gibt man eine Liste

oder macht irgendwie, ja irgendwie

muss dann einen absoluten Pfad angeben

oder man gibt irgendwie einen relativen Ankommer

irgendwie das nächste Ding und

das ist alles ganz schrecklich. Man kann sehr

schön Variablen quasi mit rein

betten und

man bekommt ja am Ende dann auch immer quasi ein Path-Objekt

wieder raus, was dann auch nochmal so

Operationen bietet, wie

okay, jetzt verrat mir von dem noch bitte die

Subdirectories oder

ja, halt Operationen dann immer direkt

auf dem Pfad ausführen. Ja, du kannst einfach

.exist machen oder sowas, das wäre auch ziemlich cool.

Genau. Ja, und ansonsten

hätte man immer os-path-exist und so verwenden

müssen und dann, also das ist

wirklich viel, viel angenehmer

damit zu arbeiten und

ja, also sonst hat man immer so, also ich hatte sonst

immer das Problem, dass irgendwie diese ganzen

Geschichten wurden immer relativ festlich und auch die

Zeilen wurden sehr lang und das Problem ist

irgendwie weg, seitdem ich Parslip verwende und das

ist schon mal echt ein Vorteil. Vielleicht um das

zu kurz zu zeigen, ich lösche jetzt einfach mal die Daten,

die ich hier bei mir lokal habe.

Data,

TMP.

Ja, genau.

Muss man echt mit aufpassen.

Ja, ja. Ja, wenn du willst so ein Git-Repo

löschen oder so, machst dann irgendwie Punkt-Slash

oder so und dann immer aus Versehen löscht man den Punkt

weg, dann machst du r-r-slash

und dann

ja, dann

immer alles als Super-User machen. Muss man hoffen,

dass nicht nur das Backup immer funktioniert hat,

sondern dass das Restore auch mal funktioniert

ist.

Ja, genau.

Ja, ich verwende

hier einfach so irgendwie

so Download-from-URL

Funktion, die benutzt

tqdm, um

das ist eine sehr schöne Library, mit der man

halt so Progress-Bars ganz gut hinkriegt.

Man kann eigentlich alle Iteratoren irgendwie damit rappen.

Ja, man braucht nur ein Iterat-Bar und genau.

Und das ist

auch sehr, sehr hübsch. Dann sieht man ungefähr, wo man ist.

Und ja,

jetzt hat das

irgendwie dieses Dataset halt irgendwie

in so ein Data-Verzeichnis geschrieben.

Dann, das ist halt auch irgendwie das

Tolle bei Python, dass man irgendwie einen Riesenhaufen

Funktionalität schon in der Standard-Library

mit drin hat. Ist eben auch

sowas drin wie tar-File, dass man halt

mit tar

Archiven halt direkt irgendwie umgehen

kann und dem kann man dann halt

einfach sagen, okay, pack doch mal alles aus

und

ja, dann

Dann haben wir einen Pickel gebaut oder du hast einen Pickel gebaut?

Genau, dann parse ich das Ganze auf und

pickel das wieder raus sozusagen,

damit ich dieses Parsen nicht jedes Mal machen muss. An der Stelle

hier ist es relativ egal, weil das ist so schnell.

Also Pickel speichert einfach das Python-Objekt in der

Binary einfach, also als Binärdaten

auf der Platte in einem Objekt und kann es genauso wieder einlesen.

Pickel ist auch ein Modul aus der Standard-

Bibliothek, genau, und es serialisiert

einfach Python-Objekte, beliebige

Python-Objekte einfach auf, ja, in ein

Format, das man dann halt auf die Platte schreiben

kann und hinterher auch wieder lesen kann.

Und es ist halt relativ schnell. Also

CSV, genau, ist oft

das, was man bekommt und das, was am

meisten verwendet wird und, ja,

Pandas Reals CSV-Funktion ist sicherlich so

eine der wichtigsten.

Aber das ist halt nicht schnell,

sondern das ist halt irgendwie so,

ja, sagen wir mal,

weiß ich nicht, vielleicht 50 MB

pro Sekunde oder so, was da so durchgeht,

kommt darauf an, wie komplex das CSV ist.

Und gut, für die meisten Datensätze

ist das vielleicht auch, oder was die meisten Leute so haben,

auch schnell genug, dass das halt irgendwie

nicht so furchtbar merkbare

Wartezeiten erzeugt, aber

wenn man jetzt so ein paar Gigabyte einlesen

will, dann ist das schon, dann muss man bei CSV schon

immer warten. Und was

ich da oft auch mache, ist halt die, wenn ich

CSVs habe, die

zuerst irgendwie in DataFrame einzulesen

mit ReadCSV und dann halt nochmal

irgendwie einen Pickle-File davon zu cachen.

weil das Pickel liest halt quasi mit Plattengeschwindigkeit, also da kann man auch so einen Gigabyte pro Sekunde lesen, dann dauert das halt, wenn man halt so einen Data-Frame, der halt irgendwie zwei, drei Gigabyte groß ist, liest, den man auf der Platte gepickelt hat, das dauert dann halt irgendwie auch nur so ein, zwei Sekunden und nicht mehr irgendwie anderthalb Minuten, wenn man das per CSV machen würde und ja, das ist halt auch ganz praktisch.

natürlich trotzdem Sinn, dass man irgendwie

eine CSV nimmt zum Teilen, weil

in so einem Pickel kann halt eben alles dran sein.

Das ist halt ein Binary-File und

dementsprechend wahrscheinlich nicht das Beste, um es irgendwie

im Internet als Austauschformat zu benutzen.

Das ist auf jeden Fall ein Sicherheitsrisiko,

weil wenn du da irgendwelche Sachen reinlädst

und da habe ich dann mein Code reingeschrieben.

Also wenn man das für einen eigenen Cache benutzt, ist es

okay, weil das zieht ja sonst keiner, aber stimmt.

So verteilen soll. Es gibt natürlich auch

Formate, die dafür gedacht sind, dass man irgendwie

da größere Datenmengen drin hat

und das halt auch

irgendwie teilt.

Ja, HDF5

oder NET,

wie heißt denn das noch, Nachfolger davon?

Keine Ahnung.

Oder halt eben sowas wie Parquet-Files

oder so. Aber

genau, CSV ist wahrscheinlich immer noch das

üblichste.

Ja, genau, ich habe das jetzt einfach

nochmal so gemacht, um das zu demonstrieren, wie das geht.

In dem Fall ist es halt völlig überflüssig, weil

eigentlich sind das so wenig Daten.

Das merkt man gar nicht.

Und dann hat man halt sozusagen die

Daten in einem Format, dass man

damit irgendwie arbeiten kann.

Ja, das können wir describen und reingucken.