004 LOKALE SPRACHMODELLE: KOSTENLOS & OHNE CLOUD

[00:00:00] Moin Trutz, hi.

[00:00:01] Moin Kai.

[00:00:02] Wie du weißt, haben wir noch ein kleines Seitenprojekt, wo wir vielleicht auch irgendwann mal hier

[00:00:07] im Podcast drüber erzählen, wo es eigentlich darum geht, fast rund um die Uhr Text zu analysieren.

[00:00:13] Das heißt, da kommen immer wieder relativ große Textmengen rein und wir müssen die

[00:00:16] durch so ein Sprachmodell jagen.

[00:00:19] Das mache ich jetzt komplett oder fast kostenlos.

[00:00:23] Also keine Tokens mehr, keine Euro pro Million Tokens mehr.

[00:00:27] Das ist quasi umsonst.

[00:00:29] Und das ist wirklich krass, weil ich mache genau das Gegenteil gerade hier bei Amalotex.

[00:00:34] Wir braten hier Millionen von Tokens durch und die Rechnung jeden Monat wird immer größer.

[00:00:38] Insofern ist das, glaube ich, ein ganz spannendes Thema, den Weg mal zu besprechen, den du da

[00:00:43] gerade verfolgst.

[00:00:44] Denn heute sprechen wir mal um lokale Sprachmodelle, also sprich Sprachmodelle nicht über Chats

[00:00:51] GPT und Co. ausführen zu lassen, sondern lokal auf einem, ja, auf dem eigenen Rechner

[00:00:56] eigentlich, oder?

[00:00:57] Genau.

[00:00:59] Darum geht es heute.

[00:01:00] Ein faszinierendes Thema und vor allem auch was, ein Bereich, der sich auch extrem entwickelt

[00:01:07] jetzt.

[00:01:08] Es sind immer leistungsfähigere Modelle, nicht nur bei den großen Anbietern und bei

[00:01:12] den Platzhirschen, sondern auch das, was man lokal auf dem eigenen Rechner, auf dem eigenen

[00:01:18] Rechner ausführen kann.

[00:01:19] Vielleicht ganz kurz zur Einordnung.

[00:01:21] Ein Modell, wenn wir von Modell sprechen, ist typischerweise Large Language Model oder

[00:01:27] Foundation Model.

[00:01:28] So bezeichnet man es typischerweise.

[00:01:30] Das ist der Kern von dem, was wir jetzt so bei Chats GPT, Cloud AI, das heißt, wenn

[00:01:35] wir ChatsGPT.com aufmachen und mit dem Agenten sprechen, ist im Kern dieses Sprachmodell.

[00:01:40] So ein Chat-Agent hat typischerweise noch ganz viele Tools drumherum, das heißt, der

[00:01:45] ist in der Lage, im Web zu suchen, um sich eine vernünftige Wissensbasis für die Antworten

[00:01:50] zu beschaffen.

[00:01:51] Der ist in der Lage, Code zu generieren, auszuführen.

[00:01:55] Der ist in der Lage, Dokumente zu lesen, Dokumente zu schreiben, Dateien zu schreiben, also ganz

[00:02:00] viele Tools drumherum.

[00:02:01] Das macht nicht alles dieses Modell, der Kern, das Large Language Model, sondern das machen

[00:02:05] noch ganz viele Tools drumherum, die dann dieses Large Language Model eigentlich zu einem

[00:02:09] Chat-Agenten machen.

[00:02:10] Aber wenn du, so wie ihr es bei AMALYTIX ja auch macht, wenn ihr über eine API, also

[00:02:15] eine Schnittstelle, auf so ein Modell zugreift, dann habt ihr mehr oder weniger das blanke

[00:02:20] Modell.

[00:02:21] Dann ist nicht dieser Chat-Agent drumherum, sondern da ist ein Sprachmodell und dem gibst

[00:02:24] du Dinge mit und du kriegst dann diese Chat-Completion, so Antworten auf das, was du da machst.

[00:02:30] Darum geht es, diesen Kern, erst mal zumindest, diesen Kern, dieses Modell wirklich lokal

[00:02:36] auf einem Rechner bei dir, auf einem Server von mir aus auch.

[00:02:39] Ich mag es tatsächlich auf meinem Notebook laufen, aber besprechen wir, glaube ich, auch

[00:02:43] gleich mal, was so die Dimensionen sind, in denen man das machen kann.

[00:02:46] Genau, Dimension ist ein großes Stichwort, denn man fragt sich jetzt natürlich, wieso

[00:02:49] braucht Elon Musk so ein riesen Datacenter, um Drucken zu generieren und wieso reicht

[00:02:55] bei dir dein Mac letztlich dafür aus?

[00:02:58] Da musst du nochmal unterscheiden zwischen diesen beiden Schritten, wie so ein Modell

[00:03:01] entsteht, also der Trainingsaspekt, und wie man so ein Modell letztlich nutzt, was man

[00:03:06] ja auch immer so Inferenz nennt.

[00:03:08] Wir reden heute nur um diesen zweiten Teil, also wir reden nicht darum, wie trainiere

[00:03:11] ich ein eigenes Modell, sondern wir reden davon, wie kann ich das Modell letztlich nutzen

[00:03:17] und dafür braucht man tatsächlich ein bisschen weniger Leistung, wenn man bereit ist, bei

[00:03:22] der Qualität vielleicht auch ein paar Abstriche zu machen, denn so ein Modell in der Leistungsklasse

[00:03:27] jetzt wie Chachibit 5.5 oder jetzt Cloud Fable 5 hast du, glaube ich, nicht auf dem Rechner,

[00:03:33] oder?

[00:03:34] Genau, das geht nicht.

[00:03:35] Da muss man wirklich deutliche Abstriche machen, diese ganz großen Modelle, das funktioniert

[00:03:40] nicht.

[00:03:41] Zum einen sind die auch gar nicht verfügbar, das heißt, die Modelle, die hinter Cloud

[00:03:46] Fable stecken, Opus, Fable, all diese Modelle, die sind nicht frei verfügbar, die bekommst

[00:03:52] du gar nicht als Modelle, aber OpenAI hat GPT-OSS, also ein Modell, was du auch selber

[00:04:04] nutzen kannst, freigegeben, ansonsten gibt es aber ganz viele andere Anbieter, vor allem

[00:04:08] natürlich auch aus dem chinesischen Markt, die die Modelle anbieten, die völlig frei

[00:04:15] sind, das heißt OpenWeight-Modelle, das heißt, du kriegst das Modell wirklich mit den Gewichten,

[00:04:19] also wie so ein Modell ist ja eigentlich auch ein neuronales Netz, wo so jeder Knoten irgendwie

[00:04:24] so Gewichte hat, die dann ausgerechnet werden, und davon bekommst du ganz viele unterschiedliche

[00:04:31] Modelle, ich glaube, so die leistungsfähigsten im Moment tatsächlich aus dem chinesischen

[00:04:37] Raum.

[00:04:38] Das heißt, erstmal geht es darum, du brauchst das Modell, das muss verfügbar sein, und

[00:04:41] dann sind die Modelle aber auch deutlich kleiner, als die, die typischerweise dann

[00:04:44] bei den großen Anbietern laufen, das heißt, du kriegst auch so ein GPT-OSS oder ein GLM5-Modell,

[00:04:55] die sind extrem groß, die sind extrem leistungsfähig, sehr groß, nicht extrem groß, aber sehr groß,

[00:05:02] aber zumindest so groß, dass ich sie nicht auf meinem Notebook laufen lassen kann, das

[00:05:06] heißt, dann gibt es aber auch die Option, wenn du als Unternehmen oder wenn du private

[00:05:10] Lust hast, kannst du dir natürlich auch so einen Server mit ein paar GPUs in den Keller

[00:05:14] stellen, und dann bist du schon in der Lage, sowas auch selber zu betreiben, das heißt,

[00:05:18] auch die großen, freien, offenen Modelle kann man selber betreiben, aber das ist dann nichts,

[00:05:22] was du auf dem Notebook machst, sondern da musst du dir schon einen Server mit entsprechend

[00:05:26] GPU-Leistungen in den Keller stellen, aber dann funktioniert das auch.

[00:05:29] Wir haben jetzt bei uns für ein paar Tests, wo wir wirklich Daten, Dokumente verarbeiten

[00:05:35] wollen, die wir nicht nach außen geben können, haben wir da einen Rechner stehen mit zwei

[00:05:40] Grafikkarten, RTX 5090 sind das, und da kriegt man dann schon diese großen Modelle, so ein

[00:05:46] GPT OSS bekommt man da schon drauf, und das funktioniert dann auch, aber das ist auch

[00:05:51] nichts zum Mitnehmen für unterwegs, aber es geht auch unterwegs.

[00:05:56] Das stimmt, und da hat sich, glaube ich, gerade so in den letzten Wochen, Monaten eine ganze

