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

Ja, hallo liebe Hörinnen und Hörer, willkommen beim Python Podcast in der 28.

Episode heute.

Es ist ein bisschen wieder eine Laberfolge, und zwar über Machine Learning heute.

Ja, hi Jochen, du bist wieder dabei.

Ich bin der Dominik.

Ja, hallo Dominik.

Und heute ist auch der Christian wieder.

Christian haben wir auch dabei.

Hallo, willkommen.

Danke.

Ja.

Habt ihr euch schon was genaueres überlegt oder wolltet einfach so ein bisschen die Dönikis 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 Webentwicklung und so.

Ja, und bewegen 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 angehen.

Wir wollten auch mal eine Folge machen, wo wir genau diese Bild-In-Interprint-Implementierung in Python dazu erklären.

Aber das wird dann eine der nächsten Folgen werden.

Was wir euch aber nochmal fragen wollten, wenn ihr Feedback und Kritik und so habt, wie immer an hallo.python podcast.de und sagt uns auch mal, auf welche Themen ihr so besonders Lust hättet.

Dann werden wir die auch nochmal mit in unsere engere Auswahl nehmen.

Ja.

Bei Schienung, es gibt was Neues.

Es gab eine möglichen Updates von Paketen NumPy, Pandas, Pandas auch?

MyPai?

Nein, Pandas nicht.

Doch, Pandas, Pandas tatsächlich auch, fällt mir jetzt gerade so ein.

Ich hab's das hier gar nicht aufgeschrieben, aber ja, gab es jetzt auch letztens irgendwie eine neue größere Version 1.2.

Ich bin 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 JupyterLab 3 ist draußen und Spacey, also die ganze Natural Language Processing-Geschichte, nochmal Version 3 ist jetzt gerade erschienen mit Support für Transformer.

Also genau, das war mal so das erste, ich habe immer anguckt, was ist denn alles Neues passiert, weil ich da auch schon lange nicht mehr drauf geguckt habe 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 wollte, es gab einige richtig coole YouTube-Tutorials, die ich fand, die ich bisher zu die besten nicht kennengelernt habe 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 reingucken kann.

Fand ich super.

Genau.

Ja.

Genau, wollen wir so ein bisschen News machen?

Also es gab noch so 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.

Dann gibt es irgendwie für PIP's einen neuen Resolver.

Ich weiß nicht, hat es sich den irgendjemand schon mal angeguckt, so ein bisschen?

Ich hatte drüber gelesen und mir ihn nochmal auf die Wiedervorlage gepackt.

Tatsächlich bin ich mit, was das Resolving angeht, momentan, ich bin immer noch an dem anderen Ende 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 einen der neue irgendwie Quatsch macht.

Aber nee, erstmal nicht negativ aufgefallen.

Ja, ne, 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, um irgendwie alles neu zu installieren und dann wieder reinzunehmen, dann geht es irgendwie wieder.

Ja.

Aber ich habe es auch eigentlich nicht.

Also insofern, ich habe es nicht, es hat nicht wehgetan.

Insofern scheint alles halbwegs gut gelaufen zu sein.

Wobei das, was du, also wenn du das erzählst, ist es aber genauso ein Fall von, ja, nee, das kann ich nicht leiden.

Ja, ja, das ist so ein schlechtes Gefühl, wenn ich sowas bemerke.

Ich spiele halt ein bisschen rum mit so einer Form von Log-Files, 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 fertig gebackene Virtual-Enfs 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 seinen Log-File mit.

Und das konkrete Tool, was daran 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 so 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äg, Strich, in dem Fall Bateau oder auch irgendwas anderes.

Du musst vielleicht 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 durchgerecht 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 es XY machen und dann sagt er im schlimmsten Fall, nur ja, Moment, weil zum Beispiel ein anderer im Projekt hat was committed, weswegen des Logfiles 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.

Und das ist ein Use Case, den habe ich nirgendwo 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 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 riesen Tool hinterherlaufe, dem man ständig sagen muss, du, ich brauch das aber so oder so.

Okay, und vielleicht, das machst du mit Bateau oder das Tool heißt Bateau?

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, AppEnf.

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 bei Toe sein, das kann irgendein Python-Package sein, was ein Konsole-Skript hat, was genauso heißt wie das Skript, was du in deinem Repo ablegst.

Und dann installiert er alles das, was in dem Requirements-Textfall drin steht, in eine geheime, in Anführungszeichen, Position.

Also es heißt dann irgendwie Punkt, dein Tool-Name, Schräg, Strich und dann werden da so gehashte Virtual Envs drin erzeugt und auch wieder aufgeräumt und ruft im Prinzip dann bloß Punkt da aus dem Virtual Envin und dieses Konsolskript auf.

Viel mehr macht er nicht.

Und das ist das App-Env, um so einen Bootstrapping-Mechanismus da einmal abzubilden.

Und Bateau ist ein Werkzeug, was das halt benutzt.

