Transcript: Vermischtes über Data Science, Machine Learning und nbdev

Ja, hallo, liebe Hörerinnen und Hörer, willkommen beim Python-Podcast in der 28. Episode heute.

Es ist ein bisschen wieder eine Laber-Folge, und zwar über Machine Learning heute.

Ja, hey Jochen, du bist wieder dabei, hier ist wieder Dominik.

Ja, hallo Dominik.

Und heute ist auch der Christian wieder da.

Christian haben wir auch dabei, ja.

Hey, willkommen.

Danke.

Ja, habt ihr euch schon was genaueres überlegt heute oder wolltet einfach so ein bisschen die Döniges erzählen?

Wir haben heute übrigens, wir wollten es ja irgendwann mal anfangen zu sagen, 4. Februar 2021.

Ja, ich glaube, diesmal wollten wir wieder so ein bisschen Richtung irgendwie Data Science, Machine Learning ein bisschen mehr.

Wir hatten in letzter Zeit immer ganz, ganz viel Web-Entwicklung und so.

Ja, und wegen uns da jetzt mal so ein bisschen, so wirklich das Thema haben wir noch nicht.

Wir haben alle so ein bisschen was mitgebracht, mal schauen.

Ja, wir hatten auch einige Hörerwünsche, was Datentypen zum Beispiel angeht.

Wir wollten auch mal eine Folge machen, wo wir genau diese

Build-in-Implementierung in Python

dazu erklären, aber das wird dann eine

der nächsten Folgen werden.

Was wir euch aber noch mal fragen wollten, wenn ihr

Feedback und Kritik und so habt, wie immer an

hallo.pythonpodcast.de und sagt uns

auch mal, auf welche Themen ihr so besonders Lust hättet.

Dann werden wir die auch noch mal mit

in unsere engere Auswahl nehmen.

Ja,

es gibt was Neues, es gibt eine

möglichen Updates von

Paketen, NumPy, Pandas,

Pandas auch, MyPy,

Nein, Pandas nicht. Doch, Pandas tatsächlich

auch, fällt mir jetzt gerade so ein.

Ich habe es jetzt hier gar nicht aufgeschrieben, aber ja,

gab es jetzt auch letztens irgendwie eine neue,

größere Version 1.2.

Ich bin mir nicht ganz sicher. Aber tatsächlich

auch NumPy hat die größte Release,

also mit den meisten Pull-Requests seit

x Jahren, jetzt mit

1.20 und

ähm, äh, Jupiter Lab

3 ist draußen und

äh, Spacey, äh,

also die ganze Natural Language Processing

Geschichte, Version 3

ist jetzt gerade erschienen mit Support für Transformer.

Also genau, das war mal so das erste, ich hab mir mal

angeguckt, was ist denn alles Neues passiert, weil ich da auch schon lange nicht mehr

drauf geguckt hab und da ist ja in letzter Zeit

einiges, hat sich da...

Falls ihr irgendwie tatsächlich mal den Einstieg finden wollt in NumPy

und oder Pandas oder schon immer mal ein bisschen tiefer

angucken wolltet, es gab einige richtig coole

YouTube-Tutorials, die ich fand, die ich bis jetzt

so die besten nicht kennengelernt hab, von Ben Gorman

dazu und zwar

NumPy for Grandmas und Pandas

for your Grandpa. Okay.

Ja, eine richtig schöne

Einführungsserie

für die beiden Bibliotheken, würde ich sagen,

wo man mal so ein bisschen

schon doch tiefer einkommen kann.

Fand ich super.

Genau, ja.

Genau, weil wir so ein bisschen News machen,

es gab noch ein paar andere

Releases auch, MyPi

kann man dazu was sagen, also ich weiß

nur, das hat jetzt irgendwie Support für 3.9,

Python 3.9,

dann gibt es irgendwie für PIP

gibt es einen neuen Resolver. Ich weiß nicht,

hat sich den irgendjemand schon mal angeguckt,

so ein bisschen?

Ich hatte drüber gelesen

und ihn nochmal auf die

Wiedervorlage gepackt.

Tatsächlich bin ich mit,

was das Resolving angeht,

momentan,

ich bin immer noch an dem anderen Ende,

am Umdoktern, wie ich irgendwie

so einmal zusammengestellte Paketlisten

so fix und fertig

durch die Gegend verteile.

Deswegen hatte ich es wieder zur Seite gelegt, aber

ich merke auch, es hat uns nirgendwo

gebissen zumindest. Es stand ja so ein kleines

Teilchen drauf von, man kann noch

den alten Reserver, glaube ich, aktivieren, wenn

einer der Neue irgendwie Quatsch macht.

Aber

nee, erst mal nicht negativ

aufgefallen.

Ja, nee, ich merke

ab und zu funktioniert das halt irgendwie nicht so richtig

und dann irgendwie meistens

hilft irgendwie das Paket, was Ärger macht,

nochmal auszukommentieren, nochmal wieder alles neu zu installieren

Und dann wieder reinzunehmen, dann geht es irgendwie wieder.

Ja, aber

ich habe es auch eigentlich nicht, also insofern,

es hat nicht wehgetan, insofern

scheint alles halbwegs gut gelaufen

zu sein. Wobei das, was du,

also wenn du das erzählst, ist aber genau so ein Fall

von, ja, nee, das kann ich nicht leiden.

Ja, ja, also

das ist so ein schlechtes Gefühl, wenn ich sowas merke.

Ja, ich

spiele halt ein bisschen rum mit

so einer Form von Logfiles,

dass ich halt ein Environment

beschreiben kann. Ich hatte, glaube ich,

an irgendeiner Stelle ja mal das App-Env

erwähnt gehabt, was

ich benutze, um so

fertiggebackene Virtual-Envs zu erzeugen.

Klingt nach Poetry.

So ein bisschen das Problem

bei Poetry war mir,

das ist zu viel. Das ist einfach

zu viel Kram. Ich brauche irgendwie was ganz

Kleines. Der

wichtigste Teil für mich ist,

wir haben so Projekte,

wo wir ein Repo haben, das

auschecken und dann

bringt das Repo im Prinzip sein Log-File

mit und das konkrete Tool,

was da dran hängt,

bootstrappt sich mit dem Log-File

selber durch ein kleines Bootstrap-Skript,

was in dem Repo drinnen liegt. Also

Bateau ist bei uns das große Werkzeug, was

das benutzt. Und dann hast

du dort ein, dann kann sozusagen jeder, der mit diesem

Projekt arbeitet, das Repo auschecken

und tippt einfach Punkt, Schrägstrich

in dem Fall Bateau oder auch irgendwas anderes.

Du musst gleich nochmal kurz auf

Bateau eingehen, gleich. Ja,

kann ich auch.

Und dieses Skript, was in dem Repository eingecheckt ist, ist nur ein ganz kleines Bootstrap-Skript, so ein Single-File, was auch über mehrere, mindestens so, glaube ich, 3, 4 oder 3, 5 bis hoch zur aktuellsten halt kompatibel ist.

Und der ist ein kleiner Wrapper, dass wenn man ihn aufruft, guckt er, ob ein funktionierendes Virtual-Env für das Log-File oder halt auch das Requirements-Text-File vorhanden ist.

Und wenn ja, dann startet er sozusagen das eigentliche Kommando aus diesem Virtual Env statt sich selber.

So einmal durchgereicht wie so ein Exec.

Und wenn das aber eben nicht der Fall ist oder wenn das Virtual Env kaputt ist

oder wenn sich das Log-File geändert hat oder wenn du deinen Python-Interpreter geändert hast,

dann erkennt er das und macht in dem Moment sofort eine Reinstallation, ohne dass du irgendwas tun musst.

Du rufst einfach wie immer dein Tool auf, um zu sagen, ich will jetzt XY machen.

Und dann sagt der im schlimmsten Fall nur, ja Moment, weil zum Beispiel ein anderer im Projekt hat was committed, weswegen das Log-File sich geändert hat.

Und dann zieht der das sofort gerade.

Und dieses Self-Contained-Ding, es ist auch so, dass du kannst dann halt dieses Tool in sieben Projekten benutzen und jedes Projekt benutzt seine eigene Versionsliste automatisch.

Und du hast nie eine systemweite Installation dieses Tools, sondern das hängt immer konkret an den Projekten dran.

das ist ein Use Case, den habe ich nirgends

wo gefunden, der das so abbildet

und

Poetry hatte ich gesehen und das war aber sozusagen

dafür Poetry zu verwenden, wäre viel zu

aufwendig geworden, um dieses ganze Self-Bootstrapping

irgendwie anzugehen und ich merke da

da habe ich auch häufig

Gedanken und Ideen, wie ich möchte, dass das funktioniert

wo ich gegen andere Tools nicht

mehr ankämpfen möchte, so viel Code

ist es dann nicht, das selber zu bauen, als dass ich dann

einem Riesentool hinterherlaufe, dem man

ständig sagen muss, du ich brauch das aber so oder so

Okay, und vielleicht

das machst du mit Bato, oder

das Tool heißt Bato, oder?

Also dieses Bootstrap-Tool

heißt AppEnv

das ist im Prinzip nur eine

einzige Datei, da gibt es bei uns

auf GitHub, GitHub, Flying Circus

IO, AppEnv

das ist nur eine einzige

Python-Datei, die legt man sich in ein Repo

und wenn in dem Repo

daneben eine Datei liegt, die

Requirements-Text heißt

Dann passiert folgendes, dann benennt man das Skript so wie das eigene Tool.

Das muss nicht Bateau sein, das kann irgendein Python-Package sein,

was ein Konsol-Skript hat, was genauso heißt wie das Skript, was du in deinem Repo ablegst.

Und dann installiert er alles das, was in dem Equipments-Text-File drin steht,

in eine geheime, in Anführungszeichen,

Position, also das heißt dann irgendwie Punkt

dein Tool-Name, Schrägstrich, und dann werden

da so gehäschte Virtual-Envs drin erzeugt

und auch wieder aufgeräumt und ruft

im Prinzip dann bloß Punkt

da aus dem Virtual-Env

bin und dieses Konsol-Skript auf,

viel mehr macht der nicht, und das ist das App-Env,

um so ein Bootstrapping-

Mechanismus da einmal

abzubilden.

Und Bateau ist ein Werkzeug, was das halt

benutzt. Wir haben so Bateau-Projekte, also

Also das ist ein Deployment-Werkzeug, ähnlich zu Ansible und anderen Tools.

Und ein Charakter von dem Ding ist halt, wenn du Bateau-Projekte machst

und wir haben bei uns bei den Mitarbeitern halt gerne das,

