4 Tipps damit deine lokale Modelle bis zu 10x SCHNELLER werden! (einfach erklärt | 2026)

0:00Kennst du das auch? Du bist auf Huging

0:01Face gegangen, hast dir das neueste Quen

0:0436 mit 27 Billion Parametern ausgesucht

0:07und denkst dir so, na ja, der

0:08Hersteller, der das wird schon das

0:10richtige Modell sein. Also gehst du hin

0:12und schaust dir das an, gehst dann hier

0:14auch entsprechend auf Fils and Versions

0:17und lädst dir das komplette Modell

0:19runter.

0:20So, wenn du das machst und dann deinen

0:22ersten Prompt ausführst, na ja, gut,

0:25dann muss es erstmal ein bisschen laden.

0:26Das siehst du jetzt auch hier unten

0:27rechts. Da lät das Modell erstmal in den

0:29RAM und es hat ordentliche 53 GB. Na ja,

0:33je größer desto besser denkt man sich.

0:38Das dauert eine Weile und dann fängt er

0:40an den Prom zu verarbeiten und es sind

0:42jetzt schon irgendwie 10 bis 15 Sekunden

0:44vergangen und dann endlich fängt er an

0:47zu generieren und er denkt nach.

0:50und er denkt sehr sehr langsam nach. Wir

0:54sind jetzt hier ungefähr so bei 8 bis 9

0:56Tokens pro Sekunde und ja, man kann da

1:00drauf warten, aber schön ist das nicht.

1:04Und zum Entwickeln reicht das schon mal

1:06gar nicht. Also, was ist hier falsch?

1:09Wenn ich mit Modellen arbeite, dann

1:11konfiguriere ich ein paar Sachen und

1:12achte auf ein paar Sachen und dann sieht

1:14das bei mir direkt ganz anders aus.

1:17Natürlich muss mein Modell auch erstmal

1:19laden und dann auch den Kontext

1:20verarbeiten, aber sobald der Kontext

1:22verarbeitet ist, dann geht's richtig ab.

1:30So wie du hier siehst, das geht

1:31bedeutend schneller und wir sind

1:33irgendwo bei 38 bis 40 Tokens pro

1:36Sekunde und damit kann man wirklich

1:37schon was anfangen. Aber das ist nicht

1:39alles. Ich kriege sogar Modelle hin, die

1:41mit 80 Tokens pro Sekunde laufen und das

1:44ist der absolute Hammer. Und wie das

1:46geht, das zeige ich dir in diesem Video.

1:47Und damit herzlich willkommen bei

1:49Deathime.

1:57[musik]

2:03Okay, fangen wir mal bei null an. Also

2:06das erste ist, wenn du über Hugging Face

2:08Modelle runterlädst, die hier keine

2:11speziellen Angaben haben, dann wirst du

2:13sehr wahrscheinlich das Originalmodell

2:15runterladen. Das heißt mit einer 16 Bit

2:18Codierung. Und das ist unheimlich groß

2:21und das ist natürlich dann auch sehr

2:23viel Arbeit für die Grafikkarte. Du

2:25musst sehr viel Gigabyte durch die

2:26Grafikkarte durchschleusen. Das ist

2:28natürlich dann auch die maximale Größe,

2:30die das Modell haben kann.

2:33Und wenn ich das natürlich hier benutze,

2:34dann ist es kein Wunder, dass ich hier

2:36dann auch entsprechend schlechte Tokens

2:39pro Sekundenraten bekomme. Das heißt,

2:41zum einen muss das komplette Modell

2:43erstmal in den RAM geladen werden und du

2:45siehst, das sind hier so um die 51 bis

2:4854 GB allein das Modell, da kommt später

2:51der Kontext noch mit dazu und dann muss

2:54für jedes Token müssen diese 54 GB durch

2:57die Grafikkarte wandern und das kostet

2:59natürlich unheimlich viel Zeit. Und

3:02genau deshalb kriege ich hier dann auch

3:03nur so um die acht Tokens pro Sekunde.

3:07Aber was kann man machen? Nun, es gibt

3:09die sogenannte Quantisierung.

3:12Normalerweise hast du so einen Wert,

3:14also so eine ein Gewicht in deinem

3:15Modell. Das hat eben 16 Bit. Das heißt,

3:17es hat eine sehr krasse Genauigkeit. Die

3:20ist 16 Bit lang. Das sind einige

3:23Nachkommastellen und so viel Genauigkeit

