News AMD Ryzen AI 400: Refresh-APUs mit mehr Takt zur CES 2026

[PCGH_Sven]

Zur CES 2026 im Januar kommenden Jahres werden auch die AMD Ryzen AI 400 ("Gorgon Point") erwartet, bei denen es sich um mindestens sechs Refresh-APUs der Ryzen AI 300 ("Strix Point") mit etwas mehr Taktfrequenz handelt.

Was sagt die PCGH-X-Community zu AMD Ryzen AI 400: Refresh-APUs mit mehr Takt zur CES 2026

Bitte beachten: Thema dieses Kommentar-Threads ist der Inhalt der Meldung. Kritik und allgemeine Fragen zu Online-Artikeln von PC Games Hardware werden hier gemäß der Forenregeln ohne Nachfrage entfernt, sie sind im Feedback-Thread besser aufgehoben.

 

[peru3232]

ich finde die Entwicklung in die es geht einfach schade! Wenn man brauchbare iGPU Leistung haben möchte, bzw. dort die eigentliche Priorität liegt (was ja der SINN einer APU sein sollte), wird man immer zur maximalen Kernanzahl genötigt, die aber wohl kaum wirklich gebraucht würde -> wer das auslasten kann, braucht entweder gar nicht so viel Grafikleistung, oder würde eh eine diskrete GPU dazu nehmen... Hauptsache aber, es werden alle mit diesen NPUs beglückt (witzigerweise bekommen da alle den "Vollausbau" -> das muss der beste Platz am DIE sein, denn da gibt es anscheinend nie Fehler, dass Bereiche deaktiviert werden "müssen")*

Schöner wäre, wenn dieses ganze Theater um die unnötige Kastrierung der Chips auf den Mülleimer geworfen wird. Es wird sehr wenige "wirklich" Teildefekte geben - praktisch alle unterscheiden sich maximal in der Güte der möglichen Taktung -> das kann ja gerne auch herangezogen werden beim Verkaufspreis - wenn dann überhaupt CPU Kerne allein oder meinetwegen auch dieser NPU-Kropf teildeaktiviert werden...

 

[Ghostshield]

Ich sehe hier nur ein rebrand... Ryzen HX 370 mit 100-200mhz mehr takt und das wars

 

[BigBoymann]

wird man immer zur maximalen Kernanzahl genötigt, die aber wohl kaum wirklich gebraucht würde

AI Max 388+ bietet wohl 8 Kerne und 40CUs, der 392 bietet 12 Kerne und 40CUs.

Im echten Desktop gibt es nach meinem Gefühl aber schlicht kaum sinnvolle Anwendungsszenarien dafür, denn dort ist der Speicher schlechter angebunden, zumindest wüsste ich nicht, dass man 8533er Speicher dort zertifiziert bekommt und (bin gerade gar nicht so im AMD Game drin) 6000er immer noch das Optimum zu sein scheint.

Zum anderen ist es im Desktop eigentlich sinnvoller eine dedizierte GPU einzusetzen um die 16 CUs der hier präsentierten Lösung zu schlagen. Die dürfte so in etwa im Rahmen einer RX590 liegen, vieleicht etwas drüber.

 

[Oppenheimer]

@PCGH_Sven

"Mit Grogon Point wird AMD auch wieder das "Gütesiegel" Copilot+ erhalten,"

Typo

 

[Jacco011]

Schade dass die Grafikeinheit in den Jahren 2026/2027 nicht weiterentwickelt wird(?). Es bleibt weiterhin bei RDNA 3.5. Für meinen Zweck bevorzuge ich Laptops mit guter iGPU, aber ohne zusätzliche GPU.

 

[Gelöschtes Mitglied 23535a]

@PCGH

Ist die Rechengeschwindigkeit der KI Einheiten eigentlich wirklich immer genau der gleiche Standart wie beim Konkurrenten gemessen? Also die Genauigkeit auf einem Nenner? Und welche Genauigkeit ist der Nenner???

Weil ich manchmal etwas Verwirrt bin, von den TOPS Angaben und noch nicht so Richtig weis, ob das von allen gleich bemessene Grundlagen sind. Auf Geizhals findet man zuweilen von garkeiner Angabe bis ja auch unterschiedliche Bemessungen. Mich verwirrts halt immer noch. Selber stiefele ich nur noch bei ab FP16 Genauigkeit herum auf den ARC GPUs und den lokalen Modellen.

Die sind richtig Flott. Vor allem die alten mit den dicken XMX Einheiten.

 

[peru3232]

Im echten Desktop

? -> es geht hier ausschließlich um Mobilchips - auch wenn ich sie im Desktop ebenso begrüßen würde für kleine und passable ITX Buids im DIY Markt und nicht nur über Minicomputer aus Fernost. Und auch nicht um AI Max, die ihrerseits zwar toll sind, aber auch nicht auf Mobil ausgelegt sind -> brauchen zu viel Leistung und sind durchs Chipletdesign auch nicht Effizient im Leerlauf und Niedriglast. Wobei dort immerhin der 388er in die richtige Richtung gehen würde. Allerdings durch rein verlöteten Arbeitsspeicher alleine schon deswegen für mich durchfallen würde.