die haben 12, 15, 20 so Projekte rumfliegen, die sie jonglieren.

Und jedes davon, eins davon hat ein Kunde halt mal ein Dreivierteljahr nicht angefasst

und das ist jetzt auf einer Bateau-Version von vor anderthalb Jahren oder irgendwas.

Und dann will ich nicht überlegen müssen,

was muss ich tun, um diese Bateau-Version wieder zum Laufen zu kriegen,

weil meine letzten drei Projekte waren in einer anderen Bateau-Version.

Oder ist das Thema halt, nee, du brauchst bloß das Repo nehmen,

rufst .slash Bateau in dem Repo auf

und der zieht sich exakt die Version, die für dieses Projekt gebraucht wird, her

und du kannst dann halt in dutzenden Projekten

halt die Dependencies ordentlich managen,

ohne jemals händisch reingreifen zu müssen.

Das macht ja alles im Self-Bootstrapping

und auch ohne, dass in deinem System was anderes installiert ist, außer Python selber.

Also da sind auch noch so ein paar Hacks drin,

dass wenn du halt kaputte Pythons hast,

wie auf Debian üblich,

also Debian macht halt gerne Setup-Tools und Pip und so kaputt,

und dass die Standard-Library noch nicht mehr geht,

da ist überall so dieses kleine Wissen drin,

von wie ziehe ich mir das in so einem Moment halt alles gerade,

dass ich mich dann aus dem luftleeren Raum,

solange ich irgendwie einen Python habe,

was nicht nur ein bisschen kaputt gemacht wurde,

dass er sich daraus halt bootstrappen kann

und dir dann ein voll funktionierendes Virtual Env

auch zusammenbaut.

Und du musst nie überlegen,

muss ich das Virtual Env jetzt aufräumen

oder nicht, sondern er macht es halt immer, weil er

erkennt, wann das nötig ist.

Das klingt klasse.

Ja.

Ja, ehrlich gesagt, hätte man an der Stelle

schon

eigentlich eine ganz gute Überleitung zu

MBDev.

Also das ist ja so ein Ding, mit dem

spiele ich in letzter Zeit so ein bisschen rum.

weil das

im Grunde auch einen Großteil von

diesen Dingen halt tut.

Probleme lösen, wie man seine MGBung so

einrichtet, dass man damit arbeiten kann, oder?

Ja, wobei es halt auch

sehr weit noch in den Bereich reinragt,

irgendwie, wie kann man

quasi ein Projekt so konfigurieren,

dass hinterher dann auch Pakete für PyPI

rausfallen

und Dokumentation

und

GitHub Actions, wo dann direkt

irgendwie so ein

Continuous-Integration-Zeugs

halt läuft und... Also Jochen,

man hört raus, mag Notebooks, Jupyter-Notebooks.

Ja, also ich

mag die tatsächlich

und das Ding

dreht halt quasi

den Jupyter-Notebook-Level

so auf 11, weil

da schreibt man halt alles in Jupyter-Notebooks

beziehungsweise das ist halt eigentlich

so eine Art IDE und

plus Projektverwaltungs-Dings irgendwie

Und genau, also ist halt quasi so die Antwort auf die Frage, was wäre, wenn ich alles in Notebooks machen wollte? Und dann kommt es ungefähr das dabei raus. Und das hat einige interessante Vorteile. Also es hat auch interessante, also es ist halt auch ein bisschen komisch natürlich, also wenn man jetzt irgendwie eine IDE gewohnt ist oder irgendwie auch nur einen normalen Texteditor, dann kommt einem das alles so ein bisschen eigenartig vor.

Es gibt ja auch so einen sehr populären Talk, ich weiß gar nicht wo, der gehalten, Joel Gruß, der macht auch so einen Data Science Podcast, Adversarial Learning, glaube ich, heißt der und der macht viele YouTube-Videos und der hatte halt so einen Talk gehalten, I don't like Notebooks, der dann oft irgendwie immer rumgeschickt wurde.

Und wo er sagt, ja, ja, das

encouraget irgendwie

einen Haufen sehr schlechte

Software-Entwicklungspraktiken

und macht

die funktionierenden Workflows, die ich habe, halt kaputt

und deswegen, ich finde das alles doof und

nicht deterministisch und

ja, in gewisser Weise hat er da so einen Punkt,

aber man kann da auch

überall um diese ganzen Ecken drum herum

arbeiten und manche Sachen

sind halt auch sehr, sehr cool dabei.

Also das, was

es halt so ein bisschen möglich macht,

ist halt ein Ideal,

dass, ich glaube, Knut

hatte das irgendwann mal

1983 oder so aufgeschrieben, so von

Literate Programming, dass man halt sozusagen

nicht nur Code hinschreibt, sondern halt

Dokumentation und Code oder beziehungsweise was der Code tun soll

halt irgendwie zusammen. Gab es diverse

Versuche, das irgendwie hinzukriegen.

Ich glaube, mit die ersten war

der erste Versuch war Mathematica, aber das ist halt

irgendwie nicht so richtig populär geworden.

Matlab,

R-Studio geht auch in die

Richtung. Und jetzt halt Jupyter Notebooks,

damit würde ich sagen, war es halt so,

hat es in gewisser Weise einen Durchbruch

gehabt und wird jetzt überall verwendet.

Und halt auch JupyterLab nochmal so als komplette

IDE irgendwie dafür.

Und genau,

da gibt es dann halt auf diesen Talk auch eine Antwort

von einem, der sich,

also derjenige, der sich diese

MBDF-Geschichte überlegt hat oder dann halt,

ja, die dann entstanden ist bei der

Entwicklung einer Bibliothek,

das ist Jeremy Howard,

der hat

der hat halt Fast

AI, die

Library, das ist auch so ein Wrapper um PyTorch

im Grunde,

damit geschrieben, auch ein Buch darüber geschrieben,

das ist auch wahrscheinlich so das empfehlenswerteste

Buch über PyTorch ist

und das

Buch ist auch komplett mit MBDev geschrieben

und

das ist halt schon, das hat auch schon so was sehr

sehr cooles und der argumentiert halt, ja,

für mich ist das alles viel einfacher, so einmal

diese ganzen Hässlichkeiten und da muss man leider

sagen, es ist halt, es gibt viele Hässlichkeiten

oder es fällt vielen Leuten

total schwer, irgendwie Projekte ordentlich

aufzusetzen. Das geht halt

alles mehr oder weniger weg, wenn die Leute halt

mit, also es gibt ja so ein Template für

GitHub zum Beispiel, wo man einfach sagen kann, okay, erzeuge

mir so ein MBDev-Projekt oder

man sagt MBDev-New irgendwie, ich weiß

jetzt gar nicht genau, wenn man das Papier installiert

hat, dann erzeugt es einem halt

so eine Projektstruktur, so ähnlich

wie bei Portree, Portree

Init oder so, nur es macht

noch mehr, deutlich mehr.

Und, ja, dann für ihn ist es halt total super, weil die Pull-Requests werden halt besser und er reviewt die Pull-Requests, da gibt es dann auch ein eigenes Tool für, dann direkt in einem Notebook, das halt irgendwo auf Binder oder irgendwie auf Google Colab oder so gestartet wird.

Das heißt, ein Pull-Request kommt rein, er klickt halt auf einen Link, dann geht das halt in einem eigenen Notebook auf, das überhaupt nicht bei ihm läuft, sondern irgendwo in der Cloud. Und dann kann er halt auch direkt sehen, da das halt so ein bisschen Richtung Literate-Programming geht, was hat sich denn geändert? Also wie verändern sich zum Beispiel auch die Visualisierungen von irgendwelchen Dingen?

Das ja ansonsten auch ein Problem wäre,

wenn jemand ein Pull-Request stellt,

jetzt sieht die Visualisierung von irgendeiner Geschichte besser aus.

Ja, da muss man erst mal, okay, die Daten zusammensammeln,

das dann irgendwie ausführen und dann sich das angucken.

Oh, dann wo guckt man sich das an?

Wie generiert man so diese Grafik eigentlich?

Das ist alles ziemlich umständlich.

Und da hat man es halt dann direkt, kann sehen,

okay, ah, sieht besser aus als vorher, super,

Pull-Request akzeptieren, fertig.

Und auch ein schöner Vorteil ist halt,

Tests und so, die sind da auch direkt mit im Notebook.

Bei so klassischer Softwareentwicklung mit einer IDE oder so hast du dann halt schon auch die Tests oft in einem sehr anderen Bereich deines Pakets, als der Code, an dem man gerade schreibt.

Und das ist halt auch immer nicht so richtig, also die liegen halt nicht nah beieinander.

Während wenn man das jetzt in einem Notebook schreibt, dann hat man halt irgendwie den eigentlichen Code, der irgendwas tut.

Und halt noch Dokumentation und Beispiele, wie man es halt ausführt und so drumherum.

Plus die Tests, alle zusammen in einem Notebook.

Und über den Teilen, die halt hinterher in der Library wirklich landen sollen, steht halt noch irgendwie Export in Markdown oben drüber und dann werden die halt in eine Library gepackt. Und der ganze Dokumentationscode nicht, aber der landet dann durchaus noch in der Dokumentation. Und das ist schon sehr nett. Also ich finde es auf jeden Fall einen sehr interessanten Ansatz.

Und ja, also ...

Ist das nicht dann irgendwie so ein ewig langes Endlos-Scrolling

durch irgendwelche Projekte dann durch von Top to Bottom?

Ja gut, du kannst das ja strukturieren.

Natürlich können die Notebooks schon lang werden.

Man kann das ja strukturieren, wie man möchte.

Man kann auch viele Notebooks machen.

Ist auch so, man kann auch Dinge dann in der Library ändern

und die werden dann in die Notebooks zurückgesynct, der Code.

und umgekehrt halt

und das ist so, man muss

wenn Dinge jetzt, wenn

Klassen zum Beispiel sehr groß werden, dann muss man nicht alle

Methoden direkt

an die Klasse dran schreiben, sondern man kann das

dann auch später machen, dann gibt es dann halt Dekoratoren

die dann irgendwie

Funktionen als Methoden wieder an Klassen dran klatschen

dem Code, der da hinterher rausfällt

den sieht man das nicht an, aber im Notebook ist das dann halt schön

übersichtlich, weil die ganzen

Methoden, die die Klasse groß machen, kommen dann

halt erst so nach und nach dazu oder können halt auch in einem anderen

Notebook dazukommen

ja, also

es ist sehr anders, als man normalerweise

so entwickelt, aber ich finde, das ist interessant

und ja, ich meine,