3:25brauchst du gar nicht, dass das Modell

3:28trotzdem noch gute Ergebnisse liefert.

3:30Und üblicherweise kriegst du da auf

3:32Hugging Face unterschiedliche

3:34Quantisierung angeboten. Ich kann immer

3:37nur empfehlen, wenn du ein Genmodell

3:39suchst oder ein anderes Modell, guck, ob

3:41es von Anslot angeboten wird. Das heißt,

3:44du gibst hier einfach noch anslot mit an

3:46und dann siehst du hier auch schon, es

3:47gibt jetzt verschiedene Modelle, die

3:49hier angeboten werden und wir nehmen

3:51jetzt mal das gleiche. Grand 3.627B

3:54GUF für deinen Fall, wenn du jetzt OLAMA

3:56benutzen willst. Ich habe ein MLX

3:58Modell, weil das ganze bei mir auf einem

4:00Mac läuft. So, das Wichtige ist dann

4:03aber, du siehst hier auf der rechten

4:04Seite die verschiedenen

4:05Quantisierungsstufen, ja, und 16 Bit,

4:07das war eben das volle hier mit den 54

4:10GB und das braucht halt ewig lange. Und

4:13wenn wir jetzt aber ein 4 Bit

4:14quantisiertes Modell nehmen und da

4:16gibt's jetzt unterschiedliche

4:18Nuancen, ich habe hier jetzt das Q40 mit

4:21ungefähr 16 GB heruntergeladen und wenn

4:24ich das benutze, dann bin ich von der

4:26Größe her schon mal um ein Viertel

4:28weniger. Und das ganze können wir jetzt

4:31uns mal anschauen, wie das dann

4:32aussieht. Das heißt, ich wähle einfach

4:35einen neuen Chat hier und kann dann hier

4:37auswählen das Grand 36 27B MLX 4 Bit.

4:42Das ist genau das gleiche Modell, nur

4:43eben MLX codiert für meinen Mac. Und

4:46wenn ich hier den Prompt ausführe, auch

4:48hier muss das Modell erstmal laden. Das

4:50sehen wir jetzt hier. Und sobald das

4:52geladen ist, wird der Kontext eben

4:54aufgebaut, der wird verarbeitet und dann

4:56beginnt die Tokengenerierung. Und du

4:58siehst hier jetzt auch schon, ne, wir

4:59haben ungefähr so ja 15, 16 GB. Der

5:02Prompt wird jetzt eingelesen und dann

5:04fängt er auch an direkt Tokens zu

5:06generieren. Und du siehst ja auch schon

5:08direkt, wir sind hier wesentlich besser

5:10mit 26 bis 27 Tokens pro Sekunde und das

5:14siehst du hier auch an der Oberfläche.

5:15Es wird wesentlich schneller generiert.

5:18Das heißt, die Quantisierung ist eine

5:20Möglichkeit, wie du deine

5:21Geschwindigkeit lokal beschleunigt

5:23bekommst.

5:25Der Sweet Spot liegt so ungefähr bei 4

5:27Bit Quantisierung. Du kannst, also du

5:30wirst ein bisschen Verlust haben. Das

5:32ähm ja musst du einfach in Kauf nehmen,

5:35ne? Die Ungenauigkeit, die steigt

5:36einfach, weil du jetzt nur noch vier Bit

5:38Gewichte hast, aber man kann mit denen

5:41noch sehr gut arbeiten. Das heißt, der

5:42Standard ist auch 4 Bit quantisiert.

5:44Damit kriegst du das Beste an

5:46Performance raus bei möglichst wenig

5:49Verlust. Solltest du merken, dass du

5:51trotzdem für manche Aufgaben nicht genug

5:54Qualität bekommst, dann kannst du immer

5:56noch hingehen und sagen, gut, dann gehe

5:57ich auf ein 5 Bit oder auf ein 6 Bit und

5:59wenn du genug Rahmen hast, dann nimm

6:00ruhig ein 8 Bit. Damit hast du immer

6:02noch die Größe um die Hälfte reduziert.

6:05Du wirst nicht ganz auf diese 25 Tokens

6:08pro Sekunde kommen. Das hängt auch immer

6:10von der Hardware ab. Welche Grafikkarte

6:11hast du? Ist es Share Memory von MacOS

6:14und so weiter. Ja, aber du kriegst damit

6:16auf jeden Fall schon mal einen