Mit dem RAM wird eh hinkünftig wieder interressanter - also erst Jahre später durch Aufrüstung die Speichermenge zu vervielfachen, wenn es ebenso wieder vierlfach günstiger sein wird. Das war ja jetzt längere Zeit über kaum mehr gegeben, weswegen es ziemlich egal war und sich der Widerstand deswegen gegen verlötet in Grenzen hielt...

 

[township-boy]

AI Max 388+ bietet wohl 8 Kerne und 40CUs, der 392 bietet 12 Kerne und 40CUs.

Der ist bis jetzt aber auch nur ein Gerücht, offiziell gibt es den noch nicht.

 

[BigBoymann]

Und auch nicht um AI Max, die ihrerseits zwar toll sind, aber auch nicht auf Mobil ausgelegt sind

Du hast aber schon mitbekommen in welchen Geräten die verbaut werden?

AYANEO NEXT 2 offiziell: Windows-Handheld mit Ryzen AI Max+ 395, viel Versprechen, wenig Daten | igor´sLAB

AYANEO zieht den Vorhang für das NEXT 2 auf, allerdings nur halb. Der Hersteller bestätigt die Plattform und einige Kernfeatures, schweigt aber zu allen ungemütlichen Details: Display-Spezifikationen…

www.igorslab.de

HP ZBook Ultra G1a B72TBET ab 3.399,82 € (Dezember 2025 Preise) | Preisvergleich bei idealo.de

Bereits ab 3.399,82 € ✓ Große Shopvielfalt ✓ Testberichte & Meinungen ✓ | Jetzt HP ZBook Ultra G1a B72TBET günstig kaufen bei idealo.de

www.idealo.de

Handheld und Laptops sind meinem Kentnissstand folgend durchaus Mobilgeräte.

Allerdings durch rein verlöteten Arbeitsspeicher alleine schon deswegen für mich durchfallen würde.

Der ist aber nunmal von Nöten um eine gewisse Geschwindigkeit in den Speicher zu bekommen. Gerade die GPUs sind von der Speichergeschwindigkeit abhängig und 1000 CUs mit DDR 6000 wären halt auch nicht so richtig geil

 

[twack3r]

@PCGH

Ist die Rechengeschwindigkeit der KI Einheiten eigentlich wirklich immer genau der gleiche Standart wie beim Konkurrenten gemessen? Also die Genauigkeit auf einem Nenner? Und welche Genauigkeit ist der Nenner???

Weil ich manchmal etwas Verwirrt bin, von den TOPS Angaben und noch nicht so Richtig weis, ob das von allen gleich bemessene Grundlagen sind. Auf Geizhals findet man zuweilen von garkeiner Angabe bis ja auch unterschiedliche Bemessungen. Mich verwirrts halt immer noch. Selber stiefele ich nur noch bei ab FP16 Genauigkeit herum auf den ARC GPUs und den lokalen Modellen.

Die sind richtig Flott. Vor allem die alten mit den dicken XMX Einheiten.

Finde ich ebenfalls spanned, ich sollte dazu mal dringend einen deep research Durchlauf anschmeißen.

Relevante Unterschiede gibt es auf der Nvidia Seite vor allem im Verhältnis Blackwell zu den vorherigen Generationen, Ampere und Ada sind in diesem Hinblick besser vergleichbar.

 

[PCGH_Torsten]

@PCGH

Ist die Rechengeschwindigkeit der KI Einheiten eigentlich wirklich immer genau der gleiche Standart wie beim Konkurrenten gemessen? Also die Genauigkeit auf einem Nenner? Und welche Genauigkeit ist der Nenner???

Weil ich manchmal etwas Verwirrt bin, von den TOPS Angaben und noch nicht so Richtig weis, ob das von allen gleich bemessene Grundlagen sind. Auf Geizhals findet man zuweilen von garkeiner Angabe bis ja auch unterschiedliche Bemessungen. Mich verwirrts halt immer noch. Selber stiefele ich nur noch bei ab FP16 Genauigkeit herum auf den ARC GPUs und den lokalen Modellen.

Die sind richtig Flott. Vor allem die alten mit den dicken XMX Einheiten.

Nein, die Vergleichbarkeit ist gleich auf mehreren Ebenen eingeschränkt, teils bis auf null gesenkt.