ich muss

mich so ein bisschen zwingen, also ich muss mich manchmal so ein bisschen

zwingen, da immer mal so reinzugucken in solche

Dinge. Ich habe auch zuerst, muss ich

gestehen, Notebooks hielt

ich erst für ziemlich

ein Quatsch und

ich musste erst Leute damit arbeiten sehen, um zu

verstehen, dass das eigentlich eine

ziemlich coole Geschichte ist.

Das war auch relativ spät.

Also ich hatte, ich weiß nicht,

wann ich erfahren habe davon, dass es Notebooks gibt,

aber schon wahrscheinlich relativ früh,

kurz nachdem sie irgendwie da waren.

Und dann aber gesehen, dass es eine coole Geschichte ist,

habe ich erst 2015, Ende 2015 oder so.

Und ja, wenn man es dann halt mal ausprobiert,

dann merkt man doch, oh, für manche Sachen ist das total super.

Ja, und genau, deswegen gucke ich mir das jetzt gerade an

und probiere das halt auch mal aus.

Und das ist halt auch so was,

was der Autor von Imdingen dann in seinem Talk

als Antwort auf diesen I-don't-like-notebooks-Talk

erzählt hat, ja,

also er hat immer, er findet, es funktioniert

immer gut bei Anfängern oder bei sehr, sehr erfahrenen

Leuten. Dazwischen, wenn

die Leute so sich eingegroovt haben auf ihre

Idee oder so, dann, die sind alle

immer sehr skeptisch zuerst,

weil das natürlich auch immer

so eine harte Änderung ist. Ich merke das ja auch,

ich bin eigentlich VI-User

und ich habe jetzt dieses Jahr mich

mehr mit PyCharm beschäftigt,

wie es gut noch nicht so

und das war schon schmerzhaft, also das war

irgendwie nicht, ja, aber muss man

ab und zu wohl mal machen, um einfach mal zu

gucken, wie sind andere Entwicklungsumgebungen denn so.

Vielleicht gibt es ja doch tolle Sachen.

Ja, diesen Wettel haben wir auch bei uns immer ständig.

Also, was ich mich frage, macht ihr gerne

Notebooks? Könnt ihr bestimmt

gerne mal Bescheid, schreibt uns eine E-Mail dazu oder sowas.

Also ich benutze zum Beispiel Notebooks auch

relativ gerne, so zum schnellen

Debuggen oder sowas, wenn ich irgendwie neue

Methoden, neue Funktionen baue, dann schreibe ich

die gerne erstmal im Notebook, zum Beispiel in der Django-Shell

dann auch oder so und probiere es dann direkt aus,

ob es geht und muss halt nicht mehr das

ganze Projekt immer starten und dann irgendwie

den Web-Server hochfahren und dann da die Module

oder die Routen aufrufen, sondern ich sehe halt irgendwie direkt, ob diese

kleinen Teile gehen oder nicht.

Das ersetzt so ein bisschen den Debugger vielleicht an der Stelle

oder so. Finde ich sehr

handlich.

Das verkürzt so ein bisschen den Entwicklungssyklus,

habe ich das Gefühl.

Das ist spannend, weil ich glaube, das ist ein Phänomen

von der Komplexität der

Frameworks und der Libraries, mit denen man zu tun

hat, weil also im Kern

ist ja die Handlichkeit, dass das

Python eh schon hat

und ich habe jetzt

ja eben in der letzten Zeit häufiger eher mit

sehr kleinen Sachen immer wieder zu tun

weil halt viel Systemintegration, viel so

Mini-Tooling, viel gerade

auch verteilt durch die Gegend

wo ich experimentellen Code

habe, wo ich merke, entweder mache ich so, dass ich da einen PyTest

reinwerfe, relativ

leichtgewichtig, um mir auch für Sachen, die ich gerade

sketche, gleich

auch die Test Cases dann

im Prinzip rauszulassen, indem ich

sage, ich muss gerade mal was verstehen und debuggen

und dann habe ich gleich ein Testcase zu oder

weil ich eh bloß so ein

30, 40 Zeiler habe, der irgendwo

auf einer Maschine läuft, wo ich halt

einen Haufen Bewegdaten brauche, weil es ist

irgendein Storage-Server und ich irgendwie die Krypto von

diesem komischen Ding da gerade auseinandernehme und die

Formate irgendwie auch verstehen möchte.

Da merke ich, da bin ich halt häufig in so

System-Integration-Sachen drinne

und ich fall irgendwie, so wie

du sagst, genau in diesen Mittelteil da irgendwie gerade

rein, dass

sozusagen, ja, für so einzelne Fälle haben mich

die Notebooks immer wieder angelockt.

Ich sehe auch so andere Kollegen für

bestimmte Fälle, die immer wieder rausholen.

Aber wenn ich es dann versuche, dann

stolpere ich in meinem Workflow

zu schnell drüber,

dass es mit irgendwie allen anderen Sachen nicht mehr so

richtig andockt, die ich bei mir so parat

liegen habe. Also ich würde es zum Beispiel

sehr gerne auch via das Code

und da kann man die mittlerweile sogar integrativ

einfach nutzen. Das heißt, du hast sie dann einfach

nirgendwo beiliegen, wie den anderen Code, den du auch

drin hast und neben dem Terminal oder sowas und kannst halt dann

direkt fast wie in der Shell

irgendwie so nativ so hin und her switchen. Das ist schon

nett.

Ja, interessant.

Ja.

Ja, das ist schon, also

ich finde, also das für mich total überzeugende

Geschichte war dann halt, also gerade

für so Data Science oder Machine Learning-Geschichten,

wo man oft so Schritte hat, die lange dauern.

Und das ist

einfach, wenn man das anders macht, ist es halt,

also kann man auch irgendwie,

aber das lässt man dann manchmal weg, weil man da nicht dran denkt oder so.

Man kann natürlich alles irgendwie cachen oder

versuchen, das halt so hinzuschreiben,

dass man es auch schnell wieder erzeugen

kann oder so. Aber wenn man jetzt irgendwie

ein Modell eine Stunde lang trainiert hat oder ein paar Stunden

und da macht man irgendeinen blöden Fehler,

Und dann ist halt das Ergebnis von einer Stundenberechnung einfach weg.

Das kann einem im Notebook im Grunde nicht so wirklich passieren,

weil dann hat man halt die Zelle, die das macht, ausgeführt.

Und selbst wenn man irgendwo anders einen Fehler macht,

dann macht das halt erst mal nichts kaputt,

sondern dann ändert man das halt und dann führt man es nochmal aus

und dann geht es halt weiter.

Und das beschleunigt viele Dinge durchaus.

Auch wenn man gerade mit großen Datenmengen irgendwie viel macht

und die nicht so einfach mal laden kann.

Also gerade so leidvolle Geschichten sind da sowas wie so fürchterliche Hadoop-Data-Lakes oder so,

aus denen man die Daten nur ganz schlecht wieder rauskriegt.

Und dann hat man es irgendwie geschafft, die Daten rauszukriegen.

Und dann sind sie gleich wieder weg, wenn man irgendwie einen Fehler gemacht hat oder so.

Also das war auch in dem Talk von Joel Gruß,

hat dann jemand am Schluss, als dann Fragen aus dem Publikum kamen,

meinte jemand dann so, ja, also ich habe ja das Problem, genau,

meine Data-Sites sind halt groß und es nervt, wenn ich das irgendwie verliere.

quasi das gleiche Argument, was ich jetzt auch gerade gebracht habe

und er meinte dann so,

ja, Moment, du hast, du machst

explorative Datenanlöse-Geschichten

mit Datasets, die so mehrere Gigabyte,

zwölf Gigabyte groß sind oder so, und er so,

ja, und ich dachte mir so,

ja, ja, ich mache das auch sehr oft,

das ist irgendwie, okay, ja, dann,

dann, so, ja,

das ist, also, finde ich, ist auch,

das ist halt völlig normal, also, irgendwie,

und er meinte, er macht das halt nie, und dann kann ich das auch

verstehen, okay, wenn man diesen Fall nie hat, dann, okay,

aber wenn man ihn hat, dann ist das sehr hilfreich,

Und interessanterweise triggert aber bei mir dieses Gefühl, und das ist so diese Frage, wer bringt da welchen Erfahrungshintergrund mit, bei mir triggert, wenn du beschreibst, du willst nicht aus Versehen irgendwas verlieren, dann ist mein Gefühl den Notebooks halt gegenüber viel stärker ein, ja das ist da irgendwo, ich habe keine Ahnung, wann der Punkt ist, wann ich es verliere.

Das ist so irgendwie noch unoffensichtlicher, während bei dem anderen ist es irgendwie offensichtlich und ich muss hier etwas machen, wo mir dann auch klar ist, wieso es jetzt persistent ist oder auch nicht. Ich glaube, daran spaltet sich, glaube ich, ein bisschen so das Publikum.

Naja, man muss es halt immer dann noch irgendwie irgendwann ordentlich machen, aber manchmal will man einfach nur irgendwas ausprobieren.

Ja, ich wollte gerade sagen, also ich habe also ein paar Müll-Notebooks, da schmeiße ich einfach irgendwas rein, manchmal auch richtig unformatierte Sachen, einfach um die Schnipsel irgendwo griffbereit zu haben und führe dann halt einfach mal so eine Zelle aus, um zu gucken, was da passiert und das ist halt von der Struktur vielleicht manchmal sogar entfernt, aber das ist echt hilfreich, weil also ich würde das halt nie irgendwie in das Projekt dann reinstecken, sondern das ist halt dann nur dann da drin und irgendwann zieht man das dann halt vielleicht mal gerade und baut dann irgendwie so ein kleines Modul da und dann funktioniert es, weil das super getestet ist und das kann man dann einfach copy-pasten eigentlich und es geht.

Also wo ich gespannt bin, das reißt jetzt so, jetzt kriegen wir so fast die Kurve zum Machine Learning rüber, da habe ich gesehen, dass das halt tatsächlich sehr häufig auch angeboten wird als Übungsplattform, dass du irgendwie vorgefertigte Notebooks eben hast, wo du eben halt so ein bisschen erzählerische Erklärungen hast und dann Code-Beispiele und dann halt auch das Zeug ausführen kannst, die Ergebnisse sehen und dann halt drinnen rumeditieren, um so ein bisschen mit dem Code zu arbeiten.

zu spielen.

Ich bin mal gespannt, weil ich mich jetzt durch

ein paar von den Sachen durcharbeite,

wie mir das didaktisch als jemand, der

auf der Konsumentenseite davon ist, gefällt.