6:17Geschwindigkeitsboost.

6:19So, das ist die erste Variante, die du

6:21machen kannst, um deine Geschwindigkeit

6:23zu erhöhen. Und das zweite ist, du

6:26kannst mittlerweile

6:28Multiple Token Prediction benutzen. Das

6:30ist eine Technologie, die ist ja

6:31ermöglicht, dass eben mehr als nur ein

6:34Token pro Durchlauf vorhergesagt werden.

6:37Was heißt das? die früheren Modelle und

6:39damit meine ich jetzt die Modelle von

6:41vor ein zwei Monaten. Also diese MTP

6:44Geschichte, die ist relativ neu und

6:47Olama unterstützt es auch erst seit ein

6:49paar Wochen. Das heißt, bei den früheren

6:52Modellen war es so und das ist auch bei

6:54den meisten Modellen noch so. Also die

6:55Quen Serie, die kann MTP, die Ornet

6:57Serie kann MTP und die Gammer Serie kann

7:00MTP. für die anderen und zwar nativ die

7:03anderen Modelle. Da musst du gucken, ob

7:06du ein kleineres Modell als sogenanntes

7:08Dash Modell bekommst, weil so dass du

7:10dann so eine Art äh MTP bekommst, aber

7:13nativ haben nur diese drei Serien

7:14wirklich MTP in in drin. Wie

7:17funktioniert das Ganze? Na ja, das

7:19klassische Modell, das große Modell,

7:22also jetzt hier die 27 Billion

7:24Parameter, die sagen immer nur ein Token

7:27nach dem anderen vorher. Also einmal die

7:3015 GB durch die Grafikkarte schleusen

7:32und dann kriegst du ein Token. Das ist

7:34quasi eine Silbe und dann machst du das

7:36noch mal und noch mal und so kommen

7:38deine ganzen Sätze zustande.

7:40Jetzt wäre es ja schön, wenn ich nicht

7:41nur ein Token vorher sagen könnte,

7:43sondern direkt zwei oder drei oder vier.

7:47Und genau das ist multiple Token

7:49Prediction und die Abkürzung dafür ist

7:51MTP. Und das funktioniert so, du hast

7:54ein kleineres Modell, was versucht 2 d

7:57vi Tokens vorher zu sagen. Das kann man

7:59bei manchen Tools kann man das

8:00einstellen. Auch hier hat sich ergeben,

8:02der Sweet Spock Spock, der Sweet Spot

8:05ist so bei zwei Tokens und Vorhersage

8:09und da kriegst du die maximale

8:11Geschwindigkeit raus. Und das

8:12funktioniert so, das kleine Modell sagt

8:14einfach mal zwei Tokens vorher und das

8:17große Modell validiert dann stimmen denn

8:19diese [räuspern] zwei Tokens, die jetzt

8:20das kleine Modell vorher gesagt hat? Und

8:23wenn ja, na ja, dann habe ich einmal

8:26durchlaufen hat gesagt, ja, die zwei

8:27Tokens stimmen und damit habe ich zwei

8:29Tokens mit einem Durchlauf vorher

8:31gesagt. Ich habe ein bisschen overhead

8:33vorher gehabt, weil das kleine Modell

8:34halt auch laufen musste, aber das war

8:36ein kleines und ultra schnelles Modell,

8:38was einfach diese zwei Tokens vorher

8:40gesagt hat und damit kriege ich so

8:42dieses 1,5 x zweifache Geschwindigkeit

8:45hin. Und das ist halt super genial, wenn

8:48wenn ein Modell das kann und

8:51insbesondere, wenn es Nativ kann. Und

8:53wie gesagt, die Quennie, die kann das

8:54Nativ und deshalb gucken wir uns das mal

8:56an, wie das dann aussieht, wenn ich

8:58jetzt ein Modell nutze, das eben MTP mit

9:01drin hat. Und auch hier nehme ich wieder

9:02das gleiche Modell Quen 36 27B, 4 Bit

9:06Quantisierung, damit wir schon mal die

9:07Geschwindigkeit von der reduzierten

9:09Größe bekommen und dann eben auch mit

9:11diesem Multiple Token prediction. So,

9:14wenn ich hier jetzt mal diese Anfrage

9:16sende, dann muss natürlich auch hier

9:18erstmal das Modell laden. So, und sobald

9:20das geladen ist und dann anfängt Tokens

9:22zu generieren, dann siehst du hier