Wir haben so Bateau-Projekte, 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, dass die haben 12, 15, 20 so Projekte rumfliegen, die sie jonglieren.

Und jedes davon, dann, eins davon hat ein Kunde halt mal in Dreivierteljahren nicht angepasst 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 ja bloß das Repo nehmen, rufst Punkt 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 er alles im Self-Bootstrapping und auch ohne, dass in deinem System was anderes installiert ist, außer Python selber.

Also da sind auch noch 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, dass 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 ein Python habe, was nicht nur ein bisschen kaputt gemacht wurde, dass er sich daraus halt bootstrappen kann und dir dann ein voll funktionier

es Virtual Enf auch zusammenbaut.

And du eben nie sagt und du musst nie überlegen, muss ich das Virtual Enf just 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 wäre so ein Ding, mit dem spiele ich in letzter Zeit so ein bisschen rum.

Weil das im Grunde auch ein Großteil von diesen Dingen halt tut.

Probleme lösen, wie man seine Umgebung 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, das hinterher dann auch Pakete für Pipe PI rausfallen und Dokumentationen und irgendwie 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 Öf, weil da schreibt man halt alles in Jupyter Notebooks, beziehungsweise das ist halt eigentlich so eine Art Idee und plus Projektverwaltungsdings irgendwie und genau, also es ist halt quasi so die Antwort auf die Frage, was wäre, wenn ich alles in Notebooks machen wollte.

Und dann kommt so 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 Idee 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 Gruz, auch 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 encouraged irgendwie in Haufen sehr schlechte Softwareentwicklungspraktiken 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 drumherum arbeiten und manche Sachen sind halt auch sehr, sehr, 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 der Code tun soll, halt irgendwie zusammen.

Gab es diverse Versuche, das irgendwie hinzukriegen.

Ich glaube, mit den ersten war, war das der erste Versuch war Mathematiker, aber das ist halt irgendwie nicht so richtig populär geworden.

MATLAB, ja, RStudio ist halt, geht auch in die Richtung.

Und jetzt halt Jupyter Notebooks, damit würde ich sagen, war es halt so, es hat, hat es in gewisser Weise einen Durchbruch gehabt und wird jetzt überall verwendet und halt auch JupyterLab nochmal so als komplette Idee irgendwie dafür.

Und genau, da gibt es dann halt auf diesen Talk auch eine Antwort von einem, der sich, also der, derjenige, der sich diese NBDF-Geschichte überlegt hat oder dann halt ja, die dann entstanden ist bei der Entwicklung einer Bibliothek, das Jeremy Howard, der hat der hat halt FastAI, die Library, das ist auch so ein Rapper um PyTorch im Grunde, damit geschrieben, auch ein Buch darüber geschrieben, das auch wahrscheinlich so das empfehlenswerteste Buch über P

yTorch ist.

Und das Buch ist auch komplett mit NBDev geschrieben und das ist halt schon, das hat auch schon sowas sehr, sehr Cooles.

Und der argumentiert halt ja, also für mich ist das alles viel einfacher.

Also einmal diese ganzen Hässlichkeiten und da muss man leider sagen, es ist halt, es gibt viele Hässlichkeiten, 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, ich erzeuge mir so ein MBDev-Projekt oder man sagt MBDev New irgendwie, ich weiß jetzt gar nicht genau, wie man das Papier installiert hat und dann erzeugt es einem halt so eine Projektstruktur, so ähnlich wie bei Poetry, Poetry Init oder so.

Nur es macht noch mehr, deutlich mehr.

Und ja, dann für ihn, Alter, ist es halt total super, weil die Pull-Requests werden halt besser.

Und er reviewed 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 einen Pull-Request stellt für so, jetzt sieht die Visualisierung von irgendeiner Geschichte besser aus.

Ja, da muss man erstmal die Daten zusammensammeln, das dann irgendwie ausführen und dann sich das angucken, oh, wo guckt man sich das an?

Wie generiert man diese Grafik eigentlich?

Das ist alles ziemlich umständlich.

Und da hat man es halt dann direkt sehen, okay, ah, sieht besser aus als vorher, super, Pull-Requests akzeptieren, fertig.

Und auch ein schöner Vorteil ist halt Tests und so, die sind da auch direkt mit im Notebook.

Also normal, also 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 ein 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, das ist schon sehr nett.

Also ich finde es auf jeden Fall einen sehr interessanten Ansatz und ja, also es.

Ist das nicht dann irgendwie so ein ewig langes Endlos-Scrolling durch irgendwelche Projekte dann durch, von Top to Bottom oder?

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, also es ist ein, ähm, man kann auch Dinge dann in der Library ändern und die werden dann in die Notebooks zurückgesynkt, der Code, und umgekehrt halt.

Und es 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 dranklatschen.

Dem Code, der dahinter herausfällt, den sieht man das nicht an, aber im Notebook ist es 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 dazu kommen.