[00:05:59] Menge getan, wie du sagst, diese Open Rate Modelle, die es jetzt kostenlos zum Runterladen

[00:06:04] gibt, die sind, glaube ich, immer besser geworden, und deswegen hat auch dieses ganze Selbsthosting

[00:06:09] oder Selbstbetreiben thematisch auch nochmal einen Pfad aufgenommen, denn man schafft es

[00:06:13] mittlerweile auch wirklich, fähige Modelle auf eine Größe zu kriegen, sodass die auf

[00:06:18] dem eigenen Rechner laufen lassen können, wir reden wahrscheinlich gleich auch nochmal

[00:06:22] so ein bisschen, wie man das irgendwie macht, aber nur um die Erwartungshaltung vielleicht

[00:06:27] nochmal richtig zu setzen, das ist schon eindrucksvoll, was man damit machen kann, hat jetzt aber

[00:06:32] noch nicht das Niveau von Chatspeedy 5 und Code, das muss man nochmal bewusst sein, aber

[00:06:35] trotzdem gibt es natürlich ein paar Anwendungsfälle, bei denen das dann trotzdem eine veritable

[00:06:41] Option ist, du hast es eben schon angesprochen, wir transkribieren gerade ganz viele Daten

[00:06:45] im Hintergrund, wo, ich sag mal, vielleicht auch Geschwindigkeit jetzt nicht so die Rolle

[00:06:49] spielt, da haben wir Zeit, das ist auch kein super komplexes Thema, da kann man halt auch

[00:06:53] mal so ein Sprachmodell nehmen, welches fallverfügbar ist, das kriegt diese Aufgabe locker hin und

[00:06:58] kostet dann tatsächlich in Anführungsstrichen nichts, beziehungsweise halt nur den Strom

[00:07:02] im Hintergrund und das ist natürlich schon ein Gamechanger, wenn man mal überlegt, was

[00:07:05] sonst, wie du sagst, halt über eine API, so Tokenskosten ist ja schon nicht ganz billig

[00:07:09] und das finde ich schon echt ganz spannend. Und wenn man aber einmal anfängt, in diese

[00:07:14] Welt dieser Sprachmodelle, die man runterladen kann, einzutauchen, so ging es zumindest mir,

[00:07:18] dann wird man erst mal so ein bisschen überrannt von diesen ganzen Abkürzungen, denn es gibt ja

[00:07:23] nicht nur irgendwie Namen des Sprachmodells, sondern es gibt auch irgendwie ganz verschiedene

[00:07:26] Versionen, da wollen wir vielleicht auch mal ganz kurz, aber nicht allzu tief, mal einen Überblick

[00:07:30] geben, welche Begrifflichkeiten da auf einen zukommen. Und insofern Kai, welches Sprachmodell

[00:07:37] konkret hast du da jetzt gerade am Laufen? Genau, ich bin eigentlich sehr oft, ich teste

[00:07:42] gerade relativ viel und bin aber eigentlich in der Quen und Gemma-Welt unterwegs. Das sind so

[00:07:48] die Modelle, mit denen ich mich gerade vor allem beschäftige oder die ich ausprobiere. Und ich

[00:07:56] glaube bei diesen Modellen, weil du hast eben gesagt, man muss, die sind nicht ganz so

[00:08:00] leistungsfähig. Es gibt, glaube ich, zwei Dimensionen. Also es gibt die Qualität, was kann

[00:08:06] das Modell denn tatsächlich leisten und was kann ich dem alles für Aufgaben geben? So einem Claude,

[00:08:11] dem kannst du ja alles hinwerfen, so irgendwie von Quantenphysik bis hin zu Workshop-Konzeptionen

[00:08:20] oder was auch immer. So ein Generalist eigentlich bei allen Themen, was auch mit den Tools zu tun

[00:08:25] hat. Aber erstmal ist das Modell sehr leistungsfähig. Und das hat auch und vor allem mit der Größe zu

[00:08:32] tun. Das heißt, um so eine allgemeine Leistungsfähigkeit hinzubekommen, ist es wichtig,

[00:08:38] dass das Modell groß ist. Das heißt, da sprechen wir eigentlich davon, wie viele Parameter dieses

[00:08:44] Modell hat. Das heißt, wenn man sich es wieder vorstellt wie so ein neuronales Netz, wo so

[00:08:47] einzelne Knoten sind und wo mit Gewichten gerechnet wird, damit am Ende irgendwas rauskommt, geht es

[00:08:54] darum, wie viele von diesen Parametern hat das Modell denn. Und das wird im Moment eigentlich nur

[00:08:59] in Milliardenparametern gerechnet. Das sieht man auch, wenn man mal so die Entwicklung der KI und

[00:09:08] der Modelle angeht, war man irgendwann nochmal bei Millionenparametern. Aber jetzt sind es eigentlich

[00:09:12] immer so was wie 70B, 36B, 27B, dass dann das B ist für die englische Billion, die deutsche Milliarde.

[00:09:20] Das heißt, so ein Modell hat dann 27 Milliarden Parameter. Das heißt, auch 27 einzelne Parameter,

[00:09:27] die ausgerechnet werden müssen in so einem Schritt. Das heißt, um so ein Token zu erzeugen,

[00:09:31] das heißt, so ein Wortteil, müssen die alle durchgerechnet werden. Deshalb ist es auch wichtig,

[00:09:36] dass man das auf der richtigen Hardware macht. Das heißt, dafür braucht man diese GPUs, um schnell

[00:09:42] diese ganzen parallelen Berechnungen machen zu können. Das heißt, die Größe hat einen Einfluss

[00:09:48] auf die Qualität und die Größe bestimmt dann auch, wie viele Arbeitsspeicher ich brauche.

[00:09:54] Weil ich muss dieses Modell in den RAM laden. Das kann ich nicht in der Festplatte liegen lassen. Das

[00:09:58] muss ich komplett in den RAM laden, um das alles so schnell berechnen zu können. Das heißt,

[00:10:01] ich brauche Arbeitsspeicher und da muss es reinpassen. Und wenn ein Modell einfach größer

[00:10:05] ist als mein Arbeitsspeicher, dann kann ich es nicht da reinladen. Das heißt,

[00:10:08] so diese Größe des Modells spielt schon eine wichtige Rolle.

[00:10:11] Man kann sich das so ein bisschen vorstellen wie so ein Gehirn, glaube ich. Und je mehr Gehirnzellen

[00:10:15] es hat, je mehr Parameter es hat, umso schlauer ist es halt. Ist nicht in der normalen Welt immer

[00:10:21] der Fall, dass kleine Hirne oder große Hirne besser sind als kleine. Aber in diesem Fall ist

[00:10:26] es, glaube ich, so. Man kann sagen, je mehr Parameter, je schlauer das Modell. Da gibt es

[00:10:30] Modelle mit vielen Parametern und welche mit kleinen. So stelle ich mir das zumindest immer vor.

[00:10:37] Genau, so kann man es auf jeden Fall auch erst mal sehen. Mit den KI-Forschern würde man das,

[00:10:40] glaube ich, ein bisschen differenzierter diskutieren. Und das kommt dann auch

[00:10:44] tatsächlich darauf an, was heißt schlau und was heißt leistungsfähig und all diese Dinge. Aber

[00:10:48] erst mal kann man sich so vorstellen, je größer das Modell, desto mehr Potenzial hat es wirklich,

[00:10:53] um sehr viele Dinge leisten zu können. Das ist die eine Dimension, das heißt,

[00:11:00] die Modellgröße. Und das ist dann so ein, sieht man dann, so ein QN3627B oder 35B. Das sind dann

[00:11:07] so Modelle, wo man dann sieht, wie viele Parameter, wie viele Millionen, Milliarden Parameter haben

[00:11:12] die denn tatsächlich. Das entscheidet, dann kann ich das überhaupt in meinen Speicher laden. Und

[00:11:19] dann hast du eben auch gesagt, bei unserem Beispiel ist auch nicht schlimm, wenn das ein bisschen

[00:11:23] langsamer ist, dann läuft das halt über Nacht. Und das stört uns nicht so. Wir sitzen da nicht

[00:11:26] und warten auf eine Antwort, sondern das können wir einfach die Nacht durchlaufen und Dinge

[00:11:30] analysieren, ist uns egal. Das heißt, diese Geschwindigkeit wird dann typischerweise gemessen

[00:11:35] in Token pro Sekunde. Das heißt, wie schnell antwortet er denn? Und das sieht man, glaube ich,

[00:11:39] wenn man so mit Cloud AI oder so interagiert, merkt man das, wenn die Server so ein bisschen

[00:11:45] ausgelastet sind, dann dauern die Antworten ein bisschen was. Das hat nicht immer damit zu tun,

[00:11:48] dass das Modell wirklich nachdenkt, sondern manchmal da auch einfach die Leistung gerade

