AMD Ryzen AI 400: Refresh-APUs mit mehr Takt zur CES 2026
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.
Noch bevor Ryzen AI 500 ("Medusa Point") mit Zen 6 ("Morpheus") übernimmt, wird AMD seinen aktuellen Mobilprozessoren der Serie Ryzen AI 300 ("Strix Point") eine minimale Frischzellenkur in Form der Ryzen AI 400 ("Gorgon Point") spendieren, welche als Strix Point Refresh in absehbarer Zeit in Notebooks kommen. Die effizienten mobilen Zen-5-APUs werden zur CES im Januar 2026 erwartet.
Während auf der CES 2026 mindestens sechs neue Modelle vorgestellt werden sollen, wird von einem Release im ersten Quartal des kommenden Jahres ausgegangen, das wie gehabt auf Zen 5 ("Nirvana"), Zen 5c ("Prometheus") und RDNA 3.5 ("GFX115X") zurückgreifen wird. Weiterhin alles wie gehabt. Die folgenden sechs SKUs sind inzwischen durchgesickert und aus mehreren Quellen bestätigt worden.
| Codename | Kerne/Threads | Boosttakt | IGP | NPU | |
|---|---|---|---|---|---|
| Ryzen AI 9 HX 470 | Gorgon Point | 12/24 | 5,25 GHz+ | Radeon 890M 16 Compute Units 1.024 Shadereinheiten |
XDNA 2 55 TOPS+ |
| Ryzen AI 9 465 | Gorgon Point | 10/20 | - | Radeon 890M 12 Compute Units 768 Shadereinheiten |
XDNA 2 50 TOPS |
| Ryzen AI 7 460 | Gorgon Point | 8/16 | - | Radeon 860M 8 Compute Units 512 Shadereinheiten |
XDNA 2 55 TOPS+ |
| Ryzen AI 7 450 | Gorgon Point 2 | 8/16 | - | Radeon 860M 8 Compute Units 512 Shadereinheiten |
XDNA 2 50 TOPS |
| Ryzen AI 5 440 | Gorgon Point 2 | 6/12 | - | Radeon 840M 4 Compute Units 256 Shadereinheiten |
XDNA 2 50 TOPS |
| Ryzen AI 5 430 | Gorgon Point 2 | 4/8 | - | Radeon 840M 4 Compute Units 256 Shadereinheiten |
XDNA 2 50 TOPS |
Wie schon bei den Ryzen AI 300 ("Strix Point") können sich sowohl zum Release als auch später noch weitere Modelle hinzugesellen. Zuletzt hat sich der Ryzen AI 5 430, welcher im Vergleich zum Ryzen AI 3 330 über eine doppelt so große IGP verfügt, in der Benchmark-Datenbank des Non-Profit-Konsortium BAPCo gezeigt.
Quelle: 포시포시
Unterhalb von Ryzen AI 400 ("Gorgon Point"), welche durch die Adaption von Krackan Point jetzt von Ryzen AI 9 bis Ryzen AI 3 reichen, wird weiterhin Hawk Point platziert, bei dem es sich bekanntlich um ein Phoenix Refresh handelt. Mit Grogon Point wird AMD auch wieder das "Gütesiegel" Copilot+ erhalten, das dank der starken APU im September 2024 auch Strix Point bereits "verliehen" wurde. Im Notebook-Segment erwarten Anwender also in diesem und kommenden Jahr erst einmal nur wenig technologische Neuerungen. AMDs Medusa Point mit Zen 6 wird wohl aller Voraussicht nach nicht vor Ende 2026 sein Debüt im Notebook feiern.
Quelle: 포시포시
Anders als die Ryzen AI 500 ("Medusa Point"), welche auf dem neuen und etwas größeren Sockel FP10 verlötet werden, kommen die Ryzen AI 400 ("Gorgon Point") weiterhin den von Ryzen AI 300 ("Strix Point") bekannten Sockel FP8 zum Einsatz.
| Codename | Prozessorkerne | Grafikeinheit | Sockel** | Release | |
|---|---|---|---|---|---|
| Ryzen AI 300 | Strix Point | Zen 5 (Nirvana) Zen 5c (Prometheus) |
RDNA 3.5 (GFX115X) |
FP8 25 × 40 mm |
2024 |
| Ryzen AI 400 | Gorgon Point | Zen 5 (Nirvana) Zen 5c (Prometheus) |
RDNA 3.5 (GFX115X) |
FP8 25 × 40 mm |
2026 |
| Ryzen AI 500 | Medusa Point | Zen 6 (Morpheus) Zen 6c (Monarch) |
RDNA 3.5 (GFX115X) |
FP10 25 × 42,5 mm |
2026/2027 |
Neben den neuen mobilen APUs könnte AMD auch endlich die Desktop-APUs auf der Basis von Zen 5 vorstellen, während der Ryzen 7 9850X3D als neuer Gaming-König als gesetzt gilt. Auch über einen Ryzen 9 9950X3D2 mit doppeltem 3D V-Cache wird gegenwärtig kräftig spekuliert. Die CES startet am 6. Januar 2026.
Ihre Meinung ist gefragt!
Wie stehen Sie zu diesem Thema? Die PCGH-Redaktion freut sich über Ihre fundierte Meinung in den Kommentaren zu dieser Meldung. Um zu kommentieren, müssen Sie auf PCGH.de oder im Extreme-Forum eingeloggt sein. Sollten Sie bisher noch keinen Account haben, könnten Sie sich hier unverbindlich registrieren. Beachten Sie beim Kommentieren aber bitte die geltenden Forenregeln.
Quelle: BAPCo via VideoCardz
.gif)
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. 
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)
├ 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)
├ System Icons Ant-Dark
├ System Fonts Inter (10pt)
└ Terminal konsole 25.8.3
PC Desktop
├ CPU AMD Ryzen 7 2700X (16) @ 3.70 GHz
├ GPU Intel Arc A770 @ 2.40 GHz
├ Vulkan 1.4.318 - Intel open-source Mesa driver
└ Display(s) 2560x1440 in 27", 144 Hz
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/ggerga...
* 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 ERFOLGREICH✅UNTERBAU 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| | Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 0| | Y|
⚠ ⚠KEINE KOMPATIBLEN SYCL GERÄTE GEFUNDEN: ERROR❌AKTUELLE 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| | Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 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 = = = | Intel Arc A770 Graphics| 12.55| 512| 1024| 32| 16225M| 1.13.36015|
SYCL Optimization Feature:
|ID| Device Type|Reorder|
|--|-------------------|-------|
| 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-o...
*****************************
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:
\
### 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?
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 | 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ÜCKWUNSCH✅XAIGPUARC🧠ANTWORT✨ABGESCHLOSSEN📝UNTER**XAIGPUARC/bin/llama-cli**
🔷 DER🏗BAUVERLAUF📝VON-XAIGPUARC-WIRD HIER GESPEICHERT**XAIGPUARC/XAIGPUARC.log**
entfernt@Schwarzwabe in ~ took 59s233ms
❯
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.
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.
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.
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.
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.