9:24schon, da sind wir auf einmal bei 35

9:26Tokens pro Sekunde. Und das ist

9:28natürlich unheimlich krass. Das ist noch

9:30mal, es ist nicht ganz doppelt so viel

9:31wie vorher, die 25 Tokens pro Sekunde,

9:34aber wir haben noch mal 10 Tokens pro

9:36Sekunde mehr bekommen und das natürlich

9:38unglaublich. Man muss berücksichtigen,

9:40das ist ein Full Dance Modell. Das

9:42heißt, sämtliche Neuronen sind

9:44miteinander verbunden. Das bringt dem

9:46Modell natürlich ein viel tieferes

9:47Verständnis für die Aufgabe und das mit

9:5140 Tokens pro Sekunde hinzubekommen, das

9:53ist schon echt enorm.

9:56So, das ist aber nicht das Ende der

9:58Fahenstange. Du kannst jetzt noch

10:01unterscheiden zwischen diesen Full Dance

10:03Modellen und sogenannten Moe Modellen.

10:06Das sind Mixtures of Experts. Das ist

10:09eine andere Architekturart von Modellen.

10:11Da sind eben nicht alle Gewichte mit

10:13allen verbunden, sondern du hast

10:16verschiedene, na, sagen wir mal,

10:17Expertenmodelle, kleinere

10:19Expertenmodelle in einem größeren Modell

10:21und vorne dran ist sowas wie ein, na ja,

10:24sagen wir mal Koordinator, Delegator,

10:27der sagt einfach: "Hey, welche

10:29Experten?" Also, der weiß über seine

10:31Experten Bescheid und jetzt kommt eine

10:32Anfrage und da soll ein Token generiert

10:34werden für gewissen Prompt und der

10:37Delegator, der weiß dann einfach oder er

10:39kann halt sehr gut entscheiden, welche

10:41Expertenmodelle da die besten Ergebnisse

10:43liefern. Und dadurch, dass eben jetzt

10:46nicht das komplette riesige Modell aktiv

10:48ist, sondern nur so 5 bis 10

10:50Expertenmodelle aktiv sind, kriegst du

10:52noch mal extrem viel Geschwindigkeit

10:54raus. Und wenn wir uns das mal angucken,

10:58dann siehst du, dass ich hier ein Ornet

11:011.0 35b MLX

11:05Quantisierung 8 MTP Modell hab. Das ist

11:08der absolute Scheiß momentan. Ähm ist

11:11natürlich ein Mittelklassell, also auf

11:13normalen Grafikkarten bis zu 24 GB wirst

11:15du es wahrscheinlich nicht laufen lassen

11:17können. Vielleicht musst mal gucken mit

11:18der acht, dass du runtergst auf die 4

11:21Bit Quantisierung. Aber wenn ich das

11:23Modell hier laufen lasse und du siehst

11:24hier, wir sind hier bei so um die 40 GB,

11:27die das Modell braucht, aber ich bin bei

11:3072 Tokens pro Sekunde und das wird auch

11:32noch steigen. Je nach Aufgabe kriege ich

11:34da bis zu 80 82 Tokens pro Sekunde und

11:37das ist natürlich unglaublich geil.

11:40Damit kannst du richtig entwickeln. Und

11:42genau das mache ich auch in meinem Kurs

11:44von der Idee bis zur professionellen

11:46Software. Da nutze ich genau dieses

11:48Modell, um eben fachliche Analysen zu

11:51machen, um Domainanalysen zu machen, um

11:54Entwicklungspläne zu machen, um zu

11:56testen, um zu codieren und und solltest

11:59du nicht verpassen. Also von daher, wenn

12:01du da Interesse dran hast, wie man mit

12:03Modellen professionell umgeht und zwar

12:05lokal, dann einmal abonnieren und guck

12:08dir den Kurs an. So, das waren jetzt

12:10drei Tipps und es gibt noch einen viel

12:11und der ist relativ trivial.

12:14Du musst zusehen, dass du dein Modell

12:16komplett in die Grafikkarte reinkriegst

12:20oder dein Shad Memory, je nachdem was du

12:22hast. Sobald du deinen normalen

12:24Arbeitsspeicher benutzt, also den

12:25normalen RAM von deinem PC, wird die

12:28Tokenerierung massiv einbrechen.

12:32So und da musst du jetzt einfach drauf

12:33achten. Das heißt, bei Olama hast du die

12:36Möglichkeit, das zu sehen. So. Und