[00:11:53] nicht abgerufen werden kann. Das hat damit zu tun, wie schnell der Speicher angebunden ist. Das hat

[00:11:59] nicht unbedingt mit der Größe zu tun, sondern damit, wie schnell der Speicher, wie schnell du

[00:12:03] in diesen Speicher rein und raus lesen kannst. Und da gibt es auch extreme Unterschiede. Ob du

[00:12:08] jetzt irgendwie einen normalen Arbeitsspeicher von einem PC hast, ob du den Unified Speicher auf

[00:12:15] so einem Mac hast oder ob du virtuellen RAM in so einer Grafikkarte hast, die dann halt nochmal

[00:12:21] deutlich schneller ist. Das heißt, das sind so die zwei Dimensionen. Kann ich das Modell überhaupt

[00:12:25] auf dem Rechner, wo ich es ausführen möchte, in meinen Speicher laden? Der muss groß genug sein

[00:12:31] oder das Modell klein genug? Und dann, wie schnell ist dieser Speicher? Das entscheidet dann darüber,

[00:12:36] wie viel Token ich pro Sekunde erzeugen kann. Das heißt, wie schnell das Modell auch reagiert.

[00:12:41] Ja, das stimmt. Und genau, was du sagst, ist auch richtig. Man muss, glaube ich,

[00:12:45] ein bisschen einschätzen. Nur weil ein Modell mehr Parameter hat, heißt es nicht,

[00:12:49] dass es irgendwie auch besser ist. Ich glaube, wenn man so die ganz alten 70 Billion Parameter,

[00:12:53] also nicht Billion, also Milliarden Parameter Modelle nimmt von vor einem Jahr und die

[00:12:58] vergleicht heute mit so einem 27 Milliarden Parameter Modell, dann ist das 27 Modell

[00:13:03] deutlich besser in der Regel, weil man es einfach vom Training her auch nochmal eine Schippe darauf

[00:13:09] gelegt hat. Und dann unterteilt man ja auch nochmal zwischen sogenannten Mixture of Experts

[00:13:17] Modellen und welche, die es nicht sind. Dense sagt man da auch, also dicht praktisch. Und bei

[00:13:22] diesen Mixture of Experts Modellen, dann ist es eigentlich nicht so, dass man so ein großes

[00:13:26] Gehirn hat, sondern man hat irgendwie so acht kleine, aber in einem Modell drin. Und je nachdem,

[00:13:30] welche Frage ich stelle, wird dann halt vielleicht nur das Modell genutzt, wenn es um das Coding geht

[00:13:35] oder wenn es um was anderes geht. Dann wird vielleicht ein anderer Experte, wie es so schön

[00:13:39] heißt, dann eingebunden. Und das macht diese Modelle dann auch nochmal schneller, so habe ich

[00:13:45] es zumindest gelesen, weil dann halt auch nur deutlich weniger Parameter von diesen 27 aktiv

[00:13:51] sind. Dann brauchst du vielleicht nur drei, weil das dann halt schneller durch diesen Experten

[00:13:54] durchläuft als durch das gesamte Modell. Hat wiederum aber auch ein paar Einbußen,

[00:13:59] vielleicht auf der Qualitätsseite, weil ich da halt nicht mehr alle Parameter nutze,

[00:14:01] sondern nur noch ein Teil. Das ist auch noch so ein Trick, den die Modellbetreiber nehmen,

[00:14:05] um nochmal genau diesen Trade-off zu machen zwischen Geschwindigkeit und Fähigkeit. Und

[00:14:11] diese Mixture of Experts Modelle sind meistens schneller, dafür vielleicht nicht ganz so schlau,

[00:14:16] aber den Trade-off kann man durchaus angehen. Aber dafür deutlich leistungsfähiger als ein

[00:14:23] Modell, was nur die Dimensionen von einem der Experten hätte. Das ist der große Vorteil.

[00:14:29] Das ist ein guter Kompromiss zwischen Größe und Geschwindigkeit. Da kommt es aber tatsächlich immer

[00:14:37] total auf den Anwendungsfall an. Und das ist auch, weil es jetzt so ist, als ob wir seit Project

[00:14:43] angefangen haben, ist jetzt auch schon wahrscheinlich schon ein Jahr her, vielleicht auch länger,

[00:14:48] ich weiß gar nicht so genau. Aber da habe ich auch viel, viel rumprobiert und da sieht man,

[00:14:58] dass auch Modelle ähnlicher Dimensionen sehr unterschiedlich performen auf der speziellen

[00:15:04] Aufgabe. Das heißt, wenn du das wirklich dafür nutzen willst, ich habe hier eine Aufgabe,

[00:15:09] wo ich so ein Modell nutzen möchte, was auch eher offline nicht so interaktiv ist. Ich möchte es

[00:15:14] nicht als Coding-Agenten und nicht als Chatbot nutzen auf meinem Rechner, sondern wirklich für

[00:15:18] eine Aufgabe. Dann lohnt es sich auf jeden Fall, Modelle zu vergleichen und mal auszuprobieren,

[00:15:24] wie gut performen die denn bei genau dem Task, den ich habe. Was ist meine Aufgabe? Was möchte

[00:15:29] ich gerne machen? Und welches Modell funktioniert da gut und wie weit runter kann ich auch gehen bei

[00:15:34] dem Modell? Wie klein kann es sein? Das lohnt sich, glaube ich, immer, das zu machen, wenn es

[00:15:40] wirklich eine ganz spezielle Aufgabe ist, wo man dann Agenten verbaut oder was auch immer.

[00:15:43] Also genau, Modelltyp, dann die Modellgröße und dann haben sie sich ja noch einen Trick

[00:15:47] ausgedacht, um die Modelle noch ein bisschen kleiner zu kriegen. Und das ist dieses ganze

[00:15:51] Thema Quantisierung. Das heißt, du hast ja eben schon angedeutet, jedes Gehirn hat ja so eine

[00:15:56] Gehirnzelle. Jede Gehirnzelle ist mit vielen anderen Gehirnzellen verbunden. Und je nachdem,

[00:16:01] welche Reise so Neuronen da jetzt im Gehirn nehmen muss, biegt sie einmal links, einmal rechts ab.

[00:16:05] Und das wird durch diese sogenannten Gewichte definiert. Und die kann man jetzt in unterschiedlicher

[00:16:10] Komplexität definieren. Mit vielen Nachkommastellen, mit weniger Nachkommastellen. Und je weniger

[00:16:16] Nachkommastellen ich nehme bei diesen Gewichten, umso kleiner kriege ich das Modell, macht dann

[00:16:20] aber auch wieder ein Boosten bei der Qualität. Und deswegen spricht man ja auch manchmal beim

[00:16:24] gleichen Modell von der 16-Bit-Version, der 8-Bit-Version, der 4-Bit-Version. Geht sogar

[00:16:30] runter bis 2-Bit, wo dann wirklich stark komprimiert wird. Man kann sich das, glaube ich,

[00:16:33] so ein bisschen vorstellen wie so ein JPEG, so ein komprimiertes Bild. Auf einer hohen

[00:16:36] Kompressionsstufe oder auf einer niedrigen Kompressionsstufe sieht das Bild top aus.

[00:16:39] Und je stärker ich komprimiere, umso kleiner wird das Bild. Und dann fangen aber auch schon

[00:16:43] langsam an, die Pixel zu kommen. Dann wird das Ganze ein bisschen grisselig. Und auch da gibt

[00:16:47] es halt verschiedene Modellabstufungen. Und auch da muss man halt gucken, mit welcher

[00:16:50] Quantisierung kann ich im Zweifel leben. Denn 16-Bit ist schon sehr, sehr stark. 8-Bit ist,

[00:16:56] glaube ich, auch noch sehr, sehr gut. Und bei 4-Bit fängt es dann langsam an, dass die Qualität

[00:17:00] einen Boosten hat. Dafür ist das Modell aber auch kleiner. Und ich kriege es dann auch überhaupt

[00:17:03] mit meinem Arbeitsspeicher rein. Du hast eben schon gesagt, kommen wir gleich nochmal zu.

[00:17:06] Und das ist, glaube ich, auch so ein Trade-off. Deswegen sieht man ja manchmal so 27B8Q in

[00:17:13] einem Modellnamen. Und wenn man da gar keine Ahnung hat, steht man erst mal davor und denkt,

[00:17:16] was heißt denn das jetzt genau? Aber das ist halt auch nochmal so eine Variante, die man,

[00:17:22] glaube ich, kennen soll. Aber dann haben wir es, glaube ich, auch. Ich glaube, wenn man diese

[00:17:24] Parameter so ein bisschen kennt, dann kann man mal so ein bisschen mit verschiedenen Modellen

[00:17:27] rumspielen. Genau. Ich benutze, wenn ich es lokal auf meinem Notebook mache, nämlich eigentlich

[00:17:33] immer quantisierte Modelle. Also immer auf 8-Bit runter auf jeden Fall. Also da verlierst du sehr