Ja, also es ist sehr anders, als man normalerweise so entwickelt, aber ich finde, das ist interessant.

Und ja, ich meine, ich meine, ich muss sich so ein bisschen zwingen, also ich muss mich manchmal so ein bisschen zwingen, da immer mal so reinzugucken in so solche Dinge.

Ich habe auch zuerst, muss ich gestehen, Notebooks hielt ich erst für ziemlichen 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, also schon wahrscheinlich relativ früh, kurz nachdem sie irgendwie da waren.

Und dann aber gesehen, dass das 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 auch halt auch sowas, was der Autor von Imdigen 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 sind alle immer sehr skeptisch zuerst.

Weil das natürlich auch immer so eine harte Änderung ist.

Ich merke das ja auch, ich meine, ich bin eigentlich VI-User und ich habe mich 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 da ja doch tolle Sachen.

Also was ich mich frage, macht ihr gerne Notebooks?

Könnt ihr da 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 einer 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 Webserver hochfahren und dann da die Module oder die Routen aufrufen, sondern ich sehe halt irgendwie direkt, ob diese kleinen Teile gehen oder nicht.

Das ist erst so ein bisschen ein 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 es zu tun hat.

Weil also im Kern ist ja die Handlichkeit, dass das Python eh schon hat.

Und ich habe jetzt eher 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 halt auch fair verteilt durch die Gegend, wo ich experimentellen Code habe, wo ich merke, entweder meine ich so, dass ich da einen Pi-Test reinwerfe, relativ leichtgewichtig, um mir auch für Sachen, die ich gerade sketche, gleich auch die Testcases dann raus im Prinzip rauszulassen, indem ich sage, ich muss gerade mal was verstehen und die backen und dann habe ich gleich einen Test Case zu.

Oder weil ich eh bloß einen 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 verstehen möchte, da merke ich, da bin ich halt häufig in so Systemintegrationen und Sachen drin.

Und ich fall irgendwie, 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 stolper 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 wie das Code.

Und da kann man die mittlerweile auch sogar integrativ einfach nutzen.

Das heißt, du hast dir dann einfach nur irgendein Bei liegen wie den anderen Code, den du auch drin hast, 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, es ist schon, also ich finde, also das für mich eine 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 dann macht man irgendeinen blöden Fehler und dann ist halt das Ergebnis von einem Stundenberechnung weg.

Das ist halt, so das kann einem im Notebook im Grunde nicht so wirklich passieren, weil dann hat man halt die Zelle, die das irgendwie macht, ausgeführt.

Und wenn man selbst wenn man irgendwo anders einen Fehler macht, dann macht es halt erstmal nichts kaputt, sondern dann ändert man das halt und dann führt man es nochmal aus und dann geht es halt weiter.

Und das kann, das beschleunigt viele Dinge durchaus.

Oder wenn man gerade mit ganz mit großen Datenmengen irgendwie viel macht und die nicht so einfach mal laden kann.

Also gerade 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.

Und ja, also das war auch in dem Talk von Jewel Grouse 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 Datasets sind halt groß und das nervt, wenn ich das irgendwie verliere und quasi das gleiche Argument, was ich jetzt auch gerade gebracht habe.

Und er meinte dann so, ja, Moment, du hast irgendwie, du machst explorative Datenanalysegeschichten mit Datasets, die so irgendwie so mehrere Gigabyte, 12 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 und sagst, du willst nicht aus Versehen irgendwas verlieren, dann ist mein Gefühl, die 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 unaufensichtlicher, 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, so ein bisschen so die das Publikum.

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

Ich wollte gerade sagen, also ich habe also ein paar Müll-Nutbooks, 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 vor der Struktur vielleicht manchmal sogar entfernen, aber das ist echt hilfreich.

Weil also ich würde das halt nie irgendwie 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 jetzt kann man dann einfach copy-pasten eigentlich und es geht.

Also das finde ich schon.

Also wo ich gespannt bin, das reißt jetzt so, jetzt kriegen wir so fast die Kurve zu 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 und dann halt drin herum editieren, um so ein bisschen mit dem Code zu spielen.

Ich bin mal gespannt, weil ich mich jetzt so 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 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 drauf.

Ja, es ist immer blöd, wenn er es nicht selber ausprobiert, dann ist es schnell wieder weg.

Ja, eben, also wenn man die Zellen einfach nur nacheinander.

Viele Tutorials oder Videos, die man so sieht, bestehen daraus, dass jemand dann halt so eine Zelle nach der anderen ausführt.

Das hilft einem natürlich nicht so richtig wie.

Also aber was toll ist und was man machen kann, ist halt selber dann halt irgendwann mal so da mit 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 Tutorialreide erwähnt, äh, NumPy for Grandmas und Panas for Grandmas.

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 da nicht, aber das ist ja nicht so schlimm, weil er hat ja die Lösung, dann hätte er ja gezeigt.