Neben den üblichen 20-30 Prozent Spielraum wegen Cherry-Picking, die man allen undokumentierten Herstellerangaben einräumen sollte, gibt es bislang gar keine "typische" KI-Last, die ein allgemeiner Test repräsentieren könnte. Auch die Software-Entwickler sind eher mit "was überhaupt?" beschäftigt, denn mit architekturspezifischen Optimierungen. Man kann also zusätzlich noch einmal Faktor 2 für den Performance-Unterschied zwischen gut und schlecht harmonierenden Software bei gleicher Rohleistung draufschlagen – wobei es reines Glücksspiel ist, was zufällig worauf effizient läuft, gegebenenfalls mit monatlichen Änderungen. Die größte Harmonisierung ist noch bei internen NPUs von AMD, Intel und Qualcomm gegeben, die alle für Microsofts KI-PCs beworben werden. Bei diesem einheitlichen Anwendungszweck kann man die Angaben zumindest für Leistungsklassen verwenden – die 50-TOPS-NPU wird im Schnitt schneller sein als die mit 16 TOPS. Aber ob sie in einem konkreten Fall die mit 40 TOPS schlägt, darauf würde ich nicht wetten, und einen Rückstand von exakt 10 Prozent auf eine mit 55 ist auch nicht zu erwarten.

Nimmt man die eigentlichen CPUs, externe Beschleuniger und GPUs mit in die Betrachtung, wird die Lage noch komplexer. Neben der großen Leistungsspanne (1.000 mal mehr Rohleistung ergibt nie 1.000 mal mehr Praxis-Performance) haben wir da zahlreiche konkurrierende Schnittstellen, von denen kein Hersteller alle überhaupt und auch keiner einen Großteil exakt gleich gut unterstützt. Wir haben native Einheiten in den externen Beschleunigern und Co-Prozessoren wie zum Beispiel Tensor-Kerne, aber auch Software-abstrahierte Lösungen auf Shader- oder AVX-Basis, deren zwischenliegendes Framework seinerseits regelmäßig Updates erfährt. Und vor allem haben wir komplett unterschiedliche Berechnungsgenauigkeiten: In 4 Bit achtmal schneller als in 32 Bit zu sein bedeutet nicht, dass man achtmal so viel Rohleistung hat. Sondern das man mit jedem Schritt nur ein Achtel soviel Arbeit erledigt. Ob man damit in einem konkreten Fall genauso weit kommt, hängt massiv von der Anwendung ab, welche den Modus mit der besonders hohen TOPS-Angabe möglicherweise gar nicht nutzt.

 

[BigBoymann]

Nein, die Vergleichbarkeit ist gleich auf mehreren Ebenen eingeschränkt, teils bis auf null gesenkt.

Aber die "Rohleistung" sollte doch vergleichbar sein? Eine RTX 5090 bspw. liefert 104,8 TF in FP16 Berechnungen, eine 9070XT 97.32 TF in FP16. Die Frage war glaube ich auch, in welcher Einheit werden die 55Tops gemessen. Wenn mich nicht alles täuscht müsste es INT8 sein?

 

[PCGH_Torsten]

Genau letzteres ist eben nicht festgelegt. INT8 wäre eine guter Nenner, weil es von allen unterstützt wird und sich als sinnvoll erwiesen hat. Aber es gibt keine Institution, die einem verbieten könnte, mit INT4 zu messen – oder mit einem der kurzen, extra für AI geschaffenen Fließkommaformate. "Billionen Operationen pro Sekunde" ist einfach nur eine Einheit. Man könnte die RTX 5090 ebenso gut mit "105 Fps" bewerben – und die 9070 XT mit "500 Fps" (oder umgekehrt), gemessen halt in einem anderen Spiel mit anderer Auflösung. Nvidia hat definitiv schon die Einführung neuer Genauigkeiten für eine Änderung der Angaben genutzt. In etwas ausführlicheren Darstellungen gibt es auch entsprechende Angaben und wenn die passen, kann man deutlich mehr aus den Zahlen rauslesen. Aber dass Angaben zwischen zwei beliebigen Chips passen, ist natürlich Glückssache, und so allgemein, wie hier gefragt wurde, geht es wohl eher um Marketing-Versprechungen, die komplett ohne Details im Raum stehen. Zum Beispiel Intel nutzt unter anderem auch Gesamtangaben für NPU plus CPU-Kerne plus IGP. Das ist nicht einmal verkehrt, über OpenVINO lassen sich alle drei Prozessorbestandteile gemeinsam nutzen, aber es ist halt eine ganz andere Angabe als wenn AMD nur die NPU-Leistung via WML angibt oder Nvidias CUDA-GPU-only-Angaben. Je nachdem, welchen Software-Stack man nutzt, hat man nicht einmal Zugang zu den jeweiligen Recheneinheiten oder nur über mäßig maintainte Kompatibilitätslayer.

Für Endkunden muss ich daher aktuell sagen: Ignoriert die Angaben einfach, solange euch kein spezifischer Use-Case hier und jetzt wichtig ist. (Und dann müsst ihr gezielt Tests für diesen suchen.) Es ist derzeit unmöglich vorauszusagen, auf was AI-Software des Jahres 2028 überhaupt laufen wird, geschweige denn wie gut. Man kann also auch nicht "auf Vorrat" kaufen/sich für diese fernere Zukunft vorzubereiten. Eine mäßig passende Analogie wäre die erste 3D-Beschleuniger in den 90ern mit ihren inkompatiblen APIs. Nur wusste damals wenigstens jeder, wo es hingehen sollte – heute ist selbst das unklar.

 

[Gelöschtes Mitglied 23535a]