[00:17:38] wenig Präzision eigentlich. Oder sagen wir mal so, es ist immer noch sehr gut. 4-Bit funktioniert

[00:17:46] oft auch noch sehr gut, ist zumindest meine Erfahrung. 2-Bit habe ich noch nicht ausprobiert,

[00:17:50] um ehrlich zu sein. Aber auch da wird fleißig dran entwickelt und weitergearbeitet, dass man

[00:17:57] irgendwie dynamisch quantisiert und nicht überall gleich abschneidet die Nachkommastellen quasi.

[00:18:04] Da ist auch noch viel Bewegung drin. Aber das ist auf jeden Fall ein wichtiger,

[00:18:08] extrem wichtiger Aspekt, um es wirklich lokal auf Notebooks laufen zu lassen. So,

[00:18:13] die Quantisierung, das ist ein wichtiger Schritt dafür, um leistungsfähige Modelle auch wirklich

[00:18:19] in Speicherdimensionen, die man hat, die man typischerweise so auf lokalen Rechnern hat,

[00:18:24] überhaupt betreiben zu können. Ja, das stimmt. Vielleicht gehen wir mal auf das Thema Speicher

[00:18:27] ein. Du hast eben schon gesagt, die Frage ist natürlich, wie viel Speicher brauche ich denn?

[00:18:30] Die Macs von heute starten ja mit 8 Gigabyte, manche haben 16, andere haben sogar 32. Geht

[00:18:35] bitte hoch bis 128 Gigabyte. Wie viel hast du denn gerade auf deinem Rechner? Genau,

[00:18:40] ich habe 64 Gigabyte, weil Apple bietet gerade 128 nicht mehr an. Ich glaube eher ein Speicherpreisthema,

[00:18:48] gerade ja ein großes Thema für die gesamte… Auch für Superglide. Genau. Deshalb war das

[00:18:53] Maximale ein M5 mit 64 Gigabyte. Aber das ist schon groß. Ich habe vorher mit 32 Gigabyte

[00:19:02] gearbeitet, funktioniert auch, da kannst du die Modelle auch betreiben. Es ist dann immer die

[00:19:06] Frage, wie weit musst du quantisieren? Welche Modelle nimmst du? Aber ein lokales Modell

[00:19:13] funktioniert tatsächlich sehr gut. Man hat ja auch so ein bisschen, glaube ich, nochmal einen

[00:19:17] Mac Mini-Hype ausgelöst, das ganze Thema. Auch bei uns wurde ein oder andere Mac Mini bestellt,

[00:19:24] auch in den anderen Abteilungen, um da Dinge drauf laufen zu lassen, weil das eine total

[00:19:29] angenehme Umgebung ist. Sich einen Mac Mini da hinzustellen und da ein Modell an den

[00:19:36] Start zu bekommen, das hängt eigentlich nur davon ab, wie schnell deine Internetleitung ist und wie

[00:19:41] schnell du diese 40 Gigabyte oder wie groß das Modell auch immer ist, tatsächlich auf den

[00:19:47] Rechner laden kannst. Der Rest ist kein Aufwand mehr. Das ist nicht komplex. Du startest den

[00:19:52] Rechner, lädst den Tool runter, sagst, das Modell hätte ich gerne. Dann wartest du, bis der Download

[00:19:57] fertig ist und dann hast du dein lokales Modell und das läuft einfach. Und du hast eben schon

[00:20:01] gesagt, die Modelle sind halt auch so groß. All die Dateien, vielleicht nicht die Dateien, aber

[00:20:04] zumindest den Platz, den es im Speicher belegt, das geht dann schon ans Limit. Man muss auch ein

[00:20:09] bisschen Rest lassen natürlich für Betriebssystemen und was noch so ein bisschen Overhead dazugehört.

[00:20:13] Aber wenn ich jetzt einen 32 Gigabyte Rechner habe, dann kriege ich da auch maximal ein 30

[00:20:19] Gigabyte großes Modell rein. Danach ist halt Schluss. Wie du sagst, auf Festplatte ist halt

[00:20:23] ein Vielfaches zu langsam, um damit zu rechnen. Und deswegen brauche ich halt RAM. Und vor allem

[00:20:28] brauche ich halt auch schnellen RAM. Man spricht da ja auch von dieser Speicherbandbreite. Und je

[00:20:32] schneller die ist, umso schneller kommen dann am Ende auch die Tokens raus. Deswegen sind ja

[00:20:35] wiederum auch die Macs so beliebt, weil gerade die höheren, du hast gesagt, du hast einen M5

[00:20:39] schnellen Rechner, haben halt eine sehr hohe Speicherbandbreite. Die auch diesen Studio,

[00:20:44] wie heißt der? Mac Studio mit M3, Ultra, Max, keine Ahnung was. Und diese Prozessoren sorgen

[00:20:52] halt auch nochmal dann für, oder wie immer, diese Speicherbandbreite ist halt sehr, sehr hoch.

[00:20:56] Deswegen darf man gar nicht so sehr auf den Prozessor schielen. Der spielt bei den ganzen

[00:20:59] Sachen eigentlich weniger eine Rolle. Sondern es ist in der Tat, wie du sagst, halt die GPU. Also

[00:21:04] die anderen Rechenanhalte, die die Bytes da durchjagen. Genau. Und das ist der Punkt auch,

[00:21:10] warum dieses Mac-Welt da interessant ist, weil die ja irgendwann mit ihrem Umstieg auf ARM dazu

[00:21:16] übergegangen sind, gemeinsame Speicher einfach zu machen. Sonst hast du ja in so einem typischen

[00:21:22] Intel-Notebook, hast du ja irgendwie einen Intel-Chip und entweder ist da eine Grafikkarte

[00:21:27] integriert oder du hast eine Grafikkarte selber reingebaut. Oder auch die Notebooks hatten ja auch

[00:21:32] dedizierte Nvidia-Grafikkarten, die dann aber eigenen Speicher haben, typischerweise. Ich weiß

[00:21:36] gar nicht, die Windows-PC-Welt bin ich gar nicht so firm, was da gerade der Stand ist. Aber Apple

[00:21:44] ist auf jeden Fall dazu übergegangen. Und der ganze Speicher, der normale Arbeitsspeicher wird

[00:21:48] einfach auch für die GPU, ist für die GPU zugreifbar. Was typischerweise bei klassischen

[00:21:53] PCs nicht so war. Wahrscheinlich hat sich das auch ein bisschen geändert. Aber das ist das

[00:21:58] Interessante, dass der gesamte Speicher, der Arbeitsspeicher, wirklich für die Grafikkarte

[00:22:02] auch zur Verfügung steht. Und damit hast du quasi die Geschwindigkeit und die Größe vom Speicher,

[00:22:09] um das wirklich machen zu können. Genau. Und deswegen kauft auch gerade die ganze Welt

[00:22:12] Speicher. Nicht nur, weil alle lokalen Modelle laufen lassen, das wahrscheinlich nicht. Aber

[00:22:16] überall entstehen gerade neue Rechenzentren. Und die brauchen halt Speicher, der vor allem sehr,

[00:22:22] sehr schnell ist. Und deswegen ist ja auch der normale Speicher knapp, weil viele Hersteller sich

[00:22:28] jetzt auf dieses neue, lukrative Geschäft verlagert haben und diese klassischen Speicherregeln gar

[00:22:32] nicht mehr anbieten, sondern nur noch die ganze Produktion zum Teil umgestellt haben, um diese

[00:22:36] bandbreiten, hungrigen Speicher für die Datacenter zu bekommen. Auch ganz spannend. Deswegen gibt es

[00:22:42] jetzt auch wenig Angebot im, wie du sagst, es gibt gerade kein Mac Studio mit 128 Gigabyte mehr

[00:22:48] oder ein M5 mit 128. Da haben wir, glaube ich, echt gerade ein Problem. Und es wird auch sehr

[00:22:53] teuer. Jetzt hat Apple auch gerade die Preise deswegen angehoben, weil alle Welt gerade diesen

[00:22:57] Speicher braucht, der halt so wichtig ist für die Inferenz. Auf jeden Fall, hoffentlich beruhigt

[00:23:03] sich das alles auch wieder ein bisschen, wenn die Datacenter alle gebaut sind. Aber mal sehen. Aber

[00:23:09] das ist auch eher was, was, glaube ich, andere Podcasts diskutieren. Lass uns vielleicht mal

[00:23:14] kurz darauf eingehen, wie man denn dazu kommt. Also ich kann es zumindest sagen, so wie es in

[00:23:21] der Mac-Apple-Welt aussieht. Und da gibt es ein paar Optionen. Ich weiß nicht, was du schon

[00:23:27] ausprobiert hast. Ein paar Tools gibt es da ja und das Ganze funktioniert auch unter Windows,