Weil ich gleichzeitig mich selber

dann eher ertappe von,

wenn ich das schon so

vorgesetzt kriege, ist irgendwie die

Hürde oder es ist, gibt es

ein gewisses Risiko, dass ich schneller

durchgehe, als ich es tatsächlich verstehen

und konsumieren kann. Weil es

dir vorgaukelt mit, ja, du hast jetzt auf Play gedrückt

und jetzt kam das Ergebnis raus, ah ja, aha,

okay, weiter.

Da ist sozusagen

vom E-Learning-Faktor habe ich das

Gefühl, ich muss mich ja eigentlich noch

viel stärker mit dem Zeug auseinandersetzen

und jetzt muss ich aber noch weniger machen.

Also ist da so ein Gap von

was hat mein Hirn noch an Chancen, es zu

verstehen? Bin ich gespannt darauf.

Ja, es ist immer blöd, wenn man es nicht

selber ausprobiert, dann ist es schnell wieder weg.

Ja, eben. Also wenn man die Zeilen einfach nur

nacheinander, viele Tutorials

oder Videos, die man so sieht, bestehen

daraus, dass jemand dann halt so eine Zeile nach der anderen ausführt,

Das hilft einem natürlich nicht so richtig.

Aber was toll ist und was man machen kann,

ist ja selber dann halt irgendwann mal so damit rumzuspielen

und halt zu gucken, okay, was ist denn da jetzt wirklich drin?

Und das kann man halt auch einfach ...

Ich hatte mal so am Anfang ja diese Tutorial-Reihe,

der erwähnt, NumPy for Grandmas und Pandas for Grandpas.

Der benutzt auch Google Colab, was ja auch im Prinzip das Notebook ist.

Und er hat jedes Mal nach jedem Kapitel Übungen eingestellt,

die ziemlich cool sind, wo man, weiß ich nicht,

die Anwendung direkt praktisch an so Aufgaben üben kann.

Und wenn man die halt selber versucht, dann stellt man halt fest, ob man das kann. Also meistens kann man es dann nicht, aber das ist ja nicht so schlimm, weil er hat ja die Lösung dann hinterher gezeigt. Aber durch das Ausprobieren bekommt man halt genau das Gefühl dafür, wann, wie, wo, was man vielleicht filtern, nutzen und so kann. Und auch halt mit dem Notebook. Und ich glaube, das ist so die einzige Methode, wie man tatsächlich dann versteht, was dann da passiert und was man da machen möchte.

Und mindestens ist es natürlich so, dass man auf jeden Fall erstmal eine lauffähige Umgebung hat.

Also dass man dort erstmal was hat, wo man sagt, okay, ich kann anfangen mit,

also hier gibt es Code, der sich selber beweist, dass er erstmal tut.

Das heißt, ich habe nicht das Problem, wenn ich dann irgendwie das Zeug aufbaue

und dann noch nicht so ganz weiß, ob meine Umgebung jetzt tatsächlich irgendwie clean ist

und warum kommt jetzt nicht das raus, was rauskommen soll?

Warum wirft man mir irgendwelche komischen Fehler? Bin ich schuld oder war die Umgebung schuld?

Da ist es natürlich schön, von einem definierten

Zustand aus loszulaufen.

Zumal ich auch eigentlich, eigentlich würde ich halt sagen,

mir liegt es total, Sachen halt

erstmal Ende-Ende zu begreifen.

Also wirklich mit,

wo fängt es hier an, was sind die kleinen Bauteile,

aus denen sich das zusammensetzt und wie löse

ich jetzt ein Problem einmal von vorne

bis hinten damit durch. Das taugt mir

total und

aber trotzdem triggert es mich an so ein paar

anderen Punkten.

Ja, also

genau, also ich würde sagen, kann man

sich mal angucken.

Ist ganz nett.

Ja, genau.

Eigentlich ein ganz guter Einstieg in dieses

Machine Learning Ding.

Ich würde sagen, dieses PyTorch Buch, was

Jeremy Howard geschrieben hat, das kann man sich

auf jeden Fall auch... Wie heißt nochmal dieser Rapper

von PyTorch, von dem du am Anfang sprichst?

Fast.ai.

Könnte man jetzt

eigentlich also direkt in Colab, also das kann man auch

seinem Telefon ausprobieren, direkt Python ausführen

im Browser und live und

funktioniert einfach.

Und dann kann man es importieren. Ich glaube, die Sachen sind alle

dabei und los geht's, oder?

Ja.

Ich weiß jetzt nicht, ob ich das auf dem Telefon machen wollte.

Aber gut.

Wobei die Telefone, also

ich war ja von dem Machine Learning Thema

angetriggert, weil

ich mich jetzt mal angefangen habe,

ein bisschen umzugucken, was da so an Hardware

auf dem Markt eigentlich rumfliegt

und in den Libraries habe ich zumindest auch gesehen,

Tatsächlich das Mobil ist ja definitiv halt interessant, weil du hast halt inzwischen da überall nochmal irgendwelche Chips drin, die Machine Learning Tasks halt unterstützen.

Also ich meine, guck dir den bei Apple die ganze Reihe, da ist das ja irgendwie völlig klar.

Aber auch die Androids haben da ja schon Sachen drin.

Das ist halt, weil es ist ja für mich vom Verständnis jetzt mit dem, wie ich reingeputzelt bin über die letzten zwei Wochen, ist vor allem, dass es halt ein Trade-off ist, dass du mit weniger Strom mehr Punch kriegst.

Also die Verhältnisse, wenn du deine Algorithmen oder deine Pipelines halt richtig aufziehst, speziell nachher für die Inferenz, müssen nachher noch ein bisschen in die Themen, glaube ich, die Stichworte sortieren und ich habe auch noch welche, wo ich Fragezeichen im Kopf habe.

Also wenn ich tatsächlich für den Benutzer etwas rechnen will, um für ihn ein Ergebnis zu erzeugen, dann ist da wohl typischerweise ein Power-Faktor von 40 drin, was ich an Geschwindigkeit rausholen kann im Vergleich zu wenn ich es auf einer normalen CPU rechne.

Und gerade wenn ich halt ein stromlimitiertes Gerät habe, wie ein Telefon, dann ist Faktor 40 halt schon ein massiver Unterschied. Alle beschweren sich, dass sie gerade über den Tag kommen. Wenn ich das halt dann mal 40 mache, ist der Tag halt schon früh um acht vorbei.

Insofern, also das ist so das erste Verständnis von, warum fangen wir eigentlich da an, an dieser Ebene drauf reinzuhauen und das ist halt, auch wenn jetzt einige CPUs natürlich immer mehr Instructions kriegen, die bestimmte von den Operationen, die es da braucht, diese ganzen Vektor-Operationen in Hardware abbilden, die fallen einem auch gerne mal auf den Fuß.

Also mir ist dann letztens auch aufgefallen, dass einige von den etwas älteren Libraries, die sich im KI-artigen Bereich bewegen, also Tesseract für OCR, also Schrifterkennung, Texterkennung, die haben halt zum Beispiel jetzt Unterstützung für diese Vector Instructions von Intel.

Und das fällt einem auf die Füße, weil du auf einem Multicore-System mit diesen großen Instructions von den Vektoren halt gerne mal die Pipeline für drei, vier Kerne auf einen Schlag mal für 40, 50 Takte stilllegen kannst.

Und ja, das durch eine so eine Vektor-Operation erledigen zu lassen, ist in Summe schneller als durch viele kleine, aber nichtsdestotrotz hat das so Auswirkungen auf die Responsivität des Systems, weil das plötzlich, also das Ding frisst Strom, dann geht dir der Turbo-Boost verloren und so Auswirkungen, wenn du das dann auf einer virtuellen Maschine machst, dann müssen halt gegebenenfalls noch drei virtuelle Maschinen nebenan auch noch die Luft anhalten, weil, boah, das ist aber eine dicke Instruction, die kann ich jetzt aber nicht so auf einmal rechnen.

Und da merke ich, okay, ja, das macht Sinn,

da nochmal über spezialisierte Hardware nachzudenken

und Algorithmen, die sich genau darauf abbilden

lassen.

Ja, ja, ja, dieses Hardware-Thema

ist natürlich total interessant. Ich meine, im Grunde

hat man da nur

bei einer speziellen Art von

Machine Learning-Modellen

irgendwie diesen Bedarf, halt bei

den neuronalen Netzen,

bei vielen

anderen Sachen, also wenn man jetzt irgendwie,

weiß ich nicht, lineare Modelle macht oder

Superflexor-Maschinen oder so, da hilft einem das alles nicht

so richtig.

Aber eben bei

neuronalen Netzen halt schon. Also alles,

was irgendwie mit Matrizen-

Multiplikationen irgendwie darauf

dann letztlich irgendwie basiert.

Ich finde das sowieso auch interessant, wie sich

jetzt so die Hardware im Grunde

so über die Jahrzehnte so in der

Mathematik hochhangelt. Also wenn man jetzt

sozusagen vom, wenn man sagt

so irgendwie, keine Ahnung, ein Skalar ist irgendwie so

Tensor-Nullterstufe oder sowas und dann hat man halt

irgendwie so ein Vektor und

dann irgendwie eine Matrix

und dann irgendwie

im allgemeinen Fall

Tensoren oder

Arrays mit N-Dimensionen.

Was ist der Unterschied

eines Arrays mit N?

Also was ist der Unterschied eines Tensors mit einer Matrix?

Das ist genau

eigentlich, ja, Matrix ist zweidimensional,

Tensor ist quasi N-dimensional,

wobei das halt in unterschiedlichen Communities

auch unterschiedlich genannt wird.

Wenn ich dann sowas sage,

dann sagen die Leute, die aus der Mathematik kommen,

das ist doch Quatsch. Dann die Leute, die aus der Physik

kommen, sagen so, nee, Moment, Tensor, das ist für uns

was ganz anderes.

Ja, da musst du jetzt nochmal genau

sagen, was denn Tensor für dich ist.

Also das, was ich, also das

Konzept sozusagen ist eigentlich quasi, du hast

einen Skalar, das ist halt irgendwie sozusagen

ein Ding, irgendwie eine

Zahl. So, das nächste, die nächste

Stufe wäre für mich jetzt halt irgendwie

ein Vektor. Also

eine Richtung in einem Raum.

Ja, das ist dann

schon eine Interpretation, was das da nun ist, aber

das einfach nur so

als Struktur. Das nächste wäre halt

Matrix.

Genau, also ein Skalar ist ja tatsächlich

erst mal bloß ein Wert, der für sich steht.

Der ist dimensionslos.