Und 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 laufä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 so mir irgendwelche komischen Fehler, bin ich schuld oder die Umgebung schuld, da ist es natürlich schön, von einem definierten Zustand aus loszulaufen.

Ja.

Zumal ich auch eigentlich, eigentlich würde ich halt sagen, mir liegt es total, Sachen halt erstmal Ende-End 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, kann man sich mal angucken, ist ganz nett.

Ja, genau, und aber genau, eigentlich ein ganz guter Einstieg in dieses Machine Learning Ding.

Genau, Machine Learning.

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 on PyTorch, von dem du am Anfang sprachst?

Fast.ai.

Fast.ai.

Okay.

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.

Ja.

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, guckt 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 ist, wir müssen nachher noch ein bisschen in die Themen, glaube ich, die Stichworte, glaube ich, 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 Powerfaktor von 40 drin, was ich an Geschwindigkeit rausholen kann im Vergleich zu, wenn ich es aus 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 8 vorbei.

Insofern, also das ist so erstmal 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 Vektoroperationen 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 dann jetzt Unterstützung für diese Vektor 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 Vektoroperation 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 dann sind so Auswirkungen, die, 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, ja, dieses Hardware-Thema ist natürlich total interessant.

Ich meine, im Grunde hat man da nur bei einer speziellen Art von jetzt 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 Support-Vektor-Maschinen oder so, da hilft einem das alles nicht so richtig.

Aber eben bei neuronalen Netzen halt schon.

Also alles, was irgendwie mit Matrizenmultiplikationen 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 sagt so irgendwie, keine Ahnung, ein Skalar ist irgendwie so Tensor, Nullterstufe oder sowas, und dann hat man halt irgendwie einen Vektor und dann irgendwie eine Matrix und dann irgendwie eben im allgemeinen Fall Tensoren oder Arrays mit N-Dimensionen.

Was ist der Unterschied eines Arrays mit N, also was ist der Unterschied eines Tensors in einer Matrix?

Das ist genau eigentlich, 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 wir ja, 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, du musst jetzt aber 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, die nächste Stufe wäre für mich jetzt halt irgendwie ein Vektor.

Also irgendwie.

Eine Richtung in einem Raum.

Ja, das ist dann schon eine Interpretation, was das halt nun ist, aber das einfach nur so als Struktur.

Und das nächste wäre halt eine Matrix.

Genau, also ein Skalar ist ja tatsächlich erstmal bloß ein Wert, der für sich steht.

Der ist dimensionslos.

Und einen Vektor kann ja n-Dimensionen haben.

Und es 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 er n-Dimensionen, aber tatsächlich würde ich jetzt sagen, der hat halt irgendwie ist halt eine Liste von Zahlen und hatte halt als Struktur eine Achse.

Vielleicht einfach mal ein anderes Wort.

Genau, ich kann, ja die Frage ist ja, 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, und

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 eine 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 halt zwei Achsen hast, so in zwei unterschiedliche Richtungen und das nächste wäre dann halt drei.

Das hast du dann halt bei Bildern, da hast du dann halt nicht nur, also du kannst 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 Dreidimension, über einen, statt einen Quadrat, über einen Würfel.

Ja, genau.

Ja, aber mit dem Würfel darstellen, glaube ich, das wird schwierig, weil was ist dann die vierte Dimension und so die fünfte und so?

Ja, das geht immer weiter.

Das ist halt einen Hyperwürfel.

Genau.

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.

Also einer für halt Höhe, Breite.

B sind aber, wenn die so nebeneinander macht, oder?

Dann hast du da drei Matrizen nebeneinander und dann hast du hinterher Reihen von Matrizen nebeneinander.

Aber die legt man übereinander und das spielt auch tatsächlich eine Rolle, dass es 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 Trainingsbeispiele.

Die Labels, oder?

Die Labels sind getrennt davon, aber du hast halt sozusagen mehrere Trainingsbeispiele.

Du hast immer Badges von so Uldern.

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 genau, 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 man es

vielleicht so ein bisschen visualisierbarer.

Ja, 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 Abakuss, der dann hin und her schiebt.

Ja, sondern wo man die halt auf vielen Datendingern dann halt ausführt, sozusagen diese SIM-D-Geschichten oder Vektorrechner halt.

Und jetzt haben wir halt Tensorcores 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 kleinen, so vier Kreuz-4-Matrizen, aber immerhin.

Die machen halt dann in einem Takt schon Multiplikation von zwei, vier Kreuz-4-Matrizen, wo du normalerweise viel, viel mehr Takte brauchst, wenn du das halt irgendwie dann halt in Vektoroperationen machst oder halt in der CPU als Skala.

Und ja, das ist eigentlich ganz faszinierend zu sehen, dass das jetzt so gerade mit der Zeit passiert.

Ja.

Das ist auch der Hauptgrund dann, warum die Grafikhardware 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 oder beziehungsweise halt diese Convolution-Operationen halt, die man für diese Convolutional Neural Nets halt braucht, die sind halt damit super umzusetzen.