[00:23:32] geht auch, ist jetzt nicht auf die Apple-Welt begrenzt. Aber mein Lieblingstool ist eigentlich

[00:23:39] OMLX. Das ist das, was ich immer nutze. MLX ist das Machine Learning GPU Modellausführ-Umgebung

[00:23:50] für macOS. Und dann gibt es ein Tool OMLX, ist auch immer noch in der Version 0.4 irgendwas

[00:23:58] oder 0.5 irgendwas. Ist relativ frisch auch, also hat noch nicht die Version 1.0 erreicht,

[00:24:03] läuft für mich aber total stabil. Und ist ein Tool, was du dir runterlädst, wo du ein UI hast.

[00:24:13] Also du lädst die App ganz normal runter, legst sie in deinen Programmeordner und startest das

[00:24:20] Ganze. Und dann hast du dein Frontend, wo du zum einen die Modelle managen kannst. Das heißt,

[00:24:26] da ist eine Suche integriert. Das heißt, ich kann jetzt sagen, ich möchte ein QN36720B 4-Bit oder

[00:24:34] 8-Bit oder so haben, kann das in die Suche eingeben. Der sagt mir direkt, wo ich das denn

[00:24:38] finde. Typischerweise von Hugging Face. Das ist ja so der Place, wo Modelle herkommen. Das heißt,

[00:24:45] ich kann das einfach in die Suche eingeben, lade das runter und dann macht er das. Das heißt,

[00:24:49] ich ziehe das, lade das DMG runter, ziehe das Tool in meinen Application-Ordner, starte es,

[00:24:55] sag welches Modell, sag ihm, lade das runter. Wie so ein App-Store nur für Sparmodelle.

[00:25:00] Genau. Kannst du auch. Ich habe, glaube ich, drei, vier, fünf jetzt auch runtergeladen,

[00:25:05] die jetzt hier liegen, die dann aber nacheinander geladen werden müssen. Das heißt, erst mal die

[00:25:11] Modelle sind da, werden dann auch bereitgestellt. Das heißt, mit diesem OMLX hast du auch eine

[00:25:16] normale Schnittstelle, wie du sie auch von OpenAI oder von Cloud bekommen würdest. Das heißt,

[00:25:21] wenn du so über API darauf zugreifen möchtest, die gleiche Schnittstelle. Das heißt, du musst

[00:25:26] nur sagen, ich bin auf localhost und nicht auf openai.org.com. Ich weiß gar nicht so genau.

[00:25:32] Das ist schon länger nicht mehr direkt angesprochen. Das heißt, das Tool stellt

[00:25:36] dir auch die Schnittstelle bereit. Das heißt, du kannst dann lokal, das Tool läuft, das Modell

[00:25:40] ist geladen und du kannst dann lokal mit irgendwelchen Tools diese Schnittstelle nutzen

[00:25:44] und dann entscheiden, entweder nutze ich sie lokal auf meinem Rechner oder ich nutze die

[00:25:47] OpenAI-Schnittstelle. Das ist von der Schnittstelle, vom Code her ist das ganz gut.

[00:25:51] Das ist schon verrückt eigentlich. Das ist schon so eine Magie. Dann kommen plötzlich die Tokens

[00:25:55] raus, ohne dass man da irgendwie auch nur einen Cent verzahlt. Ich habe es mal mit Ullama probiert.

[00:25:59] Ich glaube, das war ja so der eine der ersten Softwareanbieter da in dem Bereich. Ich habe es

[00:26:05] jetzt ehrlicherweise noch nie weiter groß ausprobiert, aber ich fand das schon witzig,

[00:26:10] dass das auch alles auf dem eigenen Rechner funktioniert. Und gerade wenn jetzt auch die

[00:26:14] Anwendungsfälle sich nochmal ausweiten, ist das glaube ich echt eine Option. Vor allem natürlich

[00:26:19] auch für Bereiche, wo man vielleicht gar kein Internet hat. Ich sage jetzt mal so dritte Welt,

[00:26:24] irgendwo Dorf, kein Internet. Auch die können darüber, wenn die so ein Sprachmodell hätten,

[00:26:29] über irgendeinen Laptop, der irgendwo in der Ecke steht, hätten die Zugriff praktisch auf das

[00:26:33] gesamte Weltwissen, was in so einem Sprachmodell irgendwie drinsteckt. Das finde ich schon irgendwie

[00:26:37] total eindrucksvoll. Ich glaube, fast die meisten Regionen, die wir uns gerade vorstellen würden,

[00:26:43] wo es wenig Internet gibt, ist wahrscheinlich besser als bei uns irgendwo auf dem Land.

[00:26:47] Das kann gut sein.

[00:26:50] Wo wir da die Lücken vermuten.

[00:26:57] Du hast es gesagt, die Softwareseite ist echt einfach. Wir haben jetzt ein Sprachmodell,

[00:27:02] wir haben einen Rechner, den Mac, fertig. Der braucht ein bisschen Speicher. Ich glaube,

[00:27:05] das ist ein bisschen das Einschränkende. Und dann lädt man sich dieses OMLX runter und fertig.

[00:27:09] Das ist jetzt nichts Großes. Das kann jeder Nicht-Entwickler innerhalb von 20 Sekunden installieren.

[00:27:15] Und das Coole ist halt, was ich total gut fand, das Tool hat auch direkt so ein Chat-Interface.

[00:27:22] Das heißt, du kannst dann auch mit dem reden, so wie es ja auch OpenCLAW hatte. Da gab es ja

[00:27:27] auch so dieses Chat-Interface. Da konntest du direkt mal mit deinem Agenten reden. Irgendwie

[00:27:31] fand ich auch ganz gut. Und hier auch. Du machst die Software auf, kannst auf Chat gehen und dann

[00:27:35] sprichst du mit dem Modell und sagst ihm, erklär mir Quantenphysik oder was auch immer. Also was

[00:27:40] so im Modell steckt. Funktioniert einfach jetzt sofort. Das ist total gut. Und was ich bei OMLX

[00:27:46] auch noch super finde, ist, dass die auch Benchmarks integriert haben. Das kannst du natürlich auch

[00:27:51] alles zu Fuß machen und alles per Hand bauen. So ein Benchmarking und wie viel Token bekomme

[00:27:56] ich jetzt daraus. Aber die haben eine Benchmark-Section. Das heißt, du kannst die Modelle

[00:28:00] laden, kannst sagen, führ mir diese Benchmarks aus, die da integriert sind und kriegst dann halt

[00:28:04] auch die Auswertung. Du kannst vergleichen, wie schnell ist das Modell denn jetzt auf meinem

[00:28:08] Rechner, wie viele Token pro Sekunde bekomme ich denn raus und kriegst auch noch so Qualitäts-Benchmarks.

[00:28:13] Das heißt, du hast da eigentlich ein Tool, wo du erstmal alles hast. Du kannst unterschiedlich

[00:28:18] Modelle ausprobieren und gucken, ist das schnell genug, was ist denn besser jetzt und was

[00:28:24] funktioniert. Und du hast direkt ein Chat-Interface. Das heißt, einmal runtergeladen und das läuft alles.

[00:28:29] Super. Das ist schon bei den Anwendungsfällen. Was kann man denn jetzt konkret machen und was

[00:28:34] vielleicht aber auch nicht. Du hast eben schon angedeutet Coding. Funktioniert, glaube ich,

[00:28:39] ganz gut. Man kann diese lokalen Sprachmodelle mit den öffentlichen oder Open-Source-Coding-Agenten

[00:28:45] verknüpfen. Dann habe ich praktisch sowas wie Cloud Code. Es gibt ja Open Code, es gibt Py.dev,

[00:28:52] es gibt ja verschiedene, die ich da anbinden kann. Dann habe ich praktisch einen kostenfreien

[00:28:56] Coding-Agenten, der immer bereit ist, für den ich nichts bezahlen muss. Das hast du, glaube ich,

[00:29:00] auch schon ausprobiert, oder? Ja, habe ich ausprobiert mit Open Code und funktioniert

[00:29:05] wirklich problemlos. Das ist also OMLX installiert, Modell runtergeladen, Coding-Modell in dem Fall,

[00:29:13] Open Code installiert und dann hast du bei OMLX auch quasi das Command, um das Open Code dann

[00:29:22] direkt zu konfigurieren. Das heißt, ich kann mir quasi in meinem OMLX das Kommando rauskopieren,

[00:29:28] mit dem ich in der Kommandozeile dann mein Open Code konfigurieren kann. Das hat ja für ganz

[00:29:33] unten Open Claw und so auch alles. Das heißt, der packt dann da automatisch dein Modell rein mit dem

[00:29:38] richtigen Namen, weil du dabei dieser Konfiguration auch immer genau auf den Modellnamen verweisen

[00:29:43] musst und, und, und. Das macht er auch automatisch, aber auch das Open Code runtergeladen und dann