Und

ein Vektor kann ja

n Dimensionen haben.

Und das ist ein Punkt in einem n-dimensionalen

Raum. Genau, also

aber da sieht man schon, dass das mit den Dimensionen nicht so

ganz hinkommt, weil klar, natürlich hat der n Dimensionen,

aber tatsächlich würde ich jetzt sagen, der hat

irgendwie ist halt eine Liste von Zahlen

und hat halt als Struktur eine

Achse. Vielleicht einfach mal ein anderes Wort

nehmen. Genau, ich kann,

die Frage ist jetzt, von welchem Ende komme ich halt erstmal,

aber ich bilde ja mit einem Vektor

einen Punkt in einem

n-dimensionalen Raum ab und dafür brauche

ich eine Liste, weil ich nämlich

halt n-Werte, n-Skalare

bilden halt

einen Vektor der

Dimension n. Genau.

Mit einer Matrix

mit einer Matrix kann ich jetzt mehrere

von solchen Vektoren nebeneinander

setzen. Da gibt es dann welche mit

bestimmten Eigenschaften, die, wenn ich, wenn die Matrix

genauso, wenn ich halt N

Vektoren der Dimension N

zusammenfasse, dann habe ich

genau eine

quadratische Matrix

und

solche Spielchen, wo man dann halt bestimmte

Dinge rechnen kann.

Ja, aber genau, das wäre halt für mich die nächste Stufe

sozusagen, dass du dann zwei Achsen hast,

so in zwei unterschiedliche Richtungen

und das nächste wären dann halt drei.

Das hast du dann halt bei Bildern, da hast du dann halt

nicht nur, also du könntest ja auch schon eine Matrix

als Modell für

ein Bild nehmen, wenn du jetzt nur schwarz und

weiß hättest oder nur irgendwie

einen Wert für, weiß ich nicht, die Helligkeit

oder so, aber wenn du jetzt Farben hast,

dann hast du schon Rot, Grün, Blau,

das kannst du jetzt in eine Matrixzelle

ja schon nicht mehr so richtig reinpacken

und was man dann macht, ist halt, dann geht man halt noch

eine Achse in die nächste

Richtung sozusagen und dann hast du halt sozusagen

eine Matrix pro Farbkanal

sozusagen. Das kannst du ja abbilden

sozusagen über eine Matrix von Vektoren

oder über eine

statt einem Quadrat über einen Würfel.

Ja, aber mit dem Würfel darstellen,

glaube ich, das wird schwierig, weil was ist dann die vierte

Dimension und die fünfte und so?

Ja, das geht immer weiter.

Wir machen halt einen Hyperwürfel.

Also das ist

tatsächlich, Bilder

sind halt im Rechner,

also für Machine Learning-Geschichten

sind halt, einzelne Bilder sind

halt sozusagen

Arrays mit drei Achsen, ja, so einer

für halt Höhe, Breite.

Das wäre wesentlich, wenn die so nebeneinander

macht, oder? Dann hast du da drei Matrizen nebeneinander und

dann hast du hinterher Reihen von

Matrizen nebeneinander. Ja, aber die legt man

übereinander und das spielt auch tatsächlich

eine Rolle, dass das halt irgendwie nicht

einfach getrennte Dinger sind, sondern dass es halt

ein Array ist mit drei Achsen und

nicht drei Matrizen.

Und es ist so, tatsächlich ist es

eher sogar so, dass man jetzt

ein Trainingsset, als ein Array mit

vier Achsen begreift. Nämlich, du hast dann halt auch noch die

deine Trainingsbeispiele.

Die Labels, oder?

Die Labels

sind getrennt davon, aber du hast halt

sozusagen mehrere Trainingsbeispiele.

Du hast

immer Batches von so

Bildern. Das heißt, du hast halt

da auch nochmal eine Achse.

Und dann bist du schon bei

vier Achsen. Und dann,

wenn du jetzt in Richtung Videos gehst, dann bist du auf jeden Fall schon mal

bei fünf Achsen.

Weil dann hast du nämlich auch noch Frames

über die Zeit und so.

Und dann wird es halt, irgendwann kann man

es sich auch nicht mehr vorstellen, aber

muss man ja vielleicht auch nicht. Ja, aber wenn man das halt so nebeneinander

schreibt und dann wieder rein und dann wieder spalten,

dann wieder rein und spalten von Dingen, die sich so ein bisschen

schachteln, wie so eine Puppe,

dann

wird das vielleicht ein bisschen visualisierbarer.

Ja, kann man auch.

Auf jeden Fall. Aber genau.

Also jedenfalls, das wird dann halt immer

von der

Struktur her schwieriger.

Und was ich eigentlich nur am Anfang

sagen wollte, was ich interessant finde, ist, dass jetzt sozusagen

die Hardware halt diesen Prozess mitmacht.

Nämlich halt

von irgendwie, keine Ahnung,

Vektorrechnern, wo man halt eine

Instruktion hat, die dann nicht nur

auf einem, mit einem Skalar

quasi rechnet, sondern... Das ist der Aberkurs, der dann

hin und her schiebt. Ja, sondern

wo man die halt auf

vielen Datendingern dann

halt ausführt, sozusagen diese SIMD-Geschichten

oder Vektorrechner halt. Und jetzt

haben wir halt Tensor Cores

in den Grafikkarten und den GPUs

und da

ist halt sozusagen, die rechnen dann halt nicht mit Vektoren,

sondern die rechnen halt direkt mit

Matrizen. Also klein,

so 4x4 Matrizen, aber immerhin.

Die machen halt dann in einem Takt schon

Multiplikationen von zwei 4x4

Matrizen, wo du

normalerweise viel, viel mehr Takte brauchst, wenn

du das halt irgendwie dann halt

in Vektor-Operationen machst oder halt

in der CPU

als Skalar.

Und ja, das ist

eigentlich ganz faszinierend zu sehen, dass das jetzt so gerade mit der

Zeit passiert.

Ja. Also das ist auch der Hauptgrund

dann, warum die Grafik

Hardware so gerne dafür benutzt wird.

Ja, weil halt die Dimensionalität bei

Grafikoperationen eh schon so hoch gewesen

sein muss.

Ja, weil halt die Geschichten, auf die das optimiert

ist, die mappen halt super auf die Operationen, die man

halt für Machine Learning braucht.

Also diese ganzen

Matrix-Multiplikationen, beziehungsweise halt diese

Convolution-Operationen, die man für

diese Convolutional Neural Nets halt braucht,

die sind halt damit super

umzusetzen. Die brauchen wir halt auch für Spiele und so.

Die machen ja auch im Grunde solche Sachen.

Jetzt musst du vielleicht nochmal für all die Hörer erklären,

was ein Convolutional Neural Network ist.

Vielleicht einmal ganz kurz.

Da hatten wir doch schon mal eine Episode dazu.

Da war das nicht die Folge 8.

Ehrlich gesagt, ich weiß nicht, ob ich das

kann ich jetzt aus dem Stehgreif auch nicht.

Also im Grunde, das ist halt eine spezielle Art von

neuronalen Netz, wo halt

zwischen den verschiedenen

Layern, zwischen den Ebenen irgendwelche Dinge passieren.

Das eignet sich halt vor allen Dingen, also es ist nicht nur

Bildverarbeitung, also man kann das auch

eindimensional dann halt für Audio

machen oder für halt Text, aber

es ist halt eine

Operation, man kann sich das, muss man

sich eigentlich auch mal ein Bild so angucken. Ich glaube,

das kann man nicht so wirklich gut erklären.

Das kriege ich irgendwie

nicht so richtig hin. Aber

genau, also es gibt auch noch andere

Arten von Netzen, also die jetzt gerade eine große Rolle

spielen mit so einem Transformer, ist zum Beispiel total heiß

gerade. Und

ja,

das funktioniert, es gibt so unterschiedliche

Architekturen, TPUs und so,

Tensor Cores. Und das

einzig Blöde ist jetzt, dass außerhalb von

das eigentlich, das ist was halt

wirklich doof ist, dass halt Nvidia da so ein Monopol

auf den ganzen Kram hat. Das ist so richtig

ätzend. Das macht das mit der Hardware auch ziemlich

schwierig, finde ich, irgendwie. Und gut,

ich meine, es gibt noch Google und so, die mit ihren TPUs

dann auch mal eine eigene Geschichte machen, aber da kommt man ja auch nicht

so richtig ran. So einen Laden kaufen kann man ja auch nicht.

und

tja, das ist halt, das macht das Ganze

etwas unschön. Alles andere ist super

toll, aber das ist ja, diese ganzen

Geschichten sind etwas fies und natürlich

ist es dann auch schwierig, die Dinger zu betreiben, weil wenn man

jetzt zu Nvidia geht und sagt, also ich habe da so ein

Rechenzentrum und da würde ich jetzt gerne irgendwie Machine Learning

Server irgendwie mir hinstellen oder so,

dann sagen die, ja gern, klar, super, hier,

nimm doch mal die, weiß ich nicht,

was haben wir da, A100 Karten oder so,

aber die

kosten dann halt ein Arm und ein Bein.

Wobei das finde ich, also

ob die ein Arm und ein Bein kosten, kommt so ein bisschen darauf an.

Du hast halt das Thema, du kannst nicht unter

einer gewissen Mindestgröße einsteigen.

Und was mir bei Nvidia mit dem

Monopol tatsächlich aufgefallen ist, ist, die

segmentieren

sich den Markt zurecht.

Die haben sehr stark angefangen, über

Lizenzverträge zu knebeln.

Also speziell mit dem Thema, dass

die meisten Puppel-Grafikkappen

können

genau den Kram, den man da braucht. Die haben inzwischen

auch ausreichend RAM, es ist immer noch die Frage

nach welchen Modellgrößen kannst du rechnen

und Nvidia will ja nun mal die

Gamerszene bedienen

und verbietet dir aber halt für die

normalen Gamer-Grafikkarten

sie verbieten es, die Lizenz technisch

einfach sie dafür einzusetzen

sie sagen, auf diesen Karten darfst du kein

Machine Learning machen

so und dann

nimmst du bitte unsere, die A100 oder halt

auch ein paar kleinere oder irgendwas

und es ist schon krass, was die auf dem Gebrauchtmarkt teilweise ziehen

also es gibt jetzt irgendwie

bei Azure

gibt es die K80 unter anderem.

Die ist jetzt schon ganz schön in die Jahre gekommen,

glaube ich. Aber die kostet

halt das Stück immer noch 2.500 Euro

auf dem

freien Markt.

Und wenn du mit einer A100 einsteigen willst,