Die braucht man halt auch für Spiele und so.

Die machen ja auch im Grunde solche Sachen.

Ich muss da vielleicht nochmal für Eidehöre erklären, was ein Convolutional Neural Network ist.

Vielleicht einmal genug ganz kurz.

Da hatten wir doch schon mal eine Episode zu.

Da war das nicht die Folge 8.

Ehrlich gesagt, ich weiß nicht, ob ich das so, kann ich jetzt aus dem Stiggreife auch nicht.

Also im Grunde, das ist halt eine spezielle Art von neuronalem Netz, wo halt.

Zwischen den verschiedenen Layern, zwischen den Ebenen irgendwelche Dinge passieren.

Ja, 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 Texte, aber es ist, es ist, es ist halt eine Operation.

Man kann sich das, man kann, ja, muss man sich eigentlich auch mal ein Bild so angucken.

Ich glaube, das kann man nicht so wirklich gut erklären.

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 Transformer, ist zum Beispiel total heiß gerade.

Und ja, das funktioniert dann, es gibt so unterschiedliche Architekturen, TPUs und so, Tensorkurs.

Und das einzig Blöde ist jetzt, dass außerhalb von das eigentlich, das eigentlich, was halt wirklich doof ist, dass halt Nvidia da so ein Monopol auf den ganzen Kram hat.

Das ist so richtig, 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 haben 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, 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 Rechensentrum und da würde ich jetzt gerne irgendwie Machine Learning-Server irgendwie mir hinstellen oder so, dann sagen die ja, ja, klar, super hier.

Nimm doch mal die, weiß ich nicht, was haben wir da?

A 100 Karten oder so.

Aber die kosten dann halt einen Arm und ein Bein.

Wobei das, das finde ich, also ob die einen Arm und ein Bein kosten, kommst du 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 zu Recht.

Also die haben, die haben sehr stark angefangen, über Lizenzverträge zu knebeln.

Also speziell mit dem Thema, dass, weißt du, die meisten Puppelgrafikkarten 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 Gamer-Szene bedienen und verbietet dir aber halt für die für die normalen Gamer-Grafikkarten, sie verbieten es dir lizenztechnisch einfach, sie dafür einzusetzen.

Die 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 dann 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 RAM-Größen und was du denen an Ressourcen zuweist.

Also 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 dir 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 Busssystemen, die die Karten untereinander verbinden.

Da kostet halt das Stück nur 250.000 Euro.

Und 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 unterschrieben, 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, da ist extrem viel Marketing-Fluff momentan draußen und selbst die Data-Sheets 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 ein Netzwerk und CPU und alles irgendwie einmal als ein Bundle.

Und da findet man im Netz auch für die ganzen klassischen Frameworks, die man jetzt so hat, Ubi PiTorch etc.

Anleitungen, wie man die auf den Teilen dann betreibt.

Das heißt, das ist so für mich gerade der Vektor, 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 Plattfisch bemerkbar, dass viele von den Frameworks dann mit den AMD-Karten wir 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 zurzeit.

Also das kann man.

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 haben, die scheinen das Zeug schon direkt an der Fabrik abzuzweigen.

Ich habe ein paar Lieferanten gesprochen, die eigentlich gerne 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 Problem, die es dann wirklich zu bekommen.

Ist manchmal gar nicht so einfach.

Ja, also genau diese Marktsegmentierungsgeschichte ist halt das, was man dann, das ist, das ist halt im Grunde die Art, wie man, wie man, wenn man jetzt ein Monopol hat, wie man das zu Geld macht.

IBM hat das früher ja dann auch schon gemacht, so man macht dann halt Functional Pricing, ja, man guckt halt, macht den Preis halt so, dass es zu dem Marktsegment, das man budieren möchte, passt.

Im Grunde können die ganzen Dinger mehr oder weniger das gleiche, ja.

So die RTX-Karten, also zum Beispiel, die können im Grunde fast das, also die Gamer-Karten können halt im Grunde das gleiche, was halt die 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 einem was 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.

Halt die Frage, ob man sich das, 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 so irgendwie einfach an Strom.

Und so bei den, bei den, glaube ich, bei den 3090 RTX, 3090-Karten, die aktuellsten, da ist es so, dass da musst du halt dann, also die Netzteile, die normalen 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.

Und musst du halt immer dazu sehen, dass du da mal genug Platz lässt und dann irgendwie Leute, also da gibt es ganze Bastelzähne, die versuchen, das irgendwie richtig hinzukriegen und das ist alles irgendwie, es ist nicht so einfach.

Ja, aber tatsächlich, das lohnt sich auch noch alles.

Also, wenn man das selber macht, dann kann man mindestens so 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, naja, 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.

rein.

Insofern finde ich das schon legitim.