[00:29:48] benutzt du das in der Kommandozeile genauso wie Cloud Code. Nicht so leistungsfähig,

[00:29:54] das muss man auch sagen, es funktioniert. Ich habe ein paar kleine Tools gebaut, aber natürlich

[00:29:59] ist Cloud Code deutlich leistungsfähiger und da habe ich tatsächlich auch beim Coding gemerkt,

[00:30:09] dass Kontextfenster dann auch noch mal ein Thema ist, weil du hast ja, stimmt, wir haben ja vorher

[00:30:14] in der Folge auch schon mal erklärt, glaube ich, dass diese, wenn du mit so einem Modell chattest,

[00:30:20] die einzige Chance, wie dieses Modell weiß, was du vor drei Fragen und vor sieben Fragen oder

[00:30:25] Antworten gemacht hast, ist, dass du immer den gesamten Kontext mitschickst. Das heißt,

[00:30:30] eigentlich kriegt er jedes Mal deine gesamte Unterhaltung mit. Und das geht auf das Kontextfenster.

[00:30:37] Das heißt, und das ist, gerade wenn du lokal bist, ist das auch ein Thema für den Arbeitsspeicher,

[00:30:42] für den Speicher, den du hast. Das heißt, wenn du ein Modell lädst, was deinen Speicher schon sehr

[00:30:46] voll macht, hast du sehr wenig Platz für Kontext. Das heißt, da kommst du schon an ein Limit,

[00:30:50] weil irgendwann wirklich dein Speicher einfach voll ist. Du hast die 64 GB, davon werden schon 40

[00:30:56] vom Modell belegt und dann hast du auch noch einen Rechner und ein Betriebssystem und so,

[00:31:00] die wollen auch irgendwie ein bisschen Speicher haben. Und da habe ich tatsächlich gemerkt,

[00:31:04] dass wirklich das Kontextfenster voll war, einfach mit Open Code, als ich da Dinge gemacht habe.

[00:31:10] Weil das schon sieht man, glaube ich, auch, wenn man über eine API oder Token-Abrechnung solche

[00:31:21] Modelle nutzt, nicht im 20-Dollar-Alles-ist-gut-Modus, sondern über Token abrechnet,

[00:31:28] dann ist so eine Coding-Session auch wirklich teuer. Da werden viele Token generiert. Wenn du

[00:31:33] die ganzen, wenn du den ganzen Code lesen musst, mitschicken musst, wieder was generierst und so,

[00:31:37] da gehen ganz schön viele Token durch. Und wenn du das alles, jedes Token, was generiert wird,

[00:31:42] wird halt auch wieder mitgeschickt. Das heißt, bei so einem Coding-Agenten, da muss ich noch

[00:31:45] mal ein bisschen tiefer rein. Die ersten Sachen haben gut funktioniert, aber ich glaube,

[00:31:49] da ist dieses Thema Speicher, Kontextfenster auch noch mal etwas, was man sehr gut im Blick haben

[00:31:56] muss und wie man dann das kompakten muss und solche Sachen. Aber es funktioniert. OMLX,

[00:32:01] Open Code runtergeladen. Ich kann jetzt coden, ohne mit dem Internet verbunden zu sein.

[00:32:06] Ich glaube, der Hinweis auf dieses Kontextfenster ist noch mal wichtig, weil Fable 5 und Closure 5,

[00:32:10] 6, wie sie alle heißen, die haben ja ein Kontextfenster von einer Million Tokens. Und

[00:32:15] das kriegt man in diesen lokalen Sprachmodellen einfach so nicht rein, so viel. Das ist, glaube

[00:32:19] ich, ein Hinweis. Und das begrenzt natürlich dann auch so ein bisschen die Limitierung. Oder ich

[00:32:22] muss dann öfter mal eine neue Session anfangen, fange dann wieder bei Null an. Ich glaube,

[00:32:25] das ist mal ein wichtiger Hinweis. Und da spielt Speicher natürlich auch noch mal

[00:32:28] eine entsprechende Rolle. Coding, hast du gesagt, kann man machen. Was sind denn noch so Anwendungsfälle,

[00:32:34] wo es sich lohnen würde, so ein lokales Modell zu nehmen und jetzt nicht auf irgendeine API von

[00:32:39] so einem chinesischen Anbieter zu gehen? Was in meinem Alltag irgendwie immer auftaucht,

[00:32:45] sind PDF-Dokumente, Word-Dokumente, die ich auswerten muss. Sei es Personalthemen,

[00:32:51] sei es Angebote, Projektskizzen oder sonstige Dokumente, Projektunterlagen. Irgendwie auch

[00:32:58] mal ein Papier von jemandem oder irgendein Strategiedokument oder Ähnliches, wo es darum

[00:33:04] geht, das mal zu analysieren. Oder sei es so einfache Dinge wie, wenn zwei ganz konkrete

[00:33:09] Sachen Angebotqualität sichern. So typische, gehen Angebote raus, die haben alle irgendwie

[00:33:14] eine bestimmte Form und dann irgendwie so Dinge, Copy-Paste-Fehler finden oder Dinge,

[00:33:19] auf die wir nicht sauber verweisen, auf die AGBs oder Ähnliches. Oder wir haben die Summe X im

[00:33:25] Anschreiben und im Angebot oder in der Leistungsbeschreibung steht dann Summe Y. Solche

[00:33:31] Dinge passieren im Alltag. Angebote, wo Kundeninformationen drinstehen, die können wir

[00:33:36] nicht irgendwo hochladen. Aber mein lokales Modell, dem kann ich das geben. Hier ist das

[00:33:41] Dokument, bewerte das mal. Das heißt, das kann ich so die ganzen formalen Sachen sehr gut machen.

[00:33:45] Das ist gar kein Problem für ein lokales Sprachmodell. Diese ganzen formalen Themen

[00:33:49] finden, das ist kein Problem. Dann geht es aber auch darum, was ist der Kern? Auch inhaltlich

[00:33:53] bewerten. Kriege ich auch gute Hinweise, wo das Modell nochmal darauf hinweist.

[00:33:59] Vor allem Vertraulichkeit. Das verlässt deinen Rechner nicht. Man kann halt nicht alles in die

[00:34:05] Cloud hochladen an vertraulichen Daten, gerade so Kundeninformationen oder Ähnliches. Das ist

[00:34:10] glaube ich auch nochmal ein ganz starker Anwendungsfall. Ich frage mich, wie Ärzte das

[00:34:14] vielleicht mal machen irgendwann, wenn die KI stärker einsetzen. Da geht es ja wirklich um

[00:34:17] sehr vertrauliche Daten. Da kann ich mir auch gut vorstellen, dass lokale Modelle da auch eine

[00:34:21] bestimmte Rolle spielen. Oder in Rechtsanwaltskanzleien, wo es um Streitpferde geht oder

[00:34:25] sowas. Es gibt Lösungen, auch in der Cloud eine gewisse Form von Vertraulichkeit sicherzustellen.

[00:34:31] Das große Stichwort ist ja Zero Data Retention. Aber es gibt auch Leute, die sind ein bisschen

[00:34:35] paranoid und sagen, das glaube ich nicht. Die wollen eine Lösung haben, die hundertprozentig

[00:34:39] sicher ist. Musst du dich dann auch darauf verlassen und im Zweifel musst du auch Mechanismen

[00:34:43] schaffen, das zu prüfen und all diese Sachen. Je nachdem, wo du bist und wie reguliert dein

[00:34:47] Umfeld ist, reicht es vielleicht auch nicht, die Unterschrift des Anbieters zu haben,

[00:34:52] sondern du hast dann den Auftrag, das wirklich sicherzustellen und zu prüfen. Und dann mach

[00:34:56] das mal bei einem großen Cloud-Anbieter, wo du im Zweifel ein sehr kleiner Kunde bist.

[00:35:00] Das ist dann im Zweifel auch nicht so ganz schwierig. Der ganze öffentliche Sektor, die

[00:35:06] haben halt Daten der Menschen, die hier leben, wo es Gesetze gibt, dass die auf gar keinen

[00:35:11] Fall in solchen Infrastrukturen landen. Da baust du lokale Modelle. Die laufen dann halt

[00:35:15] nicht lokal auf einem Notebook, sondern im eigenen Rechenzentrum. Aber das sind auch

[00:35:21] offene Modelle, die da betrieben werden und genutzt werden. Das heißt, wenn du Vertraulichkeit

[00:35:27] und Souveränität haben willst, dann ist das ein extrem wichtiger Punkt. Souveränität

[00:35:33] ist auch, wir haben es mit Fable 5 gesehen, Cloud Business Account war da, ich glaube,

[00:35:39] drei Tage. Dann kam da eine Mail, ist gerade leider nicht mehr verfügbar, weil bestimmte

[00:35:45] Regierungen das Thema mal auf die Liste gesetzt haben und das Unternehmen ist nicht