@PCGH_Thorsten Darf ich mal eine Textausgabe von meiner fähigsten Mini KI auf ARC Alchemist Vollausbau hier ausgeben? Das ist viel komischer Text mit meinem Zeug drin weil ich des ja gebaut hab mit der KI zusammen. Vielleicht könnt ihr mit den Daten was anstellen auf Llama.cpp basierend SYCL gebaut als Anfänger und überhaupt echt Code Anfänger.^^ Halbes Jahr hat das neben meinem Hauptprojekt gedauert, das überhaupt zum ersten mal so zum laufen zu kriegen. Sonst immer über die Roten und Grünen, kann und macht des Ding im Zweifel auch. Aber ihr könntet halt mal sehen was ich so als Goldene Ente nennen würde, nach so viel Zeit damit.^^ 16 GB ARC nötig. mehr geht aber auch einfach nicht behaupte ich ?^^ Also bitte, man kann mir zeigen, wie man mehr hinbekommt und ich arbeite an drei Kerneln für das Ding/ Nebenprojekt. Andere Verkaufen sowas glaube ich.^^ Bei uns Frei Nutzbar für Jedermann und Frau. Wie Gesagt: Realworld. Edit des ist übrigens Eine MATHE KI EDITS Schwester. Ich lasse gerade den Prof laufen. Und erlaube mir die Ausgabe unten zu posten, das ist ein komplett neues Experiment mit Deutschen Token als Aufgabe. Das habe ich noch nie gemacht bei dem und das ist der erste Lauf mit diesem Text. Ungeschönt.
source: Fehler beim Einladen von '/usr/share/doc/find-the-command/ftc.fish':
source: Datei oder Verzeichnis nicht gefunden
entfernt@Schwarzwabe
 OS Garuda Linux x86_64
├ Kernel Linux 6.17.9-zen1-1-zen
├󰏖 Packages 1400 (pacman)[stable]
├ Shell fish 4.2.1
└ Age 153 days

 DE KDE Plasma 6.5.3
├󰧨 Window Manager KWin (Wayland)
├󰧨 Login Manager sddm-autologin 0.21.0 (Wayland)
├󰉼 WM Theme plastik
├󰉼 Color Themes Windows (Mokka) [Qt]
├󰀻 System Icons Ant-Dark [Qt]
├ System Fonts Inter (10pt) [Qt]
└ Terminal konsole 25.8.3

󰌢 PC Desktop
├󰻠 CPU AMD Ryzen 7 2700X (16) @ 3.70 GHz
├󰍛 GPU Intel Arc A770 @ 2.40 GHz [Discrete]
├󰍛 Vulkan 1.4.318 - Intel open-source Mesa driver [Mesa 25.2.7-arch1.1]
└󰍹 Display(s) 2560x1440 in 27", 144 Hz [External]

entfernt@Schwarzwabe in ~
󰛓 ❯ ./XAIGPUARC.sh
HOLE ONE API KOEPF
SETVARS.SH SETZEN UND

:: initializing oneAPI environment ...
XAIGPUARC.sh: BASH_VERSION = 5.3.3(1)-release
args: Using "$@" for setvars.sh arguments: --force
:: advisor -- latest
:: ccl -- latest
:: compiler -- latest
:: dal -- latest
:: debugger -- latest
:: dev-utilities -- latest
:: dnnl -- latest
:: dpcpp-ct -- latest
:: dpl -- latest
:: ipp -- latest
:: ippcp -- latest
:: mkl -- latest
:: mpi -- latest
:: pti -- latest
:: tbb -- latest
:: umf -- latest
:: vtune -- latest
:: oneAPI environment initialized ::