bist du halt bei so 8.000, 9.000 Euro

etwa dabei netto.

Und da muss man aber im Hintergrund wissen, naja, das ist halt

schon genau für das High-End-Data-Center-Zeug

gedacht. Das heißt, eine davon kannst

du halt im Prinzip auch in sieben Teile zerteilen,

in virtuelle Maschinen reinpacken, kannst die irgendwie

in unterschiedliche Zuschnitte von

irgendwie unterschiedlichen

Rahmengrößen und was du denen an

Ressourcen zuweist, also da

Da ist dann schon auch Musik drin im Handling und wenn du dir das dann durchrechnest, dann merkst du, okay, das lohnt sich wirtschaftlich auch, aber es braucht halt diese Mindestgröße und klar, Nvidia verkauft ja halt auch, es gibt so eine A100, irgendwie vier Höheneinheiten, glaube ich, Riesenchassis mit acht von den Stück drin oder so, mit den tollen irgendwie auch noch speziellen Bussystemen, die die Karten untereinander verbinden.

Da kostet halt das Stück nur 250.000 Euro.

Das ist natürlich für mal anfangen und irgendwie loslegen und gucken,

wie experimentiere ich jetzt eigentlich damit.

Und du brauchst halt, ich habe noch nicht verstanden,

welche dieser Hardware, welche Operationen zum Beispiel in vergleichbarem Umfang,

vergleichbarem Takt, welche Modellgrößen für den RAM

und haben die nochmal unterstrichen,

da sind inzwischen auch acht Generationen, glaube ich, in Summe am Start,

was die tatsächlich können, welche Befehlssätze.

Das ist alles relativ unübersichtlich.

extrem viel Marketing-Fluff momentan

draußen und selbst die

Datasheets sind nicht

gut lesbar.

Was ich bei Nvidia zum Experimentieren gerade auf dem Schirm

habe, sind diese Jetson-Teile.

Das ist irgendwie deren Richtung

für eher kleine Embedded-Sachen, wo du so

in Richtung Robotik und so gehst. Und da kann man

tatsächlich mit dem allerkleinsten

für, glaube ich, 100 Dollar oder so, kannst du da reinwerfen.

Und das ist schon ein

Mini-PC, wie so ein Raspberry

im Prinzip. Da hast du schon Netzwerk und CPU

und alles irgendwie einmal als einen Bundle

und da findet man im Netz auch

für die ganzen klassischen Frameworks, die man jetzt so hat

wie PyTorch etc. Anleitungen

wie man die auf den Teilen dann betreibt, das heißt

das ist so für mich gerade der Vector

mal zu gucken, okay, so ein Stück

Hardware mal zu kriegen, wo man das Zeug

tatsächlich sehen kann von, bringt mir das

jetzt wirklich was in der Beschleunigung oder

ist das alles bloß heiße Luft

ja, das ist so ein Ende

ansonsten würde ich ja gerne

immer lieber noch ein bisschen AMD

kaufen. Und da macht sich

aber auch wieder Nvidia als Platzhörer

bemerkbar, dass viele von den Frameworks dann

mit den AMD-Karten wieder nichts anfangen können.

Das ist so ein bisschen,

ja, hm.

Ja, das ist ganz blöd. Also nicht, dass ich wüsste,

dass mit AMD da irgendwas zu machen wäre zur Zeit.

Also das kann man ja auch

nicht kaufen kann. Ja, okay.

Also zum einen muss die

Playstation mal noch irgendwie gefertigt werden.

Die ziehen da ja Kapazität ab.

Und zum anderen die ganzen Bitcoin-

Miner, die scheinen das

Zeug schon direkt an der Fabrik abzuzweigen.

Ich habe ein paar Lieferanten gesprochen, die

eigentlich gern AMD anbieten würden. Sie meinen, sie haben noch

nicht einmal irgendeine der Karten

jemals in echt gesehen.

Oh, okay. Ja, gut.

Ja, ja, das ist natürlich auch so ein Problem.

Die Verfügbarkeit. Das ist auch teilweise bei den

Nvidia-Karten auch immer

so ein Problemchen, die es sind, wirklich zu bekommen.

Ist manchmal gar nicht so einfach.

Ja.

Ja, also genau diese

Marktskementierungsgeschichte ist halt das, was man dann...

Das ist halt im Grunde die Art, wie man

jetzt ein Monopol hat, wie man das zu Geld macht.

IBM

hat das früher ja dann auch schon gemacht.

Man macht dann halt Functional Pricing.

Man macht den Preis halt so,

dass es zu dem Markt, das man

bedienen möchte, passt. Im Grunde können die ganzen Dinge

mehr oder weniger das Gleiche.

Die RTX-Karten,

die können im Grunde

fast das, also die Gamer-Karten können halt

im Grunde das Gleiche, was halt

auch die

großen Server-Karten können.

Sie sind halt in bestimmten Operationen ein bisschen

künstlich langsamer gemacht, damit man sie halt

jetzt nicht so verwenden kann.

Übrigens, ich weiß auch nicht, ob das irgendwie

überhaupt geht. Also in den USA geht es vielleicht,

aber ob man jetzt in Deutschland jemandem,

der irgendwas

abgekauft hat, dann hinterher verbieten kann,

damit irgendwas zu tun. Ich glaube, das geht überhaupt gar nicht.

Also auch eine Lizenz oder sowas

schwierig wahrscheinlich.

Insofern,

ja, also

vielleicht kann man

das einfach trotzdem machen. Auf der anderen Seite

ist es natürlich auch so, es ist

nicht so einfach.

Ja, es ist halt für eine Geschäftsbeziehung keine Grundlage.

Also, was machst du denn?

Damit machst du dich deinem Hersteller gegenüber nackig

und der sagt, so, jetzt hast du

da dein Produkt aufgebaut und wir sollen dich beliefern.

Wäre aber schade, wenn du nicht mehr

beliefert wirst. Ja, ja, gut, klar, natürlich.

Das ist halt die Frage,

ob man das machen kann.

Ja, das ist schon, das ist natürlich

so ein Punkt. Ja, und

ein weiterer Punkt ist halt, es ist schwer,

die Dinger zu betreiben nach wie vor.

Also die Leistung steigt zwar auch immer noch,

aber auch die Leistungsaufnahme steigt halt irgendwie einfach an Strom.

Und so bei den, glaube ich, bei den RTX 3090-Karten,

die aktuellsten, da ist es so, da musst du halt dann,

also Netzteile, die normalerweise,

also selbst die größten Netzteile, das funktioniert nicht mehr.

Du brauchst dann nochmal externen Strom da dran.

Und wenn du dann mehrere in ein Gehäuse steckst,

dann kriegst du sofort Hitzeprobleme.

Man muss halt immer zusehen, dass man genug Platz lässt

und dann irgendwie Leute,

also da gibt es ganze Bastelzähne,

die versuchen, das irgendwie richtig hinzukriegen

und das alles irgendwie,

es ist nicht so einfach.

Aber tatsächlich, das lohnt sich auch noch

alles. Also wenn man das selber macht, dann kann man

mindestens im Faktor 10 irgendwie günstiger

sein, als wenn man das jetzt irgendwie fertig

gebaut kauft und hat halt

die gleiche Performance. Und das ist

schon noch signifikant.

Ja, der Unterschied im fertig gekauft

beziehungsweise wenn du sie halt aus irgendeinem Cloud

Ding rausziehst, der Unterschied dort ist halt

du kannst halt hinklicken, dann kostet sich das

zwar auch ein Arm und ein Bein, aber du kannst es halt auch jederzeit

wieder abschießen und du musst nicht

fünf Monate lang ein Projekt

machen, dir zu überlegen, was kaufe ich

jetzt und wie stecke ich es zusammen etc. Insofern finde

ich das schon legitim.

Aber ich merke halt, also der

man darf das

nicht nur schätzen, was Flexibilität

und das ist ja eine

betriebswirtschaftliche

Grund

Erkenntnis,

Flexibilität oder Optionen

kosten Geld.

Die kosten immer irgendwas und

wenn man Investitionskosten und alle

wollen immer alles auf möglichst

OPEX umlegen heutzutage und wenig

kapitalintensiv irgendwie vorfinanzieren,

aber es kann halt manchmal passieren, dass wenn

du deine Lebensdauer von 12 bis 14,

von 12, 36

oder 60 Monaten anguckst,

dann ist das Ding in Summe 3 bis 4, 5 mal

so teuer, als wenn du es dann irgendwann mal selber in die Hand

genommen hättest. Da muss man

sich dann fragen, ist das für eine Basislast

ist das halt eigentlich dann irgendwann nicht mehr gerechtfertigt.

Also ich meine,

die A100 fand ich sogar

relativ zahm in der Hinsicht noch. Also ich

gucke gerade nochmal in das

Specsheet rein und wenn du halt eine PCIe-Karte

von der A100 ziehst und

die hat, was hat

die an RAM drin, 40 Gig

und

die zieht halt 250 Watt.

Das ist halt schon noch überschaubar. Das heißt,

also da habe ich bei den Netzteilen, was

wir so typischerweise Zeug verbauen,

ich würde ja in so einer Hinsicht halt auch weniger

gucken, irgendwie eine Karre möglichst

voll zu machen, sondern mehr

zuzusehen, dass man halt irgendwie dann in seinem

Pool vier, fünf, sechs

Maschinen damit bestückt,

weil man es ja auch irgendwie verteilen möchte, wenn mal was kaputt

geht, etc. Da bin

ich halt auch noch gespannt, weil

dann halt

die Kundenseite

für, ich rechne Modelle

um dir irgendwie Vorschläge

oder Klassifizierung oder irgendwie so ein Kram

zu rechnen.

Das ist ja immer sehr kurz von den

Transaktionen her. Da willst du ja innerhalb von

einer halben Sekunde deine Antwort haben

und dann ist es vorbei.

Wenn du aber tatsächlich so ein Ding hast mit

ich rechne hier mein

Training,

da habe ich noch nicht rausgefunden, was dann typische

Trainingsdauern sind. Aber wenn das halt mal Stunden

dauert und

die ganze Virtualisierung das noch nicht hergibt,

so ein Zeug transparent halt dann zwischen A

und B zu verschieben,

dann muss ich halt mittendrin operativ eingreifen können

und zu sagen, die eine Grafik da drüben, die fliegt jetzt mal weg.

Ja, also es kommt halt darauf an, was man damit macht.

Also die Leute, die das halt,

also die ganze Kegel-Community,

die da so kompetitives Machine Learning machen,

die versuchen sich alle möglichst viele Karten