[00:35:50] ausländischen Nutzern zur Verfügung stellen durfte. Und das war einfach von heute auf

[00:35:56] morgen. Da gab es keine Vorwarnung. Wenn du dich jetzt darauf verlässt, jetzt war es

[00:36:00] nur ein Modell und das neueste Modell, aber kann natürlich auch sein, dass da ein ganzer

[00:36:05] Dienst abgeschaltet wird einfach mal. Das heißt, hat ja auch was mit Souveränität

[00:36:09] zu tun. Ich bin sicher, dass ich dann noch arbeiten kann und auch ich. Bei manchen Dingen

[00:36:14] verlasse ich mich schon darauf, dass meine KI-Infrastruktur verfügbar ist und time das

[00:36:18] auch entsprechend so. Und wenn die dann nicht verfügbar ist, dann kann ich die Dinge auch

[00:36:22] immer alle noch machen, aber die dauern dann halt dreimal, viermal so lange, wie ich eigentlich

[00:36:25] eingeplant hatte. Und jetzt gerade heute, das habe ich heute morgen gehört, jetzt hat

[00:36:32] auch China darüber nachgedacht. Die sind ja eigentlich gerade der Lieferant für die

[00:36:36] offenen Modelle. Auch interessante Entwicklung, sodass das Land was dafür sorgt, dass wir

[00:36:45] – die Frage ist, ob es souverän ist, aber dass wir erstmal offene, freie Modelle betreiben

[00:36:49] können, ist irgendwie China, die uns dabei helfen, Dinge datenschutzkonform umzusetzen.

[00:36:55] Aber auch da gab es heute die Meldung, dass die Regierung darüber nachdenkt, ob sie auch

[00:37:01] solche Dinge machen, bestimmte Modelle nicht außerhalb von China verfügbar zu machen.

[00:37:06] Dass dann auch abgestuft, wie leistungsfähig die Modelle sind, dass manche auch nur mit

[00:37:12] Freigabe dann offengelegt werden dürfen, manche aber auch gar nicht. Das heißt, diese

[00:37:17] Entwicklung gibt es. Das heißt, dieses Thema Souveränität, welche Modelle habe ich denn

[00:37:23] und wie kann ich die denn betreiben und wie sehr verlasse ich mich im Unternehmen darauf,

[00:37:29] ist ein ganz wichtiger Punkt. Weil davon auszugehen, dass einfach Open AI API oder Cloud API oder

[00:37:35] was auch immer einfach verfügbar ist, ist halt schwierig.

[00:37:40] Gut, dass wir in Europa so gut aufgestellt sind, was das Thema Souveränität von AI angeht.

[00:37:44] Aber es war für mich auch immer so ein Wake-up-Call, als Fabel 5 plötzlich weg war,

[00:37:49] dachte ich auch, krass, da hat man zum ersten Mal wirklich gemerkt, die haben ja gerade ein

[00:37:51] starkes Modell weggenommen und das ist dann wirklich ein Nachteil im Zweifel für Unternehmen,

[00:37:56] für Regionen, wenn wir da nichts Eigenes haben. Ist vielleicht mal ein anderes Thema für eine

[00:38:02] andere Folge, aber fand ich auch wirklich wild und das werden wir vielleicht immer häufiger sehen,

[00:38:06] gerade wenn die Modelle mächtiger werden. Ein Punkt noch vielleicht, der mal für lokale Modelle

[00:38:12] sprechen könnte, ist, dass Modelle ja immer auch ein Stück weit zensiert sind. Man baut ja

[00:38:16] sogenannte Guardrails ein, also Sicherheitsbeschränkungen, dass man nicht fragen kann,

[00:38:20] kannst mir mal erklären, wie ich Kokain herstelle. Das lehnen ja normale Modelle ab und es gibt aber

[00:38:25] auch im Web halt unzensierte Modelle, wo Leute sich die Mühe machen, genau diese Beschränkungen

[00:38:29] halt rauszurechnen und dann ist das Modell halt sehr freizügig in seinen Antworten.

[00:38:34] Muss natürlich auch ein bisschen aufpassen, weil damit holt man sich natürlich auch Risiken rein,

[00:38:38] gerade wenn ich so Modelle auch dann koppele mit Codingagenten oder ähnlichem. Aber auch das wäre

[00:38:45] theoretisch eine Möglichkeit. Ich denke da zum Beispiel so an Sicherheitsexperten, die vielleicht

[00:38:49] berufswegen Sicherheitslücken finden, prüfen wollen. Vielleicht ist das dann was für die,

[00:38:54] wo so ein Modell halt immer wirklich den Hacker raushängen lässt und dann auch einfach mal alle

[00:38:58] Fähigkeiten herauspackt, die man so braucht, wo jetzt auch ein Fabel 5 sagt, nee, sorry,

[00:39:01] darf ich nicht, dir dabei helfen. Ja, aber gibt’s, kann ich auch, reales Beispiel,

[00:39:08] was wir schon hatten, wenn du dich mit Extremismus beschäftigst, das heißt irgendwie in sozialen

[00:39:15] Medien irgendwie extreme Kommentare identifizieren und klassifizieren möchtest, wenn man sich irgendwie

[00:39:20] bestimmte YouTube-Channel oder ähnliches oder Telegram-Kanäle anguckt, wenn man da bestimmte,

[00:39:25] wenn man da in bestimmten Kanälen die Kommentare klassifizieren möchte, sind da Texte, die du auf

[00:39:33] gar keinen Fall Cloud oder OpenAI geben kannst. So, weil die einfach sagen, das geht durch unseren,

[00:39:39] das wird schon vor dem Modell geblockt. Das ist ein Content-Filter. Das sprengt sofort

[00:39:43] der Filter an. Diesen Content kann ich nicht, wird nicht verarbeitet. Und das ist Realität,

[00:39:48] das ist ja durchaus valider Wunsch irgendwie, Radikalität von Kommentaren in Social Media

[00:39:53] zu analysieren, so als Akteure oder auch für Forschungszwecke. Und das können die Modelle

[00:39:59] nicht, weil sie einen Content-Filter haben. Und wenn du das dann machen musst, bleibt dir gar

[00:40:03] nichts anderes übrig, als lokale Modelle zu haben, die diesen Content-Filter nicht haben. Das ist dann

[00:40:08] kein Modellthema eigentlich. Also Cloud und OpenAI und alle anderen Anbieter, die könnten das,

[00:40:13] aber die haben davor einen Content-Filter, wo sie solche Sachen einfach schon rausfiltern. Kein Hass,

[00:40:19] keine radikalen Radikalisierung, Herabwürdigung etc. da rein. Das heißt, das ist ein reales

[00:40:24] Problem für ganz viele Menschen, nicht nur in diesem IT-Security-Thema, sondern es gibt einfach

[00:40:28] Texte, die kriegst du nicht durch die Schnittstelle zu den großen Modellen, weil die das einfach

[00:40:32] rausfiltern. Spannend, ja. Auch ein guter Punkt. Ja, super. Also ich glaube, da haben wir das Thema

[00:40:39] glaube ich so ein bisschen beleuchtet jetzt, oder haben wir noch unrichtigen Aspekt? Das ist genau

[00:40:42] eine Empfehlung noch, weil wir haben ja eben, wir haben ein lokales Modell, das betreiben wir so,

[00:40:47] und das drumherum. Wie machen wir jetzt daraus einen nützlichen Agenten? Machen wir mit OpenCode,

[00:40:52] dann ist es der Coding-Agent. Und wenn ihr das als einen normalen Chatbot nutzen wollt,

[00:40:57] quasi als ein Chatbot, wo man Dokumente reinschmeißen kann, PDF, mal ein Bild und

[00:41:03] all diese Sachen, dann würde ich OpenWebUI empfehlen. Ist eine Web-Anwendung, die dir quasi

[00:41:11] so ein Chatbot baut. Die hat ganz viele, die hat die Möglichkeit, Skills zu integrieren,

[00:41:15] die hat die ganzen Tools integriert und, und, und. Das heißt, das ist quasi auch eine Umgebung,

[00:41:20] wo du mit so einem Modell dann dein eigenes Chat-GPT, dein eigenes Cloud-AI machen kannst.

[00:41:25] Die haben auch eine Desktop-App, die habe ich gerade erst entdeckt. Ich habe mir vorher selbst,

[00:41:30] das ist eine Web-Anwendung eigentlich, die du so betreibst auf einem Server. Haben aber auch eine

[00:41:36] Desktop-App da quasi gemacht, die auch direkt schon fragt, ob du ein lokales Modell hast,

[00:41:41] oder die auch sogar selber das betreiben kann. Ich glaube, mit lama.cpp oder so heißt das,

[00:41:47] glaube ich. Das heißt, wenn ihr dann den lokalen Chat-Agenten wollt, OpenWebUI, die Desktop-App,

[00:41:53] das ist, glaube ich, der Weg, das zu machen. Das heißt, OMLX für das lokale Modell,