12:38sobald das geladen ist, kannst du eben

12:40mit Olama PS dir anschauen, wie ist das

12:43Modell geladen und du siehst dann hier

12:45100% CPU und genau das darf bei dir eben

12:49nicht stehen, sondern da muss stehen

12:51100% GPU und dann ist dein Modell auch

12:54schnell. Und wie kriegst du das hin? Na

12:57ja, die Größe deines Kontextes. Das

12:59heißt, wenn du einen Kontext hast, der

13:01zu groß ist, dann braucht das auch

13:03entsprechend viel Gigabyte und auch der

13:05Kontext wird im RAM abgelegt. Und

13:07deshalb musst du gucken, dass du

13:08entweder den Kontext reduzierst, damit

13:10es in die GPU reinpasst. Und zwar kannst

13:13du deinen Kontext quantisieren. Also

13:16nicht nur das Modell kann quantisiert

13:17werden, sondern der Kontext auch. Und

13:20wenn du das nicht tust, dann ist der

13:22Kontext immer im 16 Bit Format abgelegt

13:24und das braucht natürlich unheimlich

13:26viel Speicher. Und genau dafür gibt's

13:28dann eben eine Einstellung und bei Olama

13:31kannst du die setzen, indem du in den

13:32Umgebungsvariablen

13:34genau diese Einstellung setzt und das

13:36ist die KV Cash Einstellung. Und hier

13:39gibt es verschiedene

13:40Quantisierungsstufen. Da kannst du jetzt

13:42Q8_0

13:43für die 8 Bitquantisierung oder eben

13:45Q4_0 für die 4 Bitquantisierung machen.

13:49Das heißt, dein Kontext wird hier um ein

13:52Viertel kleiner und damit kriegst du es

13:55dann auch definitiv in deine GPU rein.

13:59So, das waren jetzt vier Möglichkeiten,

14:01wie du deine Geschwindigkeit erhöhen

14:02kannst von deinen lokalen Modellen. Und

14:05ich habe dir das an meiner Weboberfläche

14:06hier gezeigt. Das ist Open Web UI und

14:09die das ist der geilste Scheiß. Also ich

14:11muss sagen, ich nutze nichts anderes

14:13mehr. Vielleicht kennst du das. Du hast

14:15Entropic und nimmt nutzt dann halt

14:17Cloud, dann hast du da deine Projekte

14:19drin, dann nutzt du aber auch Open AI

14:21und Jetgpt und hast da deine Projekte

14:23drin. Es ist alles irgendwie verteilt

14:26und jetzt auch noch lokal und dann hast

14:28du noch mal ein eigenes und du willst

14:30alles an einer zentralen Stelle haben

14:32und genau da kommt Open Web UI ins

14:34Spiel. Hier hast du eine Weboberfläche

14:37und kannst sowohl lokale Modelle als

14:39auch Remote Modelle anbinden von

14:41verschiedenen Herstellern, indem du

14:43einfach den API Key hinterlegst, die

14:45Hostadresse und dann läuft das von

14:47alleine. Und das Schöne ist, du hast

14:49hier Skills, du kannst hier Websuchen

14:51machen. Ich kann z.B. jetzt hier unseren

14:53Prom, den wir eben hatten, kann ich

14:55sagen, führe dazu auch eine Webrecherche

14:58durch.

15:02Und wenn ich das Ganze dann mal

15:04abfeuere, dann wird mein Modell hingehen

15:06und das Ganze dann auch im Internet

15:08suchen.

15:10So, das siehst du jetzt hier. Es werden

15:12insgesamt drei Websuchen durchgeführt

15:14jetzt bei diesem Prompt und dann kriege

15:16ich natürlich ein viel viel besseres

15:17Ergebnis zurück, weil diese ganzen

15:20Halluzinationen, die das Modell eben

15:22naturbedingt hat, die werden durch die

15:24Ergebnisse aus der Websuche dann auch

15:26relativiert, die werden kompensiert und

15:28damit kriege ich ein viel viel besseres

15:30Ergebnis hier zurück. Und wenn du wissen

15:32möchtest, wie du dieses Programm bei dir

15:34laufen lassen kannst und wie du die

15:36Suche einrichten kannst, dann habe ich

15:38hier auf der linken Seite für dich zwei

15:39Videos, die du dir unbedingt anschauen

15:41solltest.

15:43[musik]

15:49[musik]

15:51[singen]