Aber ich merke halt, also der, man darf das immer nicht unterschätzen, was Flexibilität, und das ist ja eine betriebswirtschaftliche Grunderkenntnis, 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 dann eine Lebensdauer von 12, 36 oder 60 Monaten anguckst, dann ist das Ding in Summe drei bis vier, fünfmal 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 das halt eigentlich dann irgendwann nicht mehr gerechtfertigt.

Also ich meine, die A100 fand ich sogar relativ zarm in der Hinsicht noch.

Also ich gucke gerade nochmal in das Specksheet rein und wenn du halt eine PCI-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 hast du, 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 zu zu sehen, 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 Klassifizierungen 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 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, du, äh, nee, jetzt 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 zum Beispiel 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 halt natürlich irgendwie auch, oder ist 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, hm.

Aber.

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 irgendwie, 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, komm mal drauf an, was man macht.

Also wenn man halt irgendwie so, ja, so klassische Bild so was Image-Net-Mäßiges macht, halt Klassifikation von Bildern oder so und da Modelle trainiert.

Da braucht man nicht so viel Hauptspeicher, weil man jetzt Transformer-Geschichten macht, also Natural Language Processing auf irrsinnig großen Mengen Text oder so.

Da braucht man eigentlich so viele 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-Bereich kriegt, halt schnell vorbei und dann.

Also eine A auch in seinen Gaming-PC einbauen.

Ich mag nur das Interesse.

Ja, ja, 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 halt in der Szene.

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

Aber kann der, wie ist denn 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.

Ja, das

ist ja auch, weil es gibt, also 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, Machine Learning-Unterstü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 gerade einen Kollegen, der da an dem Ende bei sich rumarbeitet, also es 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 ihre User, damit die nicht, 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 das willst du nicht in CPU machen.

Und da haben sie dann auch wieder irgendwie 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 bei den ganzen Enthusiasten sozusagen, die nehmen alle die Gamer-Karten und basteln halt selber.

Dann gut, für wenn man jetzt ein Data Center machen will, dann nimmt man vielleicht halt dann einfach in Kauf, das Zeug halt zehnmal so teuer ist.

Die sind dann auch in manchen Bereichen noch ein bisschen schneller.

Aber da kommt es halt drauf 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 Repower 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 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, 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 Image-Net-Klassen schon drin ist, dann würde man einfach ein Image-Net-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 ein Dataset der Größe, also jenseits, also schon so ein paar hundert 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 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 inteieren.

Und ja, also tja, ich denke mal, die allermeisten Leute brauchen das gar nicht so wirklich, die Power, ehrlich gesagt.

Aber die sind 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 und die Modelle ja nur und schärfen sie vielleicht noch ein bisschen nach.

Aber die rechnen ja die Modelle nicht.

Ne, nicht von Grund auf, genau.

Wäre doch schön, wenn nicht das Modell parallel anpasst, aber naja, wir träumen hier

ein bisschen.

Doch, die 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 Image-Net 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 einen Fell 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.

Bei Live-Videodaten oder sowas, das ist vielleicht noch anders.

Natürlich, also es kommt halt aus, 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 das jetzt, wie man eine ganz neue, tolle Art von Machine Learning-Modell hat, bauen kann, die alles viel besser macht.

Und da musst du halt von Grund auf neu trainieren, weil ja, du wirst ja demonstrieren, dass es besser ist.

Dann, ja, also wenn du Machine Learning-Forschung machst und so, klar, dann musst du, aber auch da brauchst du unter Umständen keine so wahnsinnig wahnsinnig große Rechenleistung für.

Du brauchst sie, ja, wenn du Forschung im Bereich von Transformer machen willst, dann brauchst du halt richtig viel Hauptspeicher und richtig Leistung.

Aber ich meine, wer macht denn sowas?

Also so

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 mal auch mal an so einer Machine Learning Competition teilgenommen.

Da gibt es die französische Firma Kriteo, oder ich habe jetzt schon wieder den Namen vergessen, die machen irgendwie sowas wie zum Beispiel vorhersagen, wie wahrscheinlich ist es, dass irgendjemand auf den, 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, irgendwie, das war alles so Logistic Regression lässig.

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 ja noch nie irgendwie, also ich habe es noch nie in Funktionierend gesehen, dass da irgendwie sinnvolles Zeug rauskam.

Mich würde wirklich interessieren, wo die Teile, also 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.

Das ist ganz wichtig, Recommendation-Systeme, das geht gerade besonders gut.

Einfach die Sachen, die am häufigsten gekauft werden, die viralisieren sich dann einfach weiter.

Scheint ja auch zu funktionieren.

Naja, also was ich, das ist jetzt aber auch schon wieder 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 zehn Jahre her, oh mein Gott.

Und 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 diesem Wettbewerb von wie war das am Anfang oder was hat Netflix quasi, also 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, einfach so mit wäre

gut, ne?

Ja.