[00:41:59] dann OpenCode, um zu coden oder OpenWebUI, um dann einen Chat-Agenten zu haben, der auch

[00:42:07] Dokumente verarbeiten kann und Skills managen kann und all diese Dinge. Das heißt, das ist so

[00:42:12] die Welt, wie man das alles lokal hat. Das sind zumindest die Tools, die ich ausprobiert habe und

[00:42:18] die für mich gut funktioniert haben. Wenn unsere Zuhörerinnen und Zuhörer irgendwie bessere Tools

[00:42:23] haben oder andere Tools, auch gerne einfach mal in die Kommentare oder in die Mail an uns schreiben,

[00:42:28] gucken wir uns auch immer gerne an. Ja, super. Ja, guter Hinweis. OpenWebUI habe ich auch schon

[00:42:34] mal installiert, als es damals noch nicht jeder ein GTPC-Zugang hatte, haben wir das auch mal hier

[00:42:37] in der Firma installiert. Echt ein sehr mächtiges Tool mit wirklich vielen Einstellmöglichkeiten,

[00:42:40] kann ich auch empfehlen. Cool, ja, vielleicht ziehen wir mal ein Fazit. Also, die Dinger sind

[00:42:45] kostenlos verfügbar, die Modelle. Man kann es mit handelsüblicher Hardware betreiben,

[00:42:50] man braucht jetzt keinen extra Server dafür. Mac mit ordentlich Speicher und da gehen sogar schon

[00:42:55] auch 16 GB, habe ich hier und da auch schon mal gelesen. 24 ist natürlich besser, 32 ist schon

[00:43:00] solide. Ich glaube, damit kriegt man schon ein sehr gutes Modell dann hin. Je mehr ist immer

[00:43:04] besser, aber muss auch gar nicht sein. Und dann komme ich schon ans Laufen. Und wie gesagt,

[00:43:08] Softwareseite ist auch gelöst, ist auch kein totaler Nerdkram. Muss man jetzt nicht tief

[00:43:12] irgendwie in die Tiefen der Kommandozeile absteigen, um da irgendwas ans Laufen zu kriegen,

[00:43:16] was dauernd wieder kaputt geht. Also sehr nutzerfreundlich gemacht und dann habe ich

[00:43:19] halt ein Modell am Laufen. Und ein paar Anwendungsfälle haben wir besprochen. Man muss,

[00:43:22] glaube ich, aber auch der Wahrheit dazu sagen, weil wir haben es am Anfang schon gesagt,

[00:43:25] das sind jetzt keine Modelle, die jetzt auf dem Niveau sind der aktuellen, wie man so schön heißt,

[00:43:29] Front-Share-Modelle, wie ein Chatspiel 5.5, 5.6 kommt jetzt bald raus, Fable 5 ist gerade da. Das

[00:43:36] ist natürlich noch mal ein anderes Niveau. Das hast du jetzt auch mehrfach gesagt. Aber trotzdem

[00:43:39] sind die mittlerweile so gut, das ist je nach Aufgabe und davon hängt es, glaube ich, ab,

[00:43:42] was will ich damit machen. Durchaus eine Option sein kann, gerade wenn, sage ich mal,

[00:43:47] Qualität nicht die allerhöchste sein muss. Ich jetzt nicht den nächsten Nobelpreis gewinnen

[00:43:53] möchte und vielleicht auch Geschwindigkeit jetzt nicht die riesige Rolle spielt und vielleicht

[00:43:56] auch mal Zeit habe, dass ein Job vielleicht auch mal über Nacht laufen kann. Aber man kriegt auch

[00:43:59] da, ich glaube, so 15 bis 90 Token pro Sekunde. Das muss man erst mal mitlesen können. Je nach

[00:44:06] Leistung, je nach Hardware ist das schon, also es ist auch nicht super langsam, wollte ich, glaube

[00:44:10] ich, den falschen Eindruck erwecken. Aber ich glaube so, wenn man die Trade-Offs kennt,

[00:44:13] ist das, glaube ich, echt eine super, kann das eine Option sein. Auf jeden Fall. Und so normale

[00:44:17] Chats funktionieren auch total flüssig. Das ist jetzt nicht so, dass du denkst, du bist in einer

[00:44:21] ganz anderen Welt gelandet, sondern dann das Modell mal lädst und dann ins Chatfenster mal so im

[00:44:26] mal anfängst, einfach dich zu unterhalten. Das ist total flüssig. So, das ist nicht, das ist nicht

[00:44:32] anders. Ja, das stimmt. Man muss trotzdem Kosten-Nutzen-Abwägung machen. Also klar, wenn ich jetzt so ein Mac M5 kaufe in der

[00:44:38] Top-Konfiguration, dann lege ich da auch 6.000 bis 7.000 Euro hin. Die kann ich natürlich im Zweifel

[00:44:43] auch in eine API stecken. Und wenn ich da jetzt auch so ein Modell wie GLM 5.2 nutze, was ja auch

[00:44:49] nicht teuer ist und trotzdem sehr, sehr leistungsfähig, das kann ich ja lokal nicht laufen lassen, da kann

[00:44:54] ich viele Tokens für generieren. Also wenn ich nicht das Problem habe, Privacy oder ähnliches, wenn es

[00:44:59] wirklich nur ein Kostenthema ist, muss man es schon abwägen. Wenn ich natürlich eh ein Mac rumstehen

[00:45:03] habe und jetzt nichts extra anschaffen muss, ja gut, dann habe ich eigentlich keine zusätzlichen Kosten

[00:45:07] außer Strom. Aber das kann man natürlich immer abwägen. Also das sollte man natürlich auch immer abwägen.

[00:45:10] Es gibt auch starke Modelle, die günstig sind. Das kann man auch sagen. Genau. Aber das hatten wir ja

[00:45:15] auch schon immer. Stell ich mir einen eigenen Server in den Keller oder buche ich mir was bei Amazon

[00:45:21] in der AWS Cloud oder so. Die Abwägung hattest du da auch immer. Das geht alles lokal. Du musst halt

[00:45:27] wissen, warum. Genau. Ich war auch schon kurz davor, weil ich auch mal Lust hatte, damit rumzufliegen,

[00:45:31] mir so ein Mac mit ordentlich Rahmen hinzuschauen. Da habe ich auch gedacht, das macht eigentlich keinen Sinn.

[00:45:34] Es ist noch nicht. Doch, das macht Sinn. Das macht auf jeden Fall immer Sinn. Das stimmt. Also irgendwann

[00:45:41] sicherlich auch noch mal. Genau. Ja, super. Ich glaube, dann haben wir es, glaube ich, soweit. Oder?

[00:45:46] Ich glaube, es gibt einen guten Überblick. Wir stecken die Links zu den Tools in die

[00:45:52] Shownotes. Wer mal anfangen will, wirklich, eine Viertelstunde ist man da und kann anfangen,

[00:45:57] rumzuspielen, ohne dass man irgendwie ein Abo abschließen muss und dann im Zweifel auch,

[00:46:01] wie du ja auch schon berichtet hast, plötzlich bei ein paar hundert Dollarn API-Kosten ist. Ich

[00:46:06] glaube, vor allem dieses API-Thema ist vielleicht sogar deutlich interessanter. Wenn man Anwendungen

[00:46:10] mit API-Zugang testen will und damit Sachen machen will, ist das, glaube ich, ein Thema,

[00:46:16] wo man sehr schnell da ist. Runterladen, loslegen, API ist da und man kann Dinge tun, ohne Angst zu

[00:46:21] haben, dass man dann irgendwie bei 500 Dollar am übernächsten Tag landet, wie es dem einen oder

[00:46:27] anderen schon mal passiert ist, habe ich gehört. Soll schon passiert sein. Das stimmt. Ja, Kai,

[00:46:33] super. Dann vielen, vielen Dank, dass du uns da den Einblick gegeben hast in die Welt der lokalen

[00:46:37] Sprachmodelle. Und wie du sagst, schreibt uns mal in die Kommentare oder schreibt uns mal persönlich.

[00:46:41] Bin gespannt, ob ihr da eure Erfahrungen schon mitgemacht habt. Und vor allem, glaube ich,

[00:46:46] in der Zukunft weiter beobachten, weil die werden nicht schlechter, diese Modelle. Im Gegenteil,

[00:46:50] die werden immer, immer besser. Ich glaube, der Kreis der Anwendungen wird immer größer und

[00:46:55] wer weiß, ob man nicht irgendwann dann den Switch macht, letztlich weg von Data-Centern hin zu was

[00:47:01] lokal. Mal abwarten. Ich werde es auf jeden Fall sehr eng im Auge behalten. Ich auf jeden Fall auch.

[00:47:06] Alles klar. Kai, vielen, vielen Dank. Mach’s gut. Ciao. Mach’s gut. Ciao, ciao, ciao.