in einen Rechner zu basteln halt irgendwie.

Und das ist natürlich irgendwie auch nicht so einfach,

aber weil du damit halt die Trainingszeiten runterkriegst.

wenn du jetzt viele Karten, also wenn du

mehrere Karten in unterschiedlichen Rechnern hast, das hilft dir nicht so

viel. Also insofern,

aber

das hängt

da, also das Ende, an dem ich

noch dran bin, ist ein Gefühl dafür zu kriegen,

dann welche Modellgrößen sich dann

in welcher Geschwindigkeit aufhäufen, weil

da wir über Mehrdimensionalität reden,

ist es natürlich immer so, irgendwann kommt der

Punkt, wo jede neue Dimension

das ganze Ding natürlich

dir schnell weglaufen lässt und wenn du also

keine Ahnung, dein Modell zu trainieren

schon 20 Gig frisst und du kriegst noch eine

Dimension rein, dann kann ich mir gut vorstellen, bist du plötzlich

bei 40 und damit bist du schon beim

oberen Ende, was eine so eine Karte halt kann.

Ja, kommt halt drauf an, was man macht. Also wenn man

halt irgendwie so

so klassische

Bild,

was ImageNet mäßiges macht, halt

Klassifikation von Bildern oder so und da Modelle trainiert,

da braucht man nicht so viel

Hauptspeicher, aber wenn man jetzt Transformer-Geschichten macht,

also Natural Language

Processing auf irrsinnig

großen Mengen Text oder so, da

braucht man eigentlich so viel Hauptspeicher, wie man kriegen kann

und da sind halt auch 24 Gig oder so, das ist

halt so das, glaube ich, maximale, was

man im Computer-Summe-Bereich kriegt, halt schnell

vorbei und dann, ja.

Kann man so eine A auch in

seinen Gaming-PC einbauen? Ich frage nur aus

Interesse. Ja, ja, kann man, kann man machen.

Aber, ja.

Die A hat, glaube ich, die hat keine Grafik-Outputs,

glaube ich. Ich weiß nicht, ob die

tatsächlich was hilft.

Also für die

Enthusiasten dann in der Szene.

Nee, nee, also das sind ja, viele von den Karten benutzt man ja auch so, benutzen Spieler ja auch, weiß ich jetzt nicht genau, welche davon, aber das sind, also die, gerade die günstigen Dinger, das sind halt alles eigentlich Karten für den Gamermarkt, ja.

Aber kann der, wie ist das auch mit diesen externen Grafikkarten dann, schließe ich die Displays an die externen Grafikkarten an oder schleifen die das Rechenergebnis wieder zurück und ich schicke das irgendwie über einen anderen Output raus?

Ich meine, man schließt die direkt an.

Ja, das ja auch, weil es gibt

auch Nvidia hat an der Stelle halt von ihren

von den Sachen, die haben

ja dann auch zum Beispiel noch Spezialkarten,

siehe Marktsegmentierung, die so für

AI-Unterstützung,

Maschinenunterstützung zum Beispiel für Architekten

ist und das sind dann Karten, die haben

halt entsprechend auch wieder ein Output dran

und dann gibt es halt noch

da gibt es ja noch dann wieder die Karten, die für

Desktop-Virtualisierung gemacht sind

da habe ich auch gerade einen Kollegen, der da

an dem Ende bei sich

rumarbeitet, also das ist nicht bei uns in der Firma,

sondern woanders, die halt

jetzt dank Corona

und Homeoffice haben sich anscheinend

viele Unternehmen entschieden, die Windows-Desktops ihrer User,

damit die Daten

nicht bei den Usern zu Hause liegen, alles über

so Remote-Desktop zu machen

und die musst du aber tatsächlich auch durch

eine Acceleration durchschicken.

Naja, weil auch

das Windows auf der VM

rechnet dir irgendwelche Transparenzen

aus und das willst du nicht mehr

in CPU machen.

Und da haben sie dann auch wieder

Spezialkarten für, die halt genau dafür

wiederum getrimmt sind.

Ja.

Naja, also

gut, ich kenne es halt nur von den Leuten,

die das halt, ja,

die das jetzt nicht, also

mit den ganzen Enthusiasten sozusagen, die

nehmen alle die Gamer-Karten und basteln

halt selber. Dann gut,

wenn man jetzt im Datacenter machen will,

dann, ja, nimmt man vielleicht

halt dann einfach in Kauf, dass das Zeug halt zehnmal

so teuer ist.

Die sind dann auch in den Nantien-Bereichen noch ein bisschen schneller,

aber da kommt es halt darauf an, was man damit machen möchte.

Für Transformer braucht man halt viel Hauptspeicher,

für viele andere kleinere

Sachen reichen halt auch die

mit weniger Hauptspeicher.

Es ist sowieso so, dass man ja im Grunde braucht man

diese ganze Power eigentlich nur dann, wenn man

tatsächlich größere

Trainingsdatenmengen halt

hat und irgendwie Modelle

quasi von Grund auf trainiert.

Also wenn man jetzt irgendwie

und das würde ich jetzt, ist halt

die Frage, was das für ein Anwendungsfall ist, aber wenn man jetzt

den Anwendungsfall hat, wo ich denke,

der kommt in der Praxis sehr, sehr häufig vor,

man hat im Grunde, man nimmt irgendwie fertig

trainierte Modelle von

irgendwo her und feintunt die jetzt

auf das Problem, das man hat. Also man

hat halt irgendwie, keine Ahnung, man möchte irgendein Produkt für

was irgendwie, das kriegt halt Bilder und soll dann

irgendwas zu den Bildern sagen,

die irgendwie klassifizieren oder da

halt irgendwie, weiß ich nicht, irgendwas drauf erkennen

oder so, was jetzt nicht

in den ImageNet-Klassen

schon drin ist, dann würde man einfach

ein ImageNet-Modell nehmen und dann halt das noch

feintunen auf das Problem. Dafür braucht man nicht viel Trainingsdaten

und dafür reicht irgendwie so eine

billige, diskrete GPU, weiß ich nicht,

irgendwie so eine NVIDIA

1070 oder sowas, was ganz billiges, so ein paar

hundert Euro, das reicht ja schon aus, um das

irgendwie machen zu können. Wenn man jetzt

tatsächlich das ImageNet-Dataset

komplett neu trainieren möchte für

irgendwas, also, oder ein

Dataset der Größe,

also, jenseits,

also schon so ein paar hundert,

jenseits von 100 Gigabyte irgendwie Bilder

und dann halt von Grund auf das Trainieren,

dann braucht man eigentlich alles,

was man an Power kriegen kann,

weil dann kann es sein,

dass so ein Trainingslauf halt mal eine Woche läuft

und ob der eine Woche läuft oder eine halbe Woche läuft,

macht dann einen großen Unterschied,

weil dann kann man halt unter Umständen

doppelt so schnell iterieren.

Und ja, also,

tja,

ich denke mal,

die allermeisten Leute brauchen das gar nicht so wirklich,

Boah, ehrlich gesagt.

Aber vielleicht wissen sie das auch nicht.

Wir hätten gerne alle so ein Machine Learning Ding dabei,

wenn wir zum Beispiel irgendwelche Geräte

bewegen oder sowas, die alles dann direkt selber

wahrnehmen können.

Genau, aber das ist ja immer sozusagen das Ende von

die benutzen die Modelle ja nur

und schärfen sie vielleicht noch ein bisschen nach.

Aber die rechnen ja die Modelle nicht.

Nee, nicht von Grund auf, genau.

Wäre doch schön, wenn sich das Modell

parallel anpasst. Aber naja,

wir träumen hier ein bisschen. Doch, den kann man ja

tun, aber die unteren Ebenen,

also sozusagen du trainierst halt bei so einem

Feintuning, was du da machst, ist halt, du

passt halt nur

die oberen, also

sozusagen nur einen Teil der Layer an. Also du

frierst halt die Gewichte für den Großteil

deines Modells ein und passt halt nur

noch Details

davon an. Wenn jetzt irgendwas über ImageNet

gelaufen ist,

was halt jetzt

also ein Modell, was jetzt super

gelernt hat, wie man Haare erkennt

oder Augen oder sowas,

das macht eigentlich keinen großen Sinn, wenn

du jetzt eine spezielle Art von Tier irgendwie

erkennen willst auf Bildern,

das nochmal alles von Grund auf neu zu

machen, so zu trainieren, wie man Fälle

erkennt oder so, weil das funktioniert schon super.

Du willst halt nur, dass deine Klasse von Tier

jetzt dann noch gut erkannt wird, aber dafür musst du eigentlich nur

ein paar Layer irgendwie...

Bei Live-Videodaten oder sowas, ist das vielleicht noch

anders?

Also es kommen halt auch... Ich meine, Video ist sowieso

ein Ding, wo es noch nicht so viel gibt.

Das wäre, wenn... Also

klar, wenn du jetzt eine neue Geschichte machst, die

sonst noch keiner gemacht hat, dann hast du natürlich genau... Oder wenn du

auch neue Modelle ausprobieren willst, wenn du

die Architektur änderst und sagst,

mir ist jetzt eingefallen, wie man

eine ganz neue, tolle Art von

Maschinen-Learning-Modell hat, bauen kann,

die alles viel besser macht und

dann musst du halt von Grund auf neu trainieren, weil

ja, du willst ja demonstrieren, dass es besser ist.

Dann, ja, also wenn du

Maschinen-Learning-Forschung machst und so, klar, dann

brauchst du, aber auch da

brauchst du unter Umständen keine so wahnsinnig

wahnsinnig

große Rechenleistung für.

du brauchst die, ja, wenn du

Forschung im Bereich von Transformer machen willst, dann brauchst

du halt richtig viel Hauptspeicher und richtig

fette Leistungen. Aber ich meine, wer macht

denn sowas? Also so,

also ich, die Leute, die Werbung,

die Leute, die

die Werbung auf die Webseiten

drücken wollen.

Da fließt

doch das ganze Geld rein. Das Geld fließt da rein,

dass die Leute mehr auf die Werbung

klicken. Ja, ja,

ich hab da, also die haben auch,

Da habe ich auch mal an so einer Maschinen-Competition

teilgenommen. Da gibt es die französische

Firma Criteo, oder ich habe jetzt schon wieder

den Namen vergessen.

Die machen irgendwie sowas wie

zum Beispiel Vorhersagen, wie wahrscheinlich ist es, dass

ein User irgendwie auf

Werbung klickt oder so.

Und die Modelle, die da

aber gewonnen haben, gut, das ist jetzt auch schon lange her, aber

