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.
Naja, ich glaube, ein wichtiger Aspekt davon ist ja die Frage, das kommt jetzt aus dem ganzen Thema Komplexität, nutze ich es, um menschliche Kognitionsprozesse zu ersetzen oder zu unterstützen? Also das ist ja Augmentation.
Ja, ich würde auch augmentieren haben wollen.
Also es gibt jetzt auch so neue tolle Kontaktlinsen,
mit denen man sowas augmentieren kann.
Ja, sehr schön.
Und durch diese Augmentierung,
wenn die halt machine learning gestützt ist,
das ist natürlich schon super cool,
weil du halt einfach Zusatzinformationen bekommst,
die du vielleicht sonst nicht hättest.
Und das ist auf der einen Seite viel leichter,
es ist ethisch auch viel einfacher zu kontrollieren,
aber natürlich hängt jedes Startup
und jeder immer erstmal hin,
nein, nein, das machen wir hier, wir ersetzen das, wir lösen das Problem komplett.
Und ich glaube, das ist halt eine massive Sackgasse.
Also ich habe so ein paar Beispiele, die man immer sieht, ist ja auch dieses Thema Krebszellen erkennen.
Das ist ja gedacht als Augmentierung.
Das ist ja nicht dafür gedacht, dass der Arzt das nicht mehr drauf guckt,
aber das ist halt gedacht, dass wenn du halt eine gewisse Menge schon vorverarbeitete Zellbilder hast,
auf denen bestimmte Parameter wie irgendwie die Klumpigkeit und der Farbton und die Schärfe von der Umrandung
und ich glaube es sind so 15, 16 Dimensionen, nach denen das dann auch bewertet und gelabelt wird.
Und dann kannst du mit einer relativ hohen Konfidenz von irgendwie so 90 Prozent da halt die Sachen erkennen.
Und wenn ein Arzt natürlich die Unterstützung hat zu sagen, so guck mal, hier hat ein Algorithmus jetzt dir Prozentwerte drangeschrieben und gerankt,
guck dir mal bitte zuerst die hier an mit besonderer Vorsicht und bei denen bin ich mir unsicher und das da glaube ich ist es übrigens nicht,
Dann kann der natürlich nochmal anders rangehen, weil er hat einen Sparringspartner, er guckt selber nochmal drauf, was sagt seine professionelle Intuition zu diesem Ding, wo er sagt, das hätte ich irgendwie anders bewertet, nochmal genauer hingucken, ah ja, okay.
Und dann ist das tatsächlich, das ist Augmentation, das heißt, das Hirn von dem Arzt, der das bewertet, ist weiterhin dran zu arbeiten, wird aber entlastet, irgendwie die komplette Bewertung zu machen, sondern kriegt halt schon mal so ein bisschen Sparring dazu, ist aber, er ist der, der am Steuer sitzt.
Und das ist aber was anderes, als wenn du halt
sagst, naja, das Ding läuft auf Vollautomatismus
und wenn es tief geht, dann muss halt
jemand irgendwie ein Postmortem
machen. Im wahrsten Sinne des Wortes.
Ja.
Ja, es hat halt viele Wirklichkeiten. Das Problem ist halt,
dass du halt diese Granularität
nur durch vollständigere Informationen
auf dem höheren, ja,
Treffergrad bekommst, ja.
Das heißt, wenn du jetzt wirklich irgendwie so eine
Genschere machen wolltest, die die entsprechenden Teile
genau an der richtigen Stelle rauszieht,
dann müsstest du wahrscheinlich relativ hohe Datenmengen
und relativ hohe Experimente machen.
Und das Problem beim Machine Learning ist ja irgendwie,
dass er irgendwie selbstständig irgendwelche Zufallsexperimente macht
in irgendwelchen Datenpatterns, die wir gar nicht so genau sehen können,
weil er irgendwie da, weiß ich nicht, binär reinguckt oder so.
Und dann halt irgendwelche Zufallswerte generiert,
aus denen er dann irgendwie die wahrscheinlichste Wiederholung bemerkt.
Das sind ja keine Zufallswerte.
Das sind keine Zufallswerte.
Nicht alle Machine Learning Modelle haben irgendwas mit Statistik zu tun.
Das ist auch nicht so.
Ja, aber so ein bisschen
macht es erst mal schon, oder?
Kommt auf das Modell an. Es gibt sehr unterschiedliche Modelle.
Okay, dann müssen wir
das vielleicht nochmal in einer anderen Folge genauer
auseinandersetzen. Ja, also der Klassiker, wenn du
über die neuronalen Netze halt nachdenkst,
mit einer Backpropagation,
dann ist es halt schon so, das sieht für uns aus,
ja, der kriegt dann immer,
der hat sein,
häufig haben sie ein random
initialisiertes Modell. Das gibt's schon.
Und dann ist es aber so,
dass das an den Gewichten rumdrehen ist halt
eine deterministische Funktion.
Das ist, du hast halt,
du hast ja dein gelabeltes Datenset
und sagst so, hier kommt mein Input.
Liebes neuronales Netz, rechne mal.
Und dann kommt
dann nachher raus, ich glaube
der Output ist folgender und dann vergleichst du das
mit dem gelabelten Output, der zu diesem Beispiel
gehört hat und daraus ergibt sich ein Fehler.
Und dann macht man da eine
Bewertungsfunktion für den Fehler und er
sagt, okay, damit
dieses Bild oder dieser Input
besser vom
neuronalen Netz verarbeitet würde, hätten die Gewichte
anders sein müssen. Und er rechnet
sozusagen von dem Fehler wieder zurück,
was man an jedem Gewicht ein bisschen drehen
müsste. Das wird gedämpft, also nicht jedes
ist es sozusagen so, wie man am Steuer sitzt.
Wenn du merkst, dein Auto fährt ein bisschen in die falsche Richtung,
schlägst du ja nicht volle Kanne
90 Grad in die andere Richtung ein, sondern
der sagt dann, okay, ich habe hier einen Fehler
und der Fehler darf jetzt um 1%
nachsteuern.
Das heißt, wenn du 100 solche
Bilder hast, dann haben die vielleicht
um 30%
nachgesteuert, aber
es ist halt nicht so, dass es
random ist, sondern er rechnet immer aus,
wie hätte das aussehen müssen für die perfekte
Lösung, da ich aber nicht nur dieses eine Bild
bewerten können will, das wäre dann ja overfitting,
muss ich mich in der
Anpassung ein bisschen dämpfen
und jedes Bild, was
einen kleinen Fehler hat, korrigiert
das Netz immer wieder ein kleines bisschen nach.
Aber das ist nicht random an der
Stelle, das müsste sogar eigentlich deterministisch
sein.
Und ich glaube, dass man sie random
initialisiert macht, glaube ich, ist eine Idee,
dass man halt versucht, irgendeinen Bias zu
vermeiden, dass man irgendwie an einem
Extremwert einsteigt, der das Modell halt
völlig verzerrt.
Der Frage nach dem Motto, alles steht auf Null und dann kommt
er halt nie vom Fleck. Das ist so ein bisschen, wenn du dir an
Newton denkst,
wenn du halt eine Newton'sche Approximation
probierst, da ist es auch
immer so, dass du schon mal so grob in irgendeine Richtung
werfen musst, weil wenn du
halt irgendwie völlig bei Null oder
einem blöden Punkt
anfängst, dann
kommst du halt nie zum Ziel.
Naja.
Oder es dauert sehr lange.
Ja.
Ich überlege gerade.
Ja, also ich
weiß nicht genau.
Ich würde es eher allgemeiner,
also auch gerade was das Lernen
angeht, ich würde sagen Machine Learning oder so was,
Das versucht es halt, Software hinzubekommen,
die halt mit Erfahrung besser wird.
Und ich würde das tatsächlich so allgemein lassen.
Was das genau tut, kann man gar nicht so sagen.
Es gibt alles Mögliche.
Also es gibt auch, also das ist nicht immer in einer bestimmten Art,
sondern das ist halt so, es gibt die unterschiedlichsten Geschichten.
Ja, was man halt, ich glaube an einer Stelle,
ich habe da, der Trick ist ja, das ist ja ein technisches Werkzeug.
Das kann was, das kann bestimmte andere Sachen nicht.
Und da habe ich erstmal ja null Probleme mit.
Und ich glaube, wo wir in der Öffentlichkeit ein Problem haben, ist eben dieses Zuschreiben, es ist so komplex, dass man ja nur über Vereinfachungen, über Bilder darüber reden kann.
Und wenn die Leute aber dann mit diesen vereinfachten Bildern weiterdenken wollen, dann führt das halt ganz schnell zu logischen Schlussfolgerungsfallen, weil man halt auf Basis dieser Analogien nicht mehr dem technischen Kern gerecht wird.
Und ich meine, was ich spannend finde, ist erstmal, wenn man diese Unterteilung nochmal anguckt zwischen Supervised und Unsupervised, dann sind gerade die Supervised-Sachen natürlich immer interessant, weil ich kann mir die Extremwerte nochmal angucken und kann schauen, also ich kann es halt evaluieren und ich kann halt prüfen, wenn ich feststelle, ich habe hier komische Fehler drin, die ich so nicht beabsichtigt habe, woran liegt denn das?
muss ich noch eine Dimension dazunehmen,
fehlt mir bei einer Dimension irgendwas, ist in meinen
Eingangsdaten irgendwas komisch, weshalb
das Training in bestimmten Varianten
halt in die falsche Richtung läuft
und kann das dann halt auch immer
weitertreiben, weil das ist ja was, das kann
Machine Learning an der Stelle nicht,
Machine Learning kann ja nicht selber feststellen und
sagen, du brauchst eigentlich ganz andere
Eingangsdaten für dein Problem.
Das kann es dir ja nicht liefern.
Doch, doch, doch.
Also, naja, man kann sich schon
angucken, zum Beispiel man kann sich die Kurve angucken
mit zunehmenden
also
man trägt dann halt
den Trainingserror
gegen den Testerror auf
zum Beispiel, dann kann man sich halt
je nachdem wie das dann aussieht
also wenn die beiden Kurven sehr weit auseinander liegen
also sozusagen wenn man
wenn der Fehler auf den
Trainingsdaten gering wird
aber auf den Testdaten nicht
und die beiden Kurven sehr weit auseinander liegen
dann weiß man, man hat zu wenig Trainingsdaten
oder die falschen
oder die sind halt nicht gut verteilt.
Wenn das Ding
sich über, wenn die Kurven
anfangen sich zu überschneiden oder so, weiß man halt, okay,
ja, man
overfittet gerade zum Beispiel.
Aber das sind ja Sachen, die werden
zum Beispiel, da kommen wir in den Bereich, das ist
Augmented und das ist ein Prozess, den wir als Menschen
halt begleiten. Das ist halt
was, also dann diese Entscheidung zu treffen,
jetzt ist es so weit, dass ich das halt anders machen
muss, das kann das Modell nicht
für dich und das Modell kann dir auch nicht sagen, was
das andere ist, was es braucht.
Ja.
Gehen wir nochmal auf die
Krebszellen. Die haben dann halt da irgendwie
ihre Dimensionen, wonach sie das Zeug
bewerten. Und das sind sozusagen die
Erkenntnisse von, okay, wir nehmen
mal die Daten, die die Ärzte
uns gesagt haben, danach bewerten
sie, ob so ein Ding
gut ist oder nicht. Da ist ja der Vorteil,
dass in der Medizin, da ja auch die Prozesse
gut standardisiert werden, dass man halt
eben das auch explizieren kann, dass man nicht irgendwie
fünf Leute fragen müssen, die kratzen sich am Kopf
und ja, wie mache ich das eigentlich so? Und das ist ja gut
standardisiert. Und aber ob du das, wenn
du es im mathematischen Modell dann tatsächlich hast,
über so ein, dann kannst
du, ich gehe mit, man kann halt
über die Evaluation,
über die Qualitätskriterien
nachher rausfinden,
Mist, hier stimmt was nicht.
Aber zu einer Entscheidung zu kommen,
zu sagen, du übrigens, wir müssen
uns noch angucken, ob das Ding Fransen
hat oder keine Fransen.
Das kann das, das ist eine semantische
Ebene, die kann das Ding dir nicht sagen.
Für das Bell
sind das ja nur, also ich weiß
es nicht, also
Was macht das? Du hast ja
entscheidend irgendwas da gerade in der Intention, was dir sagt,
da versteckt sich was Interessantes.
Finde ich jetzt interessant.
Ja, also
ich weiß es nicht, also
ich
auch, also
dass da
das Problem
würde ich auch daran, also ich meine, gerade
in der Medizin, naja gut,
ist auch wieder so ein weites Feld dann direkt.
Es ist ja so,
dass wir momentan ja eigentlich sehr,
sehr grobe
Geschichten machen. Also wenn man ja
so eine Diagnose und dann
was macht man jetzt irgendwie, wenn man die
Diagnose hat? Das ist halt
sehr, sehr, auch was gibt man für
Medikamente? Das ist ja alles super grob.
Das ist ja überhaupt nicht angepasst auf
jemanden individuell oder so.
Nee, nee, das ist also
Ja, und wenn jetzt, also man könnte jetzt das aber so angenommen, man nimmt jetzt, weiß ich nicht, irgendwie Daten, was auch immer, alle möglichen Daten, die man jetzt über irgendwie einen Patienten hat und ein Modell sagt einem jetzt, okay, ich nehme jetzt nicht irgendwie zwei Tabletten von der Sorte jeden Tag oder so, morgens oder abends, keine Ahnung, sondern irgendwie wir mixen jetzt folgende Wirkstoffe in der Kombination zusammen und das muss zu den Zeiten.
Das könnte ein einzelner Arzt ja niemals machen, im Grunde, in der Granularität.
Ja, nee, aber ich bin ja gerade an einem, ich bin, nochmal ganz kurz zu meinem, da würde ich gerne anknüpfen, aber wo ich halt davor stehe, ist, wenn wir Feature Extraction halt haben,
Und ja, durchaus teilweise eine Qualität von Features, die eine sehr hohe kognitive Leistung erstmal haben.
Deswegen geht mir dieses Krebszellenerkennungsding nicht aus dem Weg.
Es geht ja nicht darum, dass dieses, es ist ja kein Image-Processing, was da stattfindet.
Sondern, also ich habe ein ganz konkretes Modell gerade, was da steht.
Und die machen halt kein Image-Processing, sondern die haben Feature-extrahierte Sachen, wo Menschen halt auf so einen Fleck drauf gucken und sagen, der hat folgende Eigenschaften.
Und das sind sehr, sehr kognitiv hochwertige Eigenschaften.
Also hat es eine regelmäßige Kante?
Ist es irgendwie besonders scharf abgegrenzt?
Hat es irgendwie kleine Ausstülpungen?
Hat es dies, hat es das, hat es jenes?
Und das sind die Features, die dann in das Modell reingehen, wo er sagt, okay, bei dem, mit diesen Eigenschaften würde ich sagen, das ist eine Krebszelle, bei dem anderen, das ist es nicht, bei dem nächsten, das ist es und darauf kannst du halt ein Modell trainieren.
Wenn du sowas trainierst, so ein Modell, und du findest mit den Qualitätskriterien, die du zwischen deinen Tests und deinen Trainingsdaten heraus, dass das gerade nicht passt, ja, dann kannst du das als Signal nehmen, dass du als Mensch hergehen musst und sagen musst, das Modell reicht so nicht, das kann ich so nicht in Betrieb nehmen.
Aber das Modell selber kann dir nicht sagen,
ja, überleg dir mal noch mal, ob die Farbe eine Rolle spielt.
Das kann das Modell halt nicht.
Da würde ich sagen, also das kommt halt darauf an,
was man für ein Modell nimmt.
Aber wenn man jetzt die Bilder nimmt,
ohne die ganzen menschlich extrahierten Features,
würde ich sagen, also die Deep Learning-Modelle,
die machen genau das.
Die extrahieren die ganzen Features selber.
Ja, natürlich.
Aber was sie nicht können, sie können sich nicht ausmalen, welche anderen Daten ihnen helfen würden, noch akkurater zu werden. Also Beispiel, du gibst denen Bilder, das Ding kann dir ja nicht sagen, ey, und wenn du mir ein UV-Bild davon machst, kann ich es besser.
Ja, nee, gut.
Das meine ich gerade. Sie können nicht aus ihrem System raus. Sie sind ja selbstreferenziell, sie sind in sich beschränkt. Und das ist das, wo ich meine. Das ist ja das, was ein Vierjähriger kann.
Du kannst den Vierjährigen trainieren
und der kann das,
aber der kann halt häufig nicht die nächste Leistung,
also der kann noch nicht die nächste Leistung bringen
und sagen, ja, da draußen in der Welt
ist ja noch mehr, von dem ich noch nicht weiß,
was hier vielleicht jetzt passen würde.
Deswegen, also ja, das kann mit den Daten arbeiten,
das kann auf den Daten ganz coole Sachen machen
und auch diese automatischen Feature-Experiment,
die können alles.
Aber dann zu sagen,
du hast mir jetzt Fotos gezeigt von den Zellen,
ich bräuchte aber mal noch,
was der die letzte Woche gegessen hat.
Ja, die Auflösung beim
Vieljährigen ist auch einfach viel höher.
Viel mehr Informationen
drin.
Viel, viel mehr.
Keine Ahnung, was Menschen machen,
weiß ich jetzt nicht.
Aber
dass man andere Informationen mit reinnimmt,
das geht auch.
Was ich aber sage ist, das Modell kann
dir nicht sagen, gib mir diese Art
von anderen Informationen.
Nö, aber man kann dem alle geben.
Genau, und ich glaube,
Aber das ist etwas, ich versuche noch irgendwie zu dem Punkt zu kommen, wo ich da stehe,
ist, das ist was, wo Machine Learning einfach falsch wahrgenommen wird.
Das löst irgendwie diese und jene und so Probleme und alles.
Aber Machine Learning kann nie die eigenen Grenzen erkennen und überschreiten.
Das geht halt nicht.
Und das ist für mich dieser Punkt, weswegen Augmentation so wichtig ist,
dass du dort jemanden hast,
dass du dort jemanden hast, der
als körperliche, biologische
Entität in der Welt ist und in der Lage
ist, seine eigenen Grenzen
infrage zu stellen und zu überschreiten.
Bei der
Grenzerkennung gehe ich mit.
Also, dass ein Modell Safety Belts haben kann
und sagen kann, du, hier komme ich an meine Grenze.
Ja, aber es kann nichts selber sagen,
ich mache jetzt ein Forschungsprojekt und finde raus.
Aber man könnte ja
vielleicht mehrere Netze miteinander kombinieren.
ja, dass du einen Cluster von Netzen hast,
wo ein Netz auf sowas achtet.
Das ist der Mensch. Das ist nicht das
Machine Learning, was das macht.
Ja, also
ja, keine Ahnung.
Wir sind halt noch nicht so weit.
Wenn wir Katzen von Hunden unterscheiden können,
sind wir total glücklich. Also insofern,
ja, das mal schauen.
Keine Ahnung.
Ich finde, das mit den Katzen von Hunden unterscheiden wäre ein super Schlusswort
für diese Machine Learning-Folge.
Ja.
Hattet ihr noch einen wichtigen Punkt?
Ich wollte euch nicht ganz so abwägen.
Ja, tatsächlich
nee.
Sonst machen wir einfach das nächste Mal.
Stimmt, wir sind auch schon eine ganze Zeit dran.
Ja, und es ist spät.
Was ich noch spannend fände, wenn vielleicht auch Hörer
tatsächlich an der Stelle
wollen, dass wir dem Thema treu bleiben
und damit nochmal, weil ich glaube, das können wir nochmal
ein bisschen, wenn ich da tiefer eingegangen bin,
nochmal ein bisschen praktischer und ein bisschen Python-orientierter
machen, weil wonach ich tatsächlich momentan
so ein bisschen Ausschau halte, ist so ein bisschen Spielprojekte.
nach denen ich mir nämlich mal genau
das ausprobieren will, so in welchen Anwendungsfällen
von qualitativer Bewertung
und für diese ganzen unterschiedlichen Teildisziplinen
von Machine Learning,
auf welche Arten von Daten kann man das eigentlich mal
loslassen, weil da merke
ich so, jetzt langsam muss ich da mal einfach
irgendwas selber bauen mit
den eigenen Daten, die hier so rumfliegen.
Vielleicht gibt es ja auch noch ein paar Leute, die
gerade ein Haus gebaut haben und
ein bisschen Hausautomatisierung machen.
Wir kommen so nicht. Oh ja, das ist auch noch
ein großes Thema. Aber dann, genau, schreibt
das doch an hallo at peißenpodcast.de
und sagt uns Bescheid, wie ihr das fandet.
Ja.
Ja, dann einen wunderschönen
guten Abend. Bleibt uns gewogen.
Schön, dass Christian wieder dabei war.
Gerne, jederzeit.
Ja, dann
hören wir uns nächstes Mal. Alles klar.
Tschüss. Tschüss. Ciao.