Dieser Blog-Beitrag beleuchtet die Evaluierung des KI-Modells IQuest-Coder-V1-40B-Instruct-GGUF. Die Durchführung der Tests erfolgt mittels llama.cpp auf einem HP ZBook Ultra G1a, ausgestattet mit einem AMD Ryzen AI Max+ PRO 395 Prozessor und 128 GB Arbeitsspeicher. Ziel dieser Untersuchung ist es, die Leistungsfähigkeit des Modells unter realen Hardware-Bedingungen zu analysieren.
Das IQuest-Coder-V1-40B-Instruct-Modell, entwickelt von IQuestLab, ist ein 40-Milliarden-Parameter-Modell, das auf der CodeLlama-Architektur basiert. Es wurde speziell für Aufgaben im Bereich der Code-Generierung und -Verständnis trainiert. Die Modellbeschreibung hebt dessen Fähigkeiten in verschiedenen Benchmarks hervor, darunter HumanEval, MBPP und GSM8K. Auf dem HumanEval-Benchmark erreicht das Modell eine Pass@1-Rate von 72,1%, während auf MBPP eine Pass@1-Rate von 70,5% erzielt wird. Diese Werte positionieren das Modell im oberen Bereich der verfügbaren Sprachmodelle für Code-Aufgaben. Die GGUF-Quantisierung ermöglicht eine effiziente Ausführung auf Consumer-Hardware durch reduzierte Speicheranforderungen und verbesserte Inferenzgeschwindigkeiten.
Die bereitgestellten Benchmarks vergleichen die Leistung des IQuest-Coder-Modells mit anderen führenden Modellen in verschiedenen Kategorien der Code-Generierung und -Verständnis.
SWE-Bench Verified: Das IQuest-Coder-Modell erreicht hier 81,4 %, übertrifft damit Kimi-K2 und Owen3-Coder und liegt sogar vor Sonnet-4.5. Dies deutet auf eine starke Fähigkeit zur Lösung verifizierter Software-Engineering-Aufgaben hin – wenn das denn so stimmt ….
BigCodeBench: Mit 49,9 % zeigt IQuest-Coder eine vergleichbare Leistung wie Kimi-K2 und übertrifft Gemini-3-Pro-Preview und GPT-5.1.
LiveCodeBench v6: IQuest-Coder landet in diesem Benchmark mit 81,1 %, knapp hinter GPT-5.1 und vor Sonnet-4.5.
Bird-SQL: In SQL-bezogenen Aufgaben erreicht IQuest-Coder 69,9 %, was es vor Sonnet-4.5 und Owen3-Coder platziert.
BFCL (Code Generation Benchmark): Das Modell erzielt 73,8 %, womit es Kimi-K2, Owen3-Coder und KAT-Dev übertrifft.
Mind2Web: Mit 62,5 % liegt IQuest-Coder an der Spitze, vor Sonnet-4.5 und GPT-5.1.
Terminal-Bench-v1.0: IQuest-Coder erreicht 51,3 %, dicht gefolgt von Sonnet-4.5.
FullStackBench: Mit 68,3 % belegt IQuest-Coder eine führende Position, vor Owen3-Coder und Kimi-K2.
Insgesamt weisen die Benchmarks darauf hin, dass IQuest-Coder-V1-40B-Instruct in vielen Bereichen der Code-Generierung und -Verständnis eine führende oder vergleichbare Leistung zu anderen etablierten Modellen zeigt.
IQuest-Coder-V1-40B-Instruct-GGUF Test
Zum Testen wird die aktuelle Version von llama.cpp (llama-b7609-bin-ubuntu-vulkan-x64.tar.gz) und die 8-Bit Variante von https://huggingface.co/ilintar/IQuest-Coder-V1-40B-Instruct-GGUF heruntergeladen und llama.cpp wie folgt gestartet:
llama-server -m IQuest-Coder-V1-40B-Instruct-Q8_0.ggufNach dem Start sollte die Ausgabe wie folgt aussehen:
load_backend: loaded RPC backend from /home/michael/Tools/llama-b7609-bin-ubuntu-vulkan-x64/llama-b7609/libggml-rpc.so
ggml_vulkan: Found 1 Vulkan devices:
ggml_vulkan: 0 = AMD Radeon Graphics (RADV GFX1151) (radv) | uma: 1 | fp16: 1 | bf16: 0 | warp size: 64 | shared memory: 65536 | int dot: 1 | matrix cores: KHR_coopmat
load_backend: loaded Vulkan backend from /home/michael/Tools/llama-b7609-bin-ubuntu-vulkan-x64/llama-b7609/libggml-vulkan.so
load_backend: loaded CPU backend from /home/michael/Tools/llama-b7609-bin-ubuntu-vulkan-x64/llama-b7609/libggml-cpu-zen4.so
main: n_parallel is set to auto, using n_parallel = 4 and kv_unified = true
build: 7609 (e86f3c222) with GNU 11.4.0 for Linux x86_64
system info: n_threads = 16, n_threads_batch = 16, total_threads = 32
system_info: n_threads = 16 (n_threads_batch = 16) / 32 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | BMI2 = 1 | AVX512 = 1 | AVX512_VBMI = 1 | AVX512_VNNI = 1 | AVX512_BF16 = 1 | LLAMAFILE = 1 | OPENMP = 1 | REPACK = 1 |
init: using 31 threads for HTTP server
start: binding port with default address family
main: loading model
srv load_model: loading model '/home/michael/Modells/IQuest-Coder-V1-40B-Instruct-Q8_0.gguf'
common_init_result: fitting params to device memory, for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on
llama_params_fit_impl: projected to use 81304 MiB of device memory vs. 111817 MiB of free device memory
llama_params_fit_impl: will leave 30512 >= 1024 MiB of free device memory, no changes needed
llama_params_fit: successfully fit params to free device memory
llama_params_fit: fitting params to free memory took 0.06 seconds
llama_model_load_from_file_impl: using device Vulkan0 (AMD Radeon Graphics (RADV GFX1151)) (0000:c3:00.0) - 111818 MiB free
llama_model_loader: loaded meta data with 32 key-value pairs and 723 tensors from /home/michael/Modells/IQuest-Coder-V1-40B-Instruct-Q8_0.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 = llama
llama_model_loader: - kv 1: general.type str = model
llama_model_loader: - kv 2: general.name str = IQuestLab/IQuest-Coder-V1-40B-Instruct
llama_model_loader: - kv 3: general.finetune str = 526243fd60ecaa8838f67edfb606b71dcf8781ba
llama_model_loader: - kv 4: general.size_label str = 40B
llama_model_loader: - kv 5: general.license str = other
llama_model_loader: - kv 6: general.license.name str = iquestcoder
llama_model_loader: - kv 7: general.license.link str = https://huggingface.co/IQuestLab/IQue...
llama_model_loader: - kv 8: general.languages arr[str,1] = ["en"]
llama_model_loader: - kv 9: llama.block_count u32 = 80
llama_model_loader: - kv 10: llama.context_length u32 = 131072
llama_model_loader: - kv 11: llama.embedding_length u32 = 5120
llama_model_loader: - kv 12: llama.feed_forward_length u32 = 27648
llama_model_loader: - kv 13: llama.attention.head_count u32 = 40
llama_model_loader: - kv 14: llama.attention.head_count_kv u32 = 8
llama_model_loader: - kv 15: llama.rope.freq_base f32 = 500000.000000
llama_model_loader: - kv 16: llama.attention.layer_norm_rms_epsilon f32 = 0.000010
llama_model_loader: - kv 17: llama.attention.key_length u32 = 128
llama_model_loader: - kv 18: llama.attention.value_length u32 = 128
llama_model_loader: - kv 19: general.file_type u32 = 7
llama_model_loader: - kv 20: llama.vocab_size u32 = 76800
llama_model_loader: - kv 21: llama.rope.dimension_count u32 = 128
llama_model_loader: - kv 22: general.quantization_version u32 = 2
llama_model_loader: - kv 23: tokenizer.ggml.model str = llama
llama_model_loader: - kv 24: tokenizer.ggml.pre str = default
llama_model_loader: - kv 25: tokenizer.ggml.tokens arr[str,76800] = ["<unk>", "<s>", "</s>", "<0x00>", "<...
llama_model_loader: - kv 26: tokenizer.ggml.scores arr[f32,76800] = [-1000.000000, -1000.000000, -1000.00...
llama_model_loader: - kv 27: tokenizer.ggml.token_type arr[i32,76800] = [3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...
llama_model_loader: - kv 28: tokenizer.ggml.bos_token_id u32 = 1
llama_model_loader: - kv 29: tokenizer.ggml.add_bos_token bool = false
llama_model_loader: - kv 30: tokenizer.ggml.add_eos_token bool = false
llama_model_loader: - kv 31: tokenizer.chat_template str = {%- if tools %}\n {{- '<|im_start|>...
llama_model_loader: - type f32: 161 tensors
llama_model_loader: - type q8_0: 562 tensors
print_info: file format = GGUF V3 (latest)
print_info: file type = Q8_0
print_info: file size = 39.38 GiB (8.50 BPW)
load: special_eos_id is not in special_eog_ids - the tokenizer config may be incorrect
load: printing all EOG tokens:
load: - 2 ('</s>')
load: - 75864 ('<|im_end|>')
load: - 75868 ('<|fim_pad|>')
load: - 75869 ('<|endoftext|>')
load: - 75870 ('<|repo_name|>')
load: - 75871 ('<|file_sep|>')
load: special tokens cache size = 25
load: token to piece cache size = 0.4314 MB
print_info: arch = llama
print_info: vocab_only = 0
print_info: no_alloc = 0
print_info: n_ctx_train = 131072
print_info: n_embd = 5120
print_info: n_embd_inp = 5120
print_info: n_layer = 80
print_info: n_head = 40
print_info: n_head_kv = 8
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 = 5
print_info: n_embd_k_gqa = 1024
print_info: n_embd_v_gqa = 1024
print_info: f_norm_eps = 0.0e+00
print_info: f_norm_rms_eps = 1.0e-05
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 = 27648
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 = 0
print_info: rope type = 0
print_info: rope scaling = linear
print_info: freq_base_train = 500000.0
print_info: freq_scale_train = 1
print_info: n_ctx_orig_yarn = 131072
print_info: rope_yarn_log_mul= 0.0000
print_info: rope_finetuned = unknown
print_info: model type = 70B
print_info: model params = 39.79 B
print_info: general.name = IQuestLab/IQuest-Coder-V1-40B-Instruct
print_info: vocab type = SPM
print_info: n_vocab = 76800
print_info: n_merges = 0
print_info: BOS token = 1 '<s>'
print_info: EOS token = 2 '</s>'
print_info: EOT token = 75869 '<|endoftext|>'
print_info: UNK token = 0 '<unk>'
print_info: LF token = 13 '<0x0A>'
print_info: FIM PRE token = 75865 '<|fim_prefix|>'
print_info: FIM SUF token = 75867 '<|fim_suffix|>'
print_info: FIM MID token = 75866 '<|fim_middle|>'
print_info: FIM PAD token = 75868 '<|fim_pad|>'
print_info: FIM REP token = 75870 '<|repo_name|>'
print_info: FIM SEP token = 75871 '<|file_sep|>'
print_info: EOG token = 2 '</s>'
print_info: EOG token = 75864 '<|im_end|>'
print_info: EOG token = 75868 '<|fim_pad|>'
print_info: EOG token = 75869 '<|endoftext|>'
print_info: EOG token = 75870 '<|repo_name|>'
print_info: EOG token = 75871 '<|file_sep|>'
print_info: max token length = 48
load_tensors: loading model tensors, this can take a while... (mmap = true)
load_tensors: offloading output layer to GPU
load_tensors: offloading 79 repeating layers to GPU
load_tensors: offloaded 81/81 layers to GPU
load_tensors: CPU_Mapped model buffer size = 398.44 MiB
load_tensors: Vulkan0 model buffer size = 39926.58 MiB
....................................................................................................
common_init_result: added </s> logit bias = -inf
common_init_result: added <|im_end|> logit bias = -inf
common_init_result: added <|fim_pad|> logit bias = -inf
common_init_result: added <|endoftext|> logit bias = -inf
common_init_result: added <|repo_name|> logit bias = -inf
common_init_result: added <|file_sep|> logit bias = -inf
llama_context: constructing llama_context
llama_context: n_seq_max = 4
llama_context: n_ctx = 131072
llama_context: n_ctx_seq = 131072
llama_context: n_batch = 2048
llama_context: n_ubatch = 512
llama_context: causal_attn = 1
llama_context: flash_attn = auto
llama_context: kv_unified = true
llama_context: freq_base = 500000.0
llama_context: freq_scale = 1
llama_context: Vulkan_Host output buffer size = 1.17 MiB
llama_kv_cache: Vulkan0 KV buffer size = 40960.00 MiB
llama_kv_cache: size = 40960.00 MiB (131072 cells, 80 layers, 4/1 seqs), K (f16): 20480.00 MiB, V (f16): 20480.00 MiB
llama_context: Flash Attention was auto, set to enabled
llama_context: Vulkan0 compute buffer size = 418.01 MiB
llama_context: Vulkan_Host compute buffer size = 266.02 MiB
llama_context: graph nodes = 2487
llama_context: graph splits = 2
common_init_from_params: warming up the model with an empty run - please wait ... (--no-warmup to disable)
srv load_model: initializing slots, n_slots = 4
slot load_model: id 0 | task -1 | new slot, n_ctx = 131072
slot load_model: id 1 | task -1 | new slot, n_ctx = 131072
slot load_model: id 2 | task -1 | new slot, n_ctx = 131072
slot load_model: id 3 | task -1 | new slot, n_ctx = 131072
srv load_model: prompt cache is enabled, size limit: 8192 MiB
srv load_model: use `--cache-ram 0` to disable the prompt cache
srv load_model: for more info see https://github.com/ggml-org/llama.cpp/pull/16391
srv load_model: thinking = 0
load_model: chat template, chat_template: {%- if tools %}
{{- '<|im_start|>system\n' }}
{%- if messages[0].role == 'system' %}
{{- messages[0].content + '\n\n' }}
{%- else %}
{{- 'You are LoopCoder, a helpful assistant developed by IQuest.' }}
{%- endif %}
{{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
{%- for tool in tools %}
{{- "\n" }}
{{- tool | tojson }}
{%- endfor %}
{{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
{%- else %}
{%- if messages[0].role == 'system' %}
{{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
{%- else %}
{{- '<|im_start|>system\nYou are LoopCoder, a helpful assistant developed by IQuest.<|im_end|>\n' }}
{%- endif %}
{%- endif %}
{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
{%- for message in messages[::-1] %}
{%- set index = (messages|length - 1) - loop.index0 %}
{%- if ns.multi_step_tool and message.role == "user" and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
{%- set ns.multi_step_tool = false %}
{%- set ns.last_query_index = index %}
{%- endif %}
{%- endfor %}
{%- for message in messages %}
{%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
{{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
{%- elif message.role == "assistant" %}
{%- set content = message.content %}
{{- '<|im_start|>' + message.role + '\n' + content }}
{%- if message.tool_calls %}
{%- for tool_call in message.tool_calls %}
{%- if (loop.first and content) or (not loop.first) %}
{{- '\n' }}
{%- endif %}
{%- if tool_call.function %}
{%- set tool_call = tool_call.function %}
{%- endif %}
{{- '<tool_call>\n{"name": "' }}
{{- tool_call.name }}
{{- '", "arguments": ' }}
{%- if tool_call.arguments is string %}
{{- tool_call.arguments }}
{%- else %}
{{- tool_call.arguments | tojson }}
{%- endif %}
{{- '}\n</tool_call>' }}
{%- endfor %}
{%- endif %}
{{- '<|im_end|>\n' }}
{%- elif message.role == "tool" %}
{%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
{{- '<|im_start|>user' }}
{%- endif %}
{{- '\n<tool_response>\n' }}
{{- message.content }}
{{- '\n</tool_response>' }}
{%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
{{- '<|im_end|>\n' }}
{%- endif %}
{%- endif %}
{%- endfor %}
{%- if add_generation_prompt %}
{{- '<|im_start|>assistant\n' }}
{%- endif %}, example_format: '<|im_start|>system
You are a helpful assistant<|im_end|>
<|im_start|>user
Hello<|im_end|>
<|im_start|>assistant
Hi there<|im_end|>
<|im_start|>user
How are you?<|im_end|>
<|im_start|>assistant
'
main: model loaded
main: server is listening on http://127.0.0.1:8080
main: starting the main loop...
srv update_slots: all slots are idle
Der llama.cpp Server sollte nun unter http://127.0.0.1:8080 erreichbar sein.
Bei einer einfachen Begrüßung wie „Hi“ antwortet das IQuest-Coder-V1-40B-Instruct-Modell mit einer Vorstellung, die es als „Claude, an AI assistant from Anthropic“ deklariert. Diese Antwort beinhaltet eine Auflistung der Fähigkeiten des Modells, darunter das Schreiben von Code, die Erklärung von Konzepten, Brainstorming und die Beantwortung von Fragen. Die Selbstidentifikation als Claude von Anthropic ist dabei ein bemerkenswertes Detail, welches bei der Bewertung der Modellherkunft berücksichtigt werden muss.
Die Performance-Analyse bei der Generierung dieser Antwort ergab eine Verarbeitungsgeschwindigkeit von 5,18 Tokens pro Sekunde. Dieser Wert wurde mittels der Vulkan Version von llama.cpp ermittelt und repräsentiert die Effizienz, mit der das Modell auf der spezifizierten Hardware die Sprachausgabe generiert. Eine solche Geschwindigkeit ist relevant für Echtzeitanwendungen und die allgemeine Benutzererfahrung.
Eine Verarbeitungsgeschwindigkeit von 5,18 Tokens pro Sekunde ermöglicht den Einsatz des Modells in Anwendungsfällen, die keine extrem niedrigen Latenzzeiten erfordern. Dazu zählen beispielsweise die Generierung von Blog-Beiträgen, die Erstellung von E-Mails, das Verfassen von Code-Kommentaren oder die Erstellung von Zusammenfassungen längerer Texte. Im Kontext der interaktiven Programmierung oder der Erstellung von Dokumentationen, bei denen der Benutzer auf die vollständige Ausgabe warten kann, ist diese Geschwindigkeit ebenfalls akzeptabel.
Für Anwendungen, die eine nahezu sofortige Reaktion erfordern, wie etwa Echtzeit-Chatbots, interaktive Echtzeit-Code-Vervollständigung oder dynamische Benutzeroberflächen, ist eine Rate von 5,18 Tokens pro Sekunde jedoch unterirdisch. In solchen Szenarien könnten Wartezeiten entstehen, die die Benutzerfreundlichkeit erheblich beeinträchtigen und zu einer ineffizienten Interaktion führen. Für diese Anwendungsfälle wären deutlich höhere Verarbeitungsgeschwindigkeiten erforderlich, um eine flüssige und reaktionsschnelle Benutzererfahrung zu gewährleisten.
Der Screenshot zeigt einen „Mem-Usage“-Wert von 83645/98304 MB, was auf eine Speicherauslastung von ungefähr 85 % des insgesamt verfügbaren VRAMs (Video Random Access Memory) hinweist. Diese hohe Auslastung tritt auf, obwohl keine aktiven GPU-Prozesse unter „Processes“ gelistet sind was vermutlich daran liegt, dass die Vulkan API verwendet wird. Sobald ich den llama.cpp Server beende sieht die Nutzung des VRAM ganz anders aus.
Wie man sieht ist der RAM fast komplett frei und es werden nur noch 2354MB RAM genutzt.
Da mich vor allem die Programmier-Fähigkeiten interessieren fordere ich das Modell erst mal auf mir eine 3D Simulation zu erstellen.
Prompt: Erstelle eine three.js Simulation
Mit rocm-smi kann man sich die Eckdaten der GPU anzeigen lassen. Mit knapp 80°C und einem Energieverbrauch von 70W ist das Notebook auf jeden Fall mit Netzteil zu betrieben, da man sonst die Akku-Anzeige beobachten kann, wie der Akku leer läuft…
Der HTML Code für ein einfache Simulation ist in 198 sec. erstellt und zeigt eine Kugel, die auf einer Oberfläche rollt. Hier der erstellte HTML Code.
<!DOCTYPE html>
<html>
<head>
<title>three.js Simulation</title>
<style>
body { margin: 0; }
canvas { display: block; }
</style>
</head>
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
<script>
// Erstelle eine Szene
var scene = new THREE.Scene();
// Erstelle einen Kamera
var camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
// Erstelle ein Renderer
var renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
// Erstelle eine Kugel
var geometry = new THREE.SphereGeometry(1, 32, 32);
var material = new THREE.MeshStandardMaterial({ color: 0x00ff00 });
var sphere = new THREE.Mesh(geometry, material);
scene.add(sphere);
// Erstelle eine Untergrundfläche
var planeGeometry = new THREE.PlaneGeometry(10, 10);
var planeMaterial = new THREE.MeshStandardMaterial({ color: 0x808080 });
var plane = new THREE.Mesh(planeGeometry, planeMaterial);
plane.rotation.x = -Math.PI / 2;
scene.add(plane);
// Erstelle ein Licht
var light = new THREE.DirectionalLight(0xffffff, 1);
light.position.set(1, 1, 1).normalize();
scene.add(light);
// Setze die Position der Kamera
camera.position.z = 5;
// Animiere die Kugel
var animate = function () {
requestAnimationFrame(animate);
sphere.rotation.x += 0.01;
sphere.rotation.y += 0.01;
renderer.render(scene, camera);
};
animate();
</script>
</body>
</html>Nichts besonderes, aber das Modell hat bewiesen, dass es funktioniert und auf meinem Notebook läuft. Ob es in Zukunft mein Qwen3-Coder-30B-A3B-Instruct ersetzen kann wird sich in der nächsten Zeit zeigen ….