das war alles total einfach, das war alles

linear, das war alles so

Logistic Regression-mäßig.

Ich bin mal gespannt.

Ich habe mich ja jetzt mal

Also ich habe, um da ein bisschen tiefer auch in das Thema für mich einzusteigen, weil ich halt eigentlich immer gerne verstehen will, wie ist das handwerklich gemacht, habe ich mich in so einen Coursera-Kurs eingeschrieben und da kommen natürlich dann diese ganzen Standardteile, unter anderem dann halt auch irgendwelche Recommendation Systems und ich wollte ja ganz kurz irgendwie den Schreibtisch abräumen und alles in die Ecke pfeffern, als dann die Aussage war, dass ja irgendwie so die tollen positiven Beispiele, die sind, wie Netflix dir halt neue Sachen empfiehlt und Amazon.

Und ich denke mir so, ja, aber das sind doch die Beispiele für, das hilft gerade genau gar nicht.

Also ich meine, wofür brauche ich Machine Learning, damit mir meine Plattform sagt, du hast gerade einen Schraubenzieher gekauft.

Ich glaube, du willst einen Schraubenzieher kaufen.

Also ich habe es ja noch nie in Funktionierend gesehen, dass da irgendwie sinnvolles Zeug rauskam.

Mich würde wirklich interessieren, wo jemand nachgewiesen hat, dass das was bringt.

Also vielleicht bin ich auch einfach als Nerd

so ein bisschen komisch an der Stelle.

Also ganz wichtig, Recommendation-Systeme,

das geht gerade besonders gut.

Einfach die Sachen, die am häufigsten gekauft werden,

die viralisieren sich dann einfach weiter.

Das scheint ja auch so funktionieren.

Naja, also

das ist jetzt aber auch schon da ganz lange her,

aber zum Beispiel Netflix hat da ja tatsächlich

mal einen Preis für ausgelobt.

Für eben

Leuten Videos empfehlen.

Und

das weiß gar nicht, wann das war.

das muss, das ist jetzt auch schon über 10 Jahre her,

oh mein Gott. Und da,

sie haben da eine Million Dollar drauf

ausgesetzt und das, was die Leute

daraus da gemacht haben, war auch sehr

interessant. Und

die Verbesserung in dieser,

in diesem Wettbewerb von, wie

war das am Anfang oder was hat Netflix

quasi, sie haben als Baseline auch angegeben,

was sie momentan verwenden für ein Verfahren

und wie gut das ist. Und

das, was dann hinterher gewonnen hat,

das war schon deutlich besser. Also

das hat richtig was gebracht.

Aber ehrlich gesagt, natürlich, es ist immer noch nicht

wirklich gut.

Ja, es war so mittelgut, ne?

Ja.

Gerade Netflix muss sich halt dann an der Stelle

auch gefallen lassen, ihr Katalog

ist halt nicht so groß.

Also, wenn ich es halt vergleiche,

auch die

eingeschränkte Art, wie man es häufig browsen kann,

dass du gar nicht mehr so richtig

wirklich strukturiert durch die Kataloge durchkommst,

sondern immer nur noch nach irgendwelchen

vor

gefertigten Kategorien,

die so ein bisschen merkwürdig sind und dann

irgendwie so Unterkategorien haben, die

Netflix irgendwie gefallen,

dann hilft es mir ja nichts,

wenn er mir die 20 Filme,

die er für mich gut findet, mal in der

und mal in der und mal in der Reihenfolge anzeigt.

Das ist ja das, was momentan irgendwie

gefühlt für mich dabei rauskommt, ist

nach so einer Pandemie

nach einem Jahr, Netflix ist ja gerade was

Filme angeht immer ziemlich hintendran,

dann hast du eh schon alles

durchgeguckt. Und jetzt

empfehlen sie dir das, aber halt einmal in der

und in der und in der Reihenfolge.

Wie viel Machine Learning brauche ich

dafür? Ja, es ist

auch die Frage, ob das eben tatsächlich ein Machine Learning

Problem ist oder vielleicht doch eher ein User

Interface Problem. Ich finde das auch total

schrecklich. Ich habe auch immer das Gefühl,

ich weiß nicht, auf was sie da optimieren, aber manchmal

habe ich das Gefühl, sie optimieren darauf, dass man da möglichst

lange drin rumsucht. Also es ist halt irgendwo

ein Incentive falsch gesetzt oder irgendein

KPI geht einfach

in die falsche Richtung. Es ist halt

Ja, sie haben eine Variable oder irgendeine Dimension in ihrem Ding drin, wo aus Versehen drauf optimiert wird und es entspricht, und das ist ja sozusagen, als ich angefangen habe, mir so ein bisschen nochmal die mathematischen Grundlagen, bin ich da zwar relativ schnell ausgestiegen, aber so die groben Ideen davon anzugucken, ist mir schon immer mal, so ein bisschen sind mir die nicht vorhandenen Haare zu Berge gestanden,

weil damit gerade in Tutorials mit anderen Nonchalance über relativ schwer wichtige Entscheidungen über was nehme ich hier, wie mache ich Feature Extraction, wie mache ich das jenes, mal so schnell drüber gebügelt wird mit einer Erklärung, wo ich dann denke von, ja, nee, du verwechselst, also die machen ein Beispiel, worum ging es da?

Ich glaube, es ging um Feature Extraction und die Ähnlichkeit von Repräsentanten im System.

Und sie hatten als Beispiel irgendwie Stolz und Vorurteil und irgendwie mit welchen Dimensionen

und wie man jetzt eigentlich rausfindet, welche Charaktere, wenn sie über diverse Dimensionen abgebildet werden,

sind eigentlich näher aneinander dran, also sind sich ähnlicher zueinander und gehen darüber hinweg.

und ich sitze danach da und sage, aber das war doch jetzt gerade

eben keine Erklärung für etwas, was man

automatisieren kann.

Das ist ja, du hast ja

a posteriori

einen eigentlichen

der ohne Menschen laufenden Prozess sinnbildlich auf eine Art erklärt, wo ich sage, das kann der ja gerade nicht, das heißt, was du mir gerade erklärt hast, ist, der macht dann nachher irgendwas draus und du kannst nicht mal mehr nachvollziehen, ob das jetzt wirklich Hand und Fuß hat oder nicht und dann kommt man an so einen Punkt, wie wir es jetzt gerade hatten, von müssen wir jetzt darüber nachdenken, dass da ein Bias im System drin war, den keiner gesehen hat, weil das Ding sich selber irgendwo ein lokales Maximum gesucht hat in der Optimierung und eben aus Versehen darauf optimiert hat,

dass die User möglichst lange den Katalog

browsen und möglichst wenig gucken,

damit Netflix möglichst wenig

Lizenzgebühren bezahlen muss.

Ja, das ist auch ein

Kundenbedingungs-Effekt. Vielleicht ist das eine mögliche Erklärung.

Und tatsächlich ist das

ein Phänomen, dass... Ja, ich habe mich tatsächlich

auf die Nutzungsdauer pro Kunde

optimiert. Also wie lange gucken

die Leute? Und wenn du jedes Mal

10 Minuten extra guckst für eine Suche, gucken die Leute

die längere Suche länger. Und UI-mäßig würde ich...

Ich würde dem auch zustimmen, dass es ein UI-Problem ist, im Sinne von

ich will manchmal einfach bloß den Button haben, zu sagen

blend doch mal aus diesen ganzen Vorschlägen

den ganzen Quatsch raus, den ich schon mal geguckt habe.

Ja, es gibt bestimmte

Filme, die gucke ich immer wieder. Da muss halt zum

35. Mal Big Lebowski laufen.

Aber das ist nicht

der Standardfall, wenn ich durch den Katalog suche.

Dann will ich einfach mal alles weghaben.

Und dass es solche Sachen nicht mehr gibt

und dass es nur noch über die Recommendation

läuft.

Also ich hätte gerne am liebsten einen Film

angezeigt und zwar genau den, den ich gerade in dem Moment

gucken will.

Ja, das geht ja nicht.

Das verkürzt ja die Komplexität menschlichen Daseins so massiv.

Naja, aber vielleicht kann der Algorithmus ja sich mit mir irgendwie koppeln

und irgendwie einen Faktor reinnehmen, dass er versteht, was ich gerade möchte.

Ich glaube auch nicht, dass er aus meinem historischen Guckverhalten sowas schon wüsste.

Ja, aber so durch vollständige Information.

Das ist ja das andere Problem.

Du kannst ja nur, also wie ist es auch in den Tutorials, bei wem war es?

Ich glaube, das war bei meinem aktuellen Coursera-Kurs.

Da war der Vergleich von Machine Learning hat im Prinzip zum Ziel,

ungefähr das menschliche Lernverhalten, was wir im Alter von vier Jahren haben, nachzubilden.

Und das würde ich sagen, das kriegen wir ziemlich gut hin.

Ja.

Also viele Leute machen ja Witze drüber, dass Machine Learning sich so anstellt wie ein kleines Kind.

Ja, es gibt ja haufenweise Memes, die immer, ist das ein Brokkoli?

Nein, das ist kein, doch, das ist ein Brokkoli.

Was ist das? Es ist kein Brokkoli.

Doch, das ist ein Brokkoli.

Na gut, das ist jetzt ein Brokkoli.

Und gleichzeitig wird dem aber eine ominöse Fähigkeit zugeschrieben,

die weit über das hinausgeht.

Also wenn man auf der einen Seite ehrlich sagt und sagt,

okay, wir versuchen so ein biologisch inspiriertes Lernverhalten

von einem Vierjährigen und der kann ja was.

Also das Hirn und das ganze Pattern-Matching, was wir haben

und dieses, wie trainiere ich das halt an?

Das ist ja nicht so, dass das nichts kann.

Aber ich kann halt auch einen Vierjährigen nicht drauf trainieren, mich anzugucken und sich zu fragen, wie geht es mir eigentlich?

Oder was bräuchte, was würde mir jetzt als Erwachsener eigentlich gut tun?

Dafür ist ein Vierjähriger halt nicht gemacht.

Ja, ich glaube auch eher, es ist halt unklar.

Deswegen sind halt die Erwartungen teilweise vielleicht völlig daneben und zu optimistisch.

Teilweise aber auch vielleicht zu pessimistisch, dass man glaubt, da geht gar nichts und manche Sachen, es gibt schon sehr beeindruckende Dinge, die man damit auch machen kann und Fortschritte, die da passiert sind. Insofern ist es halt einfach momentan nicht klar, was da überhaupt geht und was passiert. Das werden wir dann halt mit der Zeit irgendwann rausfinden.