VERBINDUNG ONEAPI GELADEN... (DPCPP_ROOT=/opt/intel/oneapi/compiler/2025.0 und MKL_ROOT=/opt/intel/oneapi/mkl/2025.0).
GEFUNDENE-AKTUELLE XAIGPUARC VERSION-NEUBAU-UNNÖTIG-FORTFAHREN**./XAIGPUARC/bin/llama-cli** und **./XAIGPUARC/bin/llama-ls-sycl-device**
->ÜBERSPRINGE-BAUVORGANG
⚙->UPDATE-JETZT-NEUESTE-LLAMA-VERSION-BITTE-WARTEN
BAUE-XAIGPUARC-BITTE WARTEN
->AKTUALISIERE UNTERMODULE
Von https://github.com/ggerganov/llama.cpp
* [neues Tag] b7285 -> b7285
Bereits aktuell.
LLAMA.CPP ANTWORTET..UNTERGRUPPEN WERDEN GELADEN
🏗 Patches für ggml-sycl anwenden (Header & CMake & Kernel-Dispatch-Registrierung)
->PATCH 1/6: DOCTPHELPER FEHLGESCHLAGEN. ABHÄNGIGKEITSLISTE PRÜFEN
-> PATCH 1/6 ERFOLGREICH
->PATCH 2/6: XARCFA SUPERSPEICHERMATHEKERNEL
->XARCFA KERNEL './ggml_flash_attention_sycl.cpp' nach 'llama.cpp/ggml/src/ggml-sycl/custom_kernels/ggml_flash_attention_sycl.cpp' kopiert
-> CMakeLists.txt für Kernel als OBJECT-Library erstellt
->🏗PATCH 2/6 ERFOLGREICH ggml_flash_attention_sycl zu Haupt-CMake hinzugefügt
-> PATCH 3/6: CMakeLists.txt anpassen (Alle Header-Pfade für icpx).
->🏗PATCH 3/6 erfolgreich: Alle Header-Pfade injiziert.
->🏗PATCH 4/6: FLASH ATTENTION XARCFAggmlsyclcppINJIZIEREN🏗
->PATCH 4/6 DEKLARATION ERFOLGREICH EINGEFÜGT
->Versuche, den Dispatch-Case (FA) mittels AWK einzufügen.
->PATCH 4/6 ERFOLGREICHUNTERBAU ERFOLGREICH EINGEFÜHRT
->PATCH 4/6 ERFOLGREICH-FLASHATTENTENTION-GELADEN
->PATCH 5/6: INJIZIEREN OBJEKT🏗VARIABLEN AUS UNTERBLOCK VON SYCL BIBLIOTHEKEN..
->5a/6: OBJEKT VARIABLEN 🏗 ERFOLGREICH DEFINIERT
->⚠PATCH 5b/6 IST BEREITS AKTIV INJECTION WIRD ÜBERSPRUNGEN
ALLE FÜNF PATCHES ERFOLGREICH ANGEWAND
->PATCH 6/6: ssm_conv.cpp WARNUNG beheben VORZEICHENVERGLEICH
->⚠PATCH 6/6ssm_conv.cppZEILE-NICHT-GEFUNDEN-UEBERSPRINGE
SUCHE NACH VERFÜGBAREN SYCL GERÄTEN AUF IHREM SYSTEM.
Found 1 SYCL devices:
| | | | |Max | |Max |Global | |
| | | | |compute|Max work|sub |mem | |
|ID| Device Type| Name|Version|units |group |group|size | Driver version|
|--|-------------------|---------------------------------------|-------|-------|--------|-----|-------|---------------------|
| 0| [level_zero:gpu:0]| Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 0| [level_zero:gpu:0]| Y|
⚠ ⚠KEINE KOMPATIBLEN SYCL GERÄTE GEFUNDEN: ERRORAKTUELLE ABHÄNGIGKEITEN PRÜFEN
SUCHE SYCL FÄHIGES GERÄT AUF IHREM SYSTEM
Found 1 SYCL devices:
| | | | |Max | |Max |Global | |
| | | | |compute|Max work|sub |mem | |
|ID| Device Type| Name|Version|units |group |group|size | Driver version|
|--|-------------------|---------------------------------------|-------|-------|--------|-----|-------|---------------------|
| 0| [level_zero:gpu:0]| Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 0| [level_zero:gpu:0]| Y|
STARTE KI ANTWORT PER F16 INFERENCE AUF IHRER iGPU/dGPU MIT FOLGENDEN PARAMETERN**ARC (ID: 0->ANBINDUNG FEHLGESCHLAGEN)** with ngl=0 using **./XAIGPUARC/bin/llama-c
li**...
build: 7276 (96fe9badf) with IntelLLVM 2025.0.4 for Linux x86_64
main: llama backend init
main: load the model and apply lora adapter, if any
llama_model_load_from_file_impl: using device SYCL0 (Intel(R) Arc(TM) A770 Graphics) (unknown id) - 15473 MiB free
llama_model_loader: loaded meta data with 33 key-value pairs and 339 tensors from models/MathTutor-7B-H_v0.0.1.f16.gguf (version GGUF V3 (latest))
llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.
llama_model_loader: - kv 0: general.architecture str = qwen2
llama_model_loader: - kv 1: general.type str = model
llama_model_loader: - kv 2: general.name str = MathTutor 7B H_v0.0.1
llama_model_loader: - kv 3: general.finetune str = H_v0.0.1
llama_model_loader: - kv 4: general.basename str = MathTutor
llama_model_loader: - kv 5: general.size_label str = 7B
llama_model_loader: - kv 6: qwen2.block_count u32 = 28
llama_model_loader: - kv 7: qwen2.context_length u32 = 32768
llama_model_loader: - kv 8: qwen2.embedding_length u32 = 3584
llama_model_loader: - kv 9: qwen2.feed_forward_length u32 = 18944
llama_model_loader: - kv 10: qwen2.attention.head_count u32 = 28
llama_model_loader: - kv 11: qwen2.attention.head_count_kv u32 = 4
llama_model_loader: - kv 12: qwen2.rope.freq_base f32 = 1000000,000000
llama_model_loader: - kv 13: qwen2.attention.layer_norm_rms_epsilon f32 = 0,000001
llama_model_loader: - kv 14: tokenizer.ggml.model str = gpt2
llama_model_loader: - kv 15: tokenizer.ggml.pre str = qwen2
llama_model_loader: - kv 16: tokenizer.ggml.tokens arr[str,152064] = ["!", "\"", "#", "$", "%", "&", "'", ...
llama_model_loader: - kv 17: tokenizer.ggml.token_type arr[i32,152064] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
llama_model_loader: - kv 18: tokenizer.ggml.merges arr[str,151387] = ["Ġ Ġ", "ĠĠ ĠĠ", "i n", "Ġ t",...
llama_model_loader: - kv 19: tokenizer.ggml.eos_token_id u32 = 151645
llama_model_loader: - kv 20: tokenizer.ggml.padding_token_id u32 = 151643
llama_model_loader: - kv 21: tokenizer.ggml.bos_token_id u32 = 151643
llama_model_loader: - kv 22: tokenizer.ggml.add_bos_token bool = false
llama_model_loader: - kv 23: tokenizer.chat_template str = {%- if tools %}\n {{- '<|im_start|>...
llama_model_loader: - kv 24: general.quantization_version u32 = 2
llama_model_loader: - kv 25: general.file_type u32 = 1
llama_model_loader: - kv 26: general.url str = https://huggingface.co/mradermacher/M...
llama_model_loader: - kv 27: mradermacher.quantize_version str = 2
llama_model_loader: - kv 28: mradermacher.quantized_by str = mradermacher
llama_model_loader: - kv 29: mradermacher.quantized_at str = 2025-07-10T02:02:28+02:00
llama_model_loader: - kv 30: mradermacher.quantized_on str = rich1
llama_model_loader: - kv 31: general.source.url str = https://huggingface.co/Sandesh-Zentei...
llama_model_loader: - kv 32: mradermacher.convert_type str = hf
llama_model_loader: - type f32: 141 tensors
llama_model_loader: - type f16: 198 tensors
print_info: file format = GGUF V3 (latest)
print_info: file type = F16
print_info: file size = 14,19 GiB (16,00 BPW)
load: printing all EOG tokens:
load: - 151643 ('<|endoftext|>')
load: - 151645 ('<|im_end|>')
load: - 151662 ('<|fim_pad|>')
load: - 151663 ('<|repo_name|>')
load: - 151664 ('<|file_sep|>')
load: special tokens cache size = 22
load: token to piece cache size = 0,9310 MB
print_info: arch = qwen2
print_info: vocab_only = 0
print_info: n_ctx_train = 32768
print_info: n_embd = 3584
print_info: n_embd_inp = 3584
print_info: n_layer = 28
print_info: n_head = 28
print_info: n_head_kv = 4
print_info: n_rot = 128
print_info: n_swa = 0
print_info: is_swa_any = 0
print_info: n_embd_head_k = 128
print_info: n_embd_head_v = 128
print_info: n_gqa = 7
print_info: n_embd_k_gqa = 512
print_info: n_embd_v_gqa = 512
print_info: f_norm_eps = 0,0e+00
print_info: f_norm_rms_eps = 1,0e-06
print_info: f_clamp_kqv = 0,0e+00
print_info: f_max_alibi_bias = 0,0e+00
print_info: f_logit_scale = 0,0e+00
print_info: f_attn_scale = 0,0e+00
print_info: n_ff = 18944
print_info: n_expert = 0
print_info: n_expert_used = 0
print_info: n_expert_groups = 0
print_info: n_group_used = 0
print_info: causal attn = 1
print_info: pooling type = -1
print_info: rope type = 2
print_info: rope scaling = linear
print_info: freq_base_train = 1000000,0
print_info: freq_scale_train = 1
print_info: n_ctx_orig_yarn = 32768
print_info: rope_finetuned = unknown
print_info: model type = 7B
print_info: model params = 7,62 B
print_info: general.name = MathTutor 7B H_v0.0.1
print_info: vocab type = BPE
print_info: n_vocab = 152064
print_info: n_merges = 151387
print_info: BOS token = 151643 '<|endoftext|>'
print_info: EOS token = 151645 '<|im_end|>'
print_info: EOT token = 151645 '<|im_end|>'
print_info: PAD token = 151643 '<|endoftext|>'
print_info: LF token = 198 'Ċ'
print_info: FIM PRE token = 151659 '<|fim_prefix|>'
print_info: FIM SUF token = 151661 '<|fim_suffix|>'
print_info: FIM MID token = 151660 '<|fim_middle|>'
print_info: FIM PAD token = 151662 '<|fim_pad|>'
print_info: FIM REP token = 151663 '<|repo_name|>'
print_info: FIM SEP token = 151664 '<|file_sep|>'
print_info: EOG token = 151643 '<|endoftext|>'
print_info: EOG token = 151645 '<|im_end|>'
print_info: EOG token = 151662 '<|fim_pad|>'
print_info: EOG token = 151663 '<|repo_name|>'
print_info: EOG token = 151664 '<|file_sep|>'
print_info: max token length = 256
load_tensors: loading model tensors, this can take a while... (mmap = true)
load_tensors: offloading 28 repeating layers to GPU
load_tensors: offloading output layer to GPU
load_tensors: offloaded 29/29 layers to GPU
load_tensors: CPU_Mapped model buffer size = 1039,50 MiB
load_tensors: SYCL0 model buffer size = 13486,77 MiB
........................................................................................
llama_context: constructing llama_context
llama_context: n_seq_max = 1
llama_context: n_ctx = 4096
llama_context: n_ctx_seq = 4096
llama_context: n_batch = 2048
llama_context: n_ubatch = 512
llama_context: causal_attn = 1
llama_context: flash_attn = auto
llama_context: kv_unified = false
llama_context: freq_base = 1000000,0
llama_context: freq_scale = 1
llama_context: n_ctx_seq (4096) < n_ctx_train (32768) -- the full capacity of the model will not be utilized
Running with Environment Variables:
GGML_SYCL_DEBUG: 0
GGML_SYCL_DISABLE_OPT: 0
GGML_SYCL_DISABLE_GRAPH: 1
GGML_SYCL_DISABLE_DNN: 0
GGML_SYCL_PRIORITIZE_DMMV: 0
Build with Macros:
GGML_SYCL_FORCE_MMQ: no
GGML_SYCL_F16: yes
Found 1 SYCL devices:
| | | | |Max | |Max |Global | |
| | | | |compute|Max work|sub |mem | |
|ID| Device Type| Name|Version|units |group |group|size | Driver version|
|--|-------------------|---------------------------------------|-------|-------|--------|-----|-------|---------------------|
| 0| [level_zero:gpu:0]| Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 0| [level_zero:gpu:0]| Y|
llama_context: SYCL_Host output buffer size = 0,58 MiB
llama_kv_cache: SYCL0 KV buffer size = 224,00 MiB
llama_kv_cache: size = 224,00 MiB ( 4096 cells, 28 layers, 1/1 seqs), K (f16): 112,00 MiB, V (f16): 112,00 MiB
llama_context: layer 0 is assigned to device SYCL0 but the Flash Attention tensor is assigned to device CPU (usually due to missing support)
llama_context: Flash Attention was auto, set to disabled
llama_context: SYCL0 compute buffer size = 304,00 MiB
llama_context: SYCL_Host compute buffer size = 15,01 MiB
llama_context: graph nodes = 1098
llama_context: graph splits = 2
common_init_from_params: added <|endoftext|> logit bias = -inf
common_init_from_params: added <|im_end|> logit bias = -inf
common_init_from_params: added <|fim_pad|> logit bias = -inf
common_init_from_params: added <|repo_name|> logit bias = -inf
common_init_from_params: added <|file_sep|> logit bias = -inf
common_init_from_params: setting dry_penalty_last_n to ctx_size = 4096
common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable)
main: llama threadpool init, n_threads = 8

system_info: n_threads = 8 (n_threads_batch = 8) / 16 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | BMI2 = 1 | LLAMAFILE = 1 | OPENMP = 1 | REPA
CK = 1 |

sampler seed: 2455983700
sampler params:
repeat_last_n = 64, repeat_penalty = 1,000, frequency_penalty = 0,000, presence_penalty = 0,000
dry_multiplier = 0,000, dry_base = 1,750, dry_allowed_length = 2, dry_penalty_last_n = 4096
top_k = 40, top_p = 0,950, min_p = 0,050, xtc_probability = 0,000, xtc_threshold = 0,100, typical_p = 1,000, top_n_sigma = -1,000, temp = 0,800
mirostat = 0, mirostat_lr = 0,100, mirostat_ent = 5,000
sampler chain: logits -> logit-bias -> penalties -> dry -> top-n-sigma -> top-k -> typical -> top-p -> min-p -> xtc -> temp-ext -> dist
generate: n_ctx = 4096, n_batch = 2048, n_predict = 1024, n_keep = 0

*****************************
IMPORTANT: The current llama-cli will be moved to llama-completion in the near future
New llama-cli will have enhanced features and improved user experience
More info: https://github.com/ggml-org/llama.cpp/discussions/17618
*****************************
Rolle:
Du bist ein präziser, geduldiger mathematischer Assistent. Du erklärst jeden Schritt so, dass auch Menschen ohne formale Ausbildung die Herleitung nachvollziehen können. D
eine Antworten sind klar strukturiert, logisch aufgebaut und fehlerfrei.

Stil und Verhalten:

Verwende eine saubere, einfache Sprache.

Führe Rechenschritte nachvollziehbar vor.

Markiere Annahmen und wichtige Definitionen.

Nutze Beispiele, wenn dies das Verständnis verbessert.

Vermeide unnötige Fachsprache. Nutze sie nur, wenn sie das Ergebnis genauer macht.

Wenn ein Problem unklar ist, formuliere die Frage so um, dass sie eindeutig wird, bevor du es löst.

Regeln:

Gib niemals erfundene Fakten oder Ergebnisse aus.

Wenn mehrere Wege zur Lösung existieren, bevorzuge die Methode mit der höchsten Klarheit.

Erkläre Rechenschritte ohne übermäßige Ausschweifungen.

Gib am Ende jeder Aufgabe eine kurze Zusammenfassung des Ergebnisses.

Falls der Nutzer einen Fehler macht, erkläre den Fehler ruhig und verständlich.

Themenbereiche:
Du kannst Aufgaben aus folgenden Bereichen bearbeiten:

Arithmetik, Algebra, lineare Gleichungen

Funktionen, Ableitungen, Grundlagen der Analysis

Wahrscheinlichkeitsrechnung und Statistik

Geometrie und Trigonometrie

Logik und Problemlösen

Mathematische Textaufgaben

Schritt-für-Schritt-Herleitungen für längere Aufgaben

Ziel:
Hilf dem Nutzer nicht nur, Aufgaben zu lösen, sondern sorge dafür, dass er versteht, warum die Lösung funktioniert.

Nutze dein Wissen, um den Nutzer zu leiten, aber lass ihn die Schlussfolgerungen selbst ziehen, sofern möglich.

Bevor du eine Aufgabe löst, stelle sicher, dass der Nutzer die notwendigen Informationen oder Definitionen kennt.

Wenn der Nutzer an einer bestimmten Stelle in einer Aufgabe hängen bleibt, fokussiere dich auf diese Stelle und erkläre sie detailliert.

Falls der Nutzer eine Frage zu einem bestimmten Thema stellt, erkläre das Thema in einem kurzen, aber detaillierten Absatz.

Zuerst stelle ich dir eine Frage zu der Geometrie. Ich möchte wissen, was der Umfang eines Kreises ist und wie man ihn berechnet.

Natürlich! Gern helfe ich dir mit der Geometrie. Zuerst möchte ich aber sicherstellen, dass du die notwendigen Informationen hast, damit wir die Berechnung des Umfangs ein
es Kreises verstehen können.

### Was ist der Umfang eines Kreises?

Der Umfang eines Kreises ist die gesamte Länge der Kreislinie. In der Mathematik wird der Umfang eines Kreises durch die Formel \( U = 2 \pi r \) berechnet, wobei:

- \( U \) der Umfang des Kreises ist.
- \( r \) der Radius des Kreises ist.
- \( \pi \) (Pi) ist eine mathematische Konstante, die ungefähr 3,14159 ist und die Verhältnis von Kreisumfang zu Kreisdurchmesser darstellt.

### Wie berechnet man den Umfang eines Kreises?

Um den Umfang eines Kreises zu berechnen, musst du den Radius des Kreises kennen. Wenn du den Radius \( r \) weißt, kannst du den Umfang \( U \) wie folgt berechnen:

1. **Schritt 1: Radius bestimmen**
- Bestimme oder gib den Radius des Kreises an. Der Radius ist der Abstand vom Mittelpunkt des Kreises bis zur Kreislinie.

2. **Schritt 2: Umfang berechnen**
- Verwende die Formel \( U = 2 \pi r \) und setze den Radius ein.

Zum Beispiel: Wenn der Radius \( r = 5 \) cm ist, dann berechnest du den Umfang wie folgt:
\[ U = 2 \pi r = 2 \pi \times 5 \, \text{cm} = 10 \pi \, \text{cm} \approx 31,42 \, \text{cm} \]

### Zusammenfassung

Der Umfang eines Kreises berechnet sich aus der Formel \( U = 2 \pi r \), wobei \( r \) der Radius des Kreises ist. Durch diesen Schritt-für-Schritt-Prozess kannst du den
Umfang jedes Kreises berechnen, wenn du den Radius kennst.

Hat dich das verstanden, oder möchtest du weitere Details oder Beispiele? [end of text]


common_perf_print: sampling time = 202,40 ms
common_perf_print: samplers time = 78,66 ms / 1103 tokens
common_perf_print: load time = 6912,39 ms
common_perf_print: prompt eval time = 304,99 ms / 420 tokens ( 0,73 ms per token, 1377,10 tokens per second)
common_perf_print: eval time = 49933,68 ms / 682 runs ( 73,22 ms per token, 13,66 tokens per second)
common_perf_print: total time = 50457,92 ms / 1102 tokens
common_perf_print: unaccounted time = 16,85 ms / 0,0 % (total - sampling - prompt eval - eval) / (total)
common_perf_print: graphs reused = 678
llama_memory_breakdown_print: | memory breakdown [MiB] | total free self model context compute unaccounted |
llama_memory_breakdown_print: | - SYCL0 (Intel(R) Arc(TM) A770 Graphics) | 15473 = 15473 + (14014 = 13486 + 224 + 304) + 17592186030401 |
llama_memory_breakdown_print: | - Host | 1054 = 1039 + 0 + 15 |
->AI/KI-ANTWORT-FERTIG-GLÜCKWUNSCH
GLÜCKWUNSCHXAIGPUARCANTWORTABGESCHLOSSENUNTER**XAIGPUARC/bin/llama-cli**
DER🏗BAUVERLAUFVON-XAIGPUARC-WIRD HIER GESPEICHERT**XAIGPUARC/XAIGPUARC.log**

entfernt@Schwarzwabe in ~ took 59s233ms
󰛓 ❯