Also, 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 vorgefertigten 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 dem Jahr, Netflix ist ja, was 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 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 finde, also ich habe auch immer das Gefühl, ich weiß nicht, ob was die da optimieren, aber manchmal habe ich das Gefühl, sie optimieren darauf, dass man da möglichst lange drin rumsucht.

Also es ist irgendwo ein Incentive falsch gesetzt oder irgendein KPI.

Es ist halt einfach in die falsche Richtung.

Ja, sie haben eine Variable oder irgendeine Dimension in ihrem Ding drin, wo Ausversehen drauf optimiert wird.

Und es entspricht, und das ist ja sozusagen, als ich angefangen habe, mir so ein bisschen nochmal die mathematischen Grundlagen, mich 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 einer 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übergebügelt

wird mit einer Erklärung, wo ich dann denke von ja, nee, du verwechselst, also die machen ein Beispiel, warum 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 da, aber das war doch jetzt gerade gerade eben keine Erklärung für etwas, was man automatisieren kann.

Das ist ja, du hast ja a posteriori einen eigentlich 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 auszusehen drauf 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, ich wäre auch ein Sitzungspekt.

Vielleicht ist es eine mögliche Erklärung.

Ohne ist es ein Phänomen, das ist.

Vielleicht haben sie tatsächlich auf die Nutzungsdauer pro Runde geoptimiert, ja.

Also wie lange gucken die Leute und wenn du jedes Mal zehn Minuten extra guckst für eine Suche, gucken die Leute die länger.

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, blende 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 einen Film angezeigt und zwar genau den, den ich gerade in dem Moment gucken will.

Nein, 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 Innovationen.

Das ist ja das andere Problem.

Du kannst ja nur, also wie es ist auch in den Tutorials immer, oder 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.

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

Ja, gibt es 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 Brokkoli.

Na gut, das ist ein Brokkoli.

Und gleichzeitig wird 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 dieses 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 ich, was würde mir jetzt als Erwachsener eigentlich guttun?

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

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

Deswegen sind halt die Erwartungen teilweise vielleicht völlig daneben was 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 rausgefinden.

Naja, ich glaube, ein wichtiger Aspekt davon ist ja die Frage, benutze ich, also das kommt jetzt aus dem ganzen Thema Komplexität, nutze ich es, um menschliche Kognitionsprozesse zu ersetzen oder zu unterstützen?

Also es ist ja Augmentation oder Cognitive.

Also es gibt ja jetzt auch so neue tolle Kontakte, mit denen man sowas augumentieren kann.

Ja, sehr schön.

Und durch diese Augumentierung, wenn die halt Machine Learning gestützt ist, ja, das ist natürlich schon super cool, weil du halt einfach Zusatzinformationen bekommst, die du vielleicht sonst nicht mehr bist.

Und das ist viel, genau, und das ist aber viel, 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 dann immer sieht, ist halt 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 dran geschrieben und gerankt, guck dir mal bitte zuerst die hier an, mit besonderer Vorsicht.

Und bei dem bin ich mir unsicher und das da glaube ich ist es übrigens nicht.

Dann kann der natürlich nochmal anders rangehen, weil er, er hat einen Sparring-Partner, er guckt selber nochmal drauf, was sagt seine professionelle Intuition zu diesen Dingen, 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.

Wenn es geht, dann muss halt jemand irgendwie ein Postmortem machen.

Im wahrsten Sinne des Wortes.

Ja.

Ja, also es hat halt viele Wirklichkeiten.

Das Problem ist halt, dass du halt diese Granularität nur durch vollständige Informationen auf dem höheren Treffergrad bekommst.

Das heißt, wenn du jetzt wirklich irgendwie so eine Genschere machen wollen würdest, die die entsprechenden Teile genau an der richtigen Stelle raussiebt, dann müsstest du wahrscheinlich relativ hohe Datenmengen und relativ hohe Experimente machen.

Und das Problem beim Machine Learning ist ja irgendwie, dass der irgendwie selbstständig irgendwelche Zufallsexperimente macht in irgendwelchen Datenpatterns, die wir gar nicht so genau sehen können, weil der irgendwie da, weiß ich nicht, binär reinguckt oder so.

Und dann halt irgendwelche Zufallswerte generiert, aus denen der dann irgendwie eine wahrscheinlichste, die wahrscheinlichste Wiederholung irgendwie bemerkt.

Es sind ja keine Zufallswerte.

Ja, es sind keine Zufallswerte.

Nicht alle Machine Learning-Modelle haben irgendwas mit Statistik zu tun, das ist auch nicht so.

Ja, weil so ein bisschen macht er es doch schon, oder?

Kommt auf das Modell an.

Das gibt es sehr unterschiedliche Modelle, also.

Okay, dann müssen wir das vielleicht nochmal in einer anderen Folge genauer angepasst.

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 es 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 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, das ist sozusagen so wie man am Steuer sitzt, wenn du merkst, dein Auto fährt ein bisschen in die falsche Richtung, schlägst 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 nicht so, dass halt, es ist ja nicht so, dass es random ist, sondern er rechnet immer aus, was wäre jetzt, 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 Feier acht immer du, alles steht auf null und dann kommt er halt nie vom Fleck.

Das ist so ein bisschen, wenn du dir an die Newton, wenn du an Newton denkst, wenn du halt eine Newtonsche 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 an einem blöden Punkt anfängst, dann kommst du halt nie zum Ziel.

Naja, wo das dauert sehr lange.

Ja, ich überlege gerade gerade immer, ja, also ich weiß nicht genau, ich würde es eher allgemeiner, also auch gerade was dieses, was das Lernen angeht, ich würde sagen, Machine Learning oder sowas, was versucht, ist 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 hab 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.

Ich glaube, wo wir in der Öffentlichkeit so ein Problem haben, ist dieses eben dieses Zuschreiben, dieses, 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 die, 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 dazu nehmen?

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 weiter treiben.

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 ich 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 angucken, dann je nachdem, wie das dann aussieht, also wenn die beiden Kurven sehr weit auseinanderliegen, also sozusagen, wenn man der Fehler auf den Trainingsdaten gering wird, aber auf den Testdaten nicht, dann und die beiden Kurven sehr weit auseinander liegen, dann weiß man, okay, 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, also 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 soweit, 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, also Siegrebszellen, 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 so gut standardisiert werden, dass man halt eben das auch explizieren kann, dass man nicht irgendwie fünf Leute fragen muss, die kratzen sich am Kopf und ja, wie mache ich das eigentlich, sondern 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 Modell sind das ja immer.

Also ich weiß es nicht.

Was macht das da?

Du hast ja anscheinend irgendwas gerade in der Intention, was dir sagt, da versteckt sich was Interessantes.

Finde ich jetzt interessant.

Ja, also ich weiß es nicht.

Also auch, also dass da das Problem würde ich auch daran, also ich meine, gerade in der Medizin, naja gut, das ist auch wieder so ein weites Held 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, ja, das ist ja alles super grob.

Das ist ja überhaupt nicht angepasst auf jemanden individuell oder so.

Nee, nee, das ist also.

Und wenn jetzt, äh, 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, nimm jetzt nicht irgendwie zwei Tabletten von der Sorte jeden Tag oder so, morgens und 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.

Granularität.

Ja, nee, aber ich bin ja gerade an einem, 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, wo 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.

Da ist es ja nicht so, es geht ja nicht darum, dass dieses, dass das Foto, 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, 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 nochmal, 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 macht, aber äh, nimmt aber jetzt, wenn man jetzt die Bilder nimmt, ohne die ganzen menschlich extrahierten Features, dann 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, die nicht.

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 er 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, es kann auf den Daten ganz coole Sachen machen und auch diese automatische Feature, 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, ne?

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.

Das ist nicht so.

Ja, nein, was ich aber sage ist, das Modell kann dir nicht sagen, gib mir diese Art von anderen Informationen.

Nö, aber man kann ihm alle gerne.

Ich kann auch nicht.

Also wenn er das nicht macht.

Genau, genau.

Und ich glaube aber, das ist etwas, ich versuche noch irgendwie zu dem Punkt zu kommen, wo ich da dastehe, ist, das ist was, wo Machine Learning einfach falsch wahrgenommen wird.

Von 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 Argumentation 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 in Frage zu stellen und zu überschreiten.

Ja, also.

Bei der Grenzerkennung gehe ich mit.

Also dass ein Modell Safety Bells haben kann und sagen kann, du, hier komme ich an meine Grenze, ja, aber es kann nicht selber sagen, ich mache jetzt ein Forschungsprojekt und finde raus.

Man könnte ja vielleicht mehrere Netze miteinander kombinieren, ja, dass du ein Cluster von Netzen hast, wo ein Netz auf sowas achtet ist.

Das ist der Mensch.

Das ist der Mensch, das ist nicht das Machine Learning, was das macht.

Ja.

Ja, keine Ahnung.

Also wir sind halt noch nicht so weit.

Wenn wir Kanzen von Hunden unterscheiden können, das sind wir total glücklich.

Also insofern, ja, das mal schauen.

Keine Ahnung.

Ich finde, dass wir den Kanzen 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öhnen.

Ja, tatsächlich.

Sonst machen wir den einfach das nächste Mal.

Stimmt, wir sind auch schon eine ganze Zeit lang dran, ne?

Ja, und das ist spät.

Also 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 angewiesen bin und 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.

Oh ja, das ist auch noch ein großes Thema.

Aber dann genau, schreibt das doch an hallo.peisenpodcast.de und sagt uns Bescheid, wie ihr das vernetzt.

Jo.

Ja, dann einen wunderschönen guten Abend.

Bleibt uns gewogen.

Schön, dass Christian wieder dabei war.

Ja, dann hören wir uns nächstes Mal.

Alles klar.

Tschüss.

Tschüss.

Ciao.