Überspringen und zum Inhalt gehen →

Leistungstest des Mixtral-8x22B-Instruct-v0.1.Q2_K.gguf Modells auf dem Jetson Orin 64 GB Developer Board

Mich interessiert der Einsatz des Mixtral-8x22B-Instruct-v0.1 Modells, von MistralAI, auf einem Jetson Orin 64 GB Developer Board in der Q2_K gguf Version.

Q2_K“ bezieht sich auf eine spezifische Art der Quantisierung innerhalb des Modellformats oder der Modellarchitektur, die im gguf-Format (General GPU Format) verwendet wird. Quantisierung sorg für geringeren Speicherverbrauch und schnellerer Verarbeitung, was besonders nützlich ist bei der Bereitstellung von Modellen auf Hardware mit begrenzten Ressourcen oder für Echtzeitanwendungen.

Mixtral-8x22B-Instruct-v0.1

Das Mixtral-8x22B-Instruct-v0.1 ist ein hochmodernes Modell, das speziell für Aufgaben im Bereich der Instruktionserfüllung konzipiert wurde. Für den Test habe ich es auf einem NVIDIA Jetson Orin 64 GB Developer Board geladen, einer Plattform, die für ihre leistungsstarken Rechenfähigkeiten und Optimierung für maschinelles Lernen bekannt ist.

JETSON AGX ORIN MODULE
AI Performance275 TOPs
GPUNVIDIA Ampere architecture with 2048 NVIDIA® CUDA® cores and 64 tensor cores
CPU12-core Arm Cortex-A78AE v8.2 64-bit CPU
3MB L2 + 6MB L3
DL Accelerator2x NVDLA v2.0
Vision AcceleratorPVA v2.0
Memory32GB/64GB 256-bit LPDDR5
204.8 GB/s
Storage64GB eMMC 5.1
Video Encode2x 4K60 | 4x 4K30 | 8x 1080p60 | 16x 1080p30 (H.265)
Video Decode1x 8K30 | 3x 4K60 | 7x 4K30 | 11x 1080p60 | 22x 1080p30 (H.265)

Ladezeit des Modells

Im Test zeigte sich, dass das Modell eine relativ hohe Ladezeit von ca. 100 Sekunden aufweist. Diese lange Ladezeit könnte in realen Anwendungen, wo schnelle Ladezeiten erforderlich sind, eine Herausforderung darstellen.

Token-Generierung und Verarbeitungsgeschwindigkeit

Während des Tests wurden insgesamt 493 Token generiert. Das Jetson Orin Developer Board hat ca. 275 TOPS und konnte ca. 5 Token pro Sekunde generieren. Das ist ein guter Wert, wenn man bedenkt, dass die Hardware nur einen Energieverbrauch von ca. 60 W (Siehe Viedeo unten) während der Token-Generierung hat.

Der Test

Das Test Skript lädt das Mixtral-8x22B-Instruct-v0.1.Q2_K GGUF Model und führt die Token-Generierung anhand des enthaltenen Prompts aus. Dabei werden hier alle Layer des Modells in der GPU verarbeitet.

#!/bin/sh

main -m gguf/Mixtral-8x22B-Instruct-v0.1.Q2_K-00001-of-00003.gguf -p "<BOS_TOKEN><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Du bist ein KI-Programmierassistent und beantwortest nur Fragen aus dem Bereich der Java Programmierung.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Schreibe eine Java Methode, welche entscheidet, ob es sich bei der übergebenen Jahreszahl um ein Schaltjahr handelt, oder nicht. Die Jahreszahl könnte man als Integer (int) übergeben, der Rückgabewert der Methode sollte ein Wahrheitswert (boolean) sein.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>" -n 400 -e --n-gpu-layers 99

Die folgende Log-Ausgabe enthält Ausgabe des Modells „Mixtral-8x22B-Instruct-v0.1“ von MistralAI in llama.cpp.

$ ./run.sh
Log start
main: build = 2680 (4fbd8098)
main: built with cc (Ubuntu 9.4.0-1ubuntu1~20.04.2) 9.4.0 for aarch64-linux-gnu
main: seed  = 1713603520
llama_model_loader: additional 2 GGUFs metadata loaded.
llama_model_loader: loaded meta data with 29 key-value pairs and 563 tensors from gguf/Mixtral-8x22B-Instruct-v0.1.Q2_K-00001-of-00003.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.name str              = models--mistralai--Mixtral-8x22B-Inst...
llama_model_loader: - kv   2:                          llama.block_count u32              = 56
llama_model_loader: - kv   3:                       llama.context_length u32              = 65536
llama_model_loader: - kv   4:                     llama.embedding_length u32              = 6144
llama_model_loader: - kv   5:                  llama.feed_forward_length u32              = 16384
llama_model_loader: - kv   6:                 llama.attention.head_count u32              = 48
llama_model_loader: - kv   7:              llama.attention.head_count_kv u32              = 8
llama_model_loader: - kv   8:                       llama.rope.freq_base f32              = 1000000,000000
llama_model_loader: - kv   9:     llama.attention.layer_norm_rms_epsilon f32              = 0,000010
llama_model_loader: - kv  10:                         llama.expert_count u32              = 8
llama_model_loader: - kv  11:                    llama.expert_used_count u32              = 2
llama_model_loader: - kv  12:                          general.file_type u32              = 10
llama_model_loader: - kv  13:                           llama.vocab_size u32              = 32768
llama_model_loader: - kv  14:                 llama.rope.dimension_count u32              = 128
llama_model_loader: - kv  15:                       tokenizer.ggml.model str              = llama
llama_model_loader: - kv  16:                      tokenizer.ggml.tokens arr[str,32768]   = ["<unk>", "<s>", "</s>", "[INST]", "[...
llama_model_loader: - kv  17:                      tokenizer.ggml.scores arr[f32,32768]   = [-1000,000000, -1000,000000, -1000,00...
llama_model_loader: - kv  18:                  tokenizer.ggml.token_type arr[i32,32768]   = [3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...
llama_model_loader: - kv  19:                tokenizer.ggml.bos_token_id u32              = 1
llama_model_loader: - kv  20:                tokenizer.ggml.eos_token_id u32              = 2
llama_model_loader: - kv  21:            tokenizer.ggml.unknown_token_id u32              = 0
llama_model_loader: - kv  22:               tokenizer.ggml.add_bos_token bool             = false
llama_model_loader: - kv  23:               tokenizer.ggml.add_eos_token bool             = false
llama_model_loader: - kv  24:                    tokenizer.chat_template str              = {{bos_token}}{% for message in messag...
llama_model_loader: - kv  25:               general.quantization_version u32              = 2
llama_model_loader: - kv  26:                                   split.no u16              = 0
llama_model_loader: - kv  27:                                split.count u16              = 3
llama_model_loader: - kv  28:                        split.tensors.count i32              = 563
llama_model_loader: - type  f32:  113 tensors
llama_model_loader: - type  f16:   56 tensors
llama_model_loader: - type q8_0:  112 tensors
llama_model_loader: - type q2_K:  169 tensors
llama_model_loader: - type q3_K:   56 tensors
llama_model_loader: - type q5_K:   56 tensors
llama_model_loader: - type q6_K:    1 tensors
llm_load_vocab: mismatch in special tokens definition ( 1027/32768 vs 259/32768 ).
llm_load_print_meta: format           = GGUF V3 (latest)
llm_load_print_meta: arch             = llama
llm_load_print_meta: vocab type       = SPM
llm_load_print_meta: n_vocab          = 32768
llm_load_print_meta: n_merges         = 0
llm_load_print_meta: n_ctx_train      = 65536
llm_load_print_meta: n_embd           = 6144
llm_load_print_meta: n_head           = 48
llm_load_print_meta: n_head_kv        = 8
llm_load_print_meta: n_layer          = 56
llm_load_print_meta: n_rot            = 128
llm_load_print_meta: n_embd_head_k    = 128
llm_load_print_meta: n_embd_head_v    = 128
llm_load_print_meta: n_gqa            = 6
llm_load_print_meta: n_embd_k_gqa     = 1024
llm_load_print_meta: n_embd_v_gqa     = 1024
llm_load_print_meta: f_norm_eps       = 0,0e+00
llm_load_print_meta: f_norm_rms_eps   = 1,0e-05
llm_load_print_meta: f_clamp_kqv      = 0,0e+00
llm_load_print_meta: f_max_alibi_bias = 0,0e+00
llm_load_print_meta: f_logit_scale    = 0,0e+00
llm_load_print_meta: n_ff             = 16384
llm_load_print_meta: n_expert         = 8
llm_load_print_meta: n_expert_used    = 2
llm_load_print_meta: causal attn      = 1
llm_load_print_meta: pooling type     = 0
llm_load_print_meta: rope type        = 0
llm_load_print_meta: rope scaling     = linear
llm_load_print_meta: freq_base_train  = 1000000,0
llm_load_print_meta: freq_scale_train = 1
llm_load_print_meta: n_yarn_orig_ctx  = 65536
llm_load_print_meta: rope_finetuned   = unknown
llm_load_print_meta: ssm_d_conv       = 0
llm_load_print_meta: ssm_d_inner      = 0
llm_load_print_meta: ssm_d_state      = 0
llm_load_print_meta: ssm_dt_rank      = 0
llm_load_print_meta: model type       = 8x22B
llm_load_print_meta: model ftype      = Q2_K - Medium
llm_load_print_meta: model params     = 140,63 B
llm_load_print_meta: model size       = 48,53 GiB (2,96 BPW)
llm_load_print_meta: general.name     = models--mistralai--Mixtral-8x22B-Instruct-v0.1
llm_load_print_meta: BOS token        = 1 '<s>'
llm_load_print_meta: EOS token        = 2 '</s>'
llm_load_print_meta: UNK token        = 0 '<unk>'
llm_load_print_meta: LF token         = 781 '<0x0A>'
ggml_cuda_init: GGML_CUDA_FORCE_MMQ:   no
ggml_cuda_init: CUDA_USE_TENSOR_CORES: yes
ggml_cuda_init: found 1 CUDA devices:
  Device 0: Orin, compute capability 8.7, VMM: yes
llm_load_tensors: ggml ctx size =    0,77 MiB
llm_load_tensors: offloading 56 repeating layers to GPU
llm_load_tensors: offloading non-repeating layers to GPU
llm_load_tensors: offloaded 57/57 layers to GPU
llm_load_tensors:        CPU buffer size =    63,00 MiB
llm_load_tensors:      CUDA0 buffer size = 49630,90 MiB
....................................................................................................
llama_new_context_with_model: n_ctx      = 512
llama_new_context_with_model: n_batch    = 512
llama_new_context_with_model: n_ubatch   = 512
llama_new_context_with_model: freq_base  = 1000000,0
llama_new_context_with_model: freq_scale = 1
llama_kv_cache_init:      CUDA0 KV buffer size =   112,00 MiB
llama_new_context_with_model: KV self size  =  112,00 MiB, K (f16):   56,00 MiB, V (f16):   56,00 MiB
llama_new_context_with_model:  CUDA_Host  output buffer size =     0,12 MiB
llama_new_context_with_model:      CUDA0 compute buffer size =   133,00 MiB
llama_new_context_with_model:  CUDA_Host compute buffer size =    13,01 MiB
llama_new_context_with_model: graph nodes  = 2862
llama_new_context_with_model: graph splits = 2

system_info: n_threads = 6 / 12 | AVX = 0 | AVX_VNNI = 0 | AVX2 = 0 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 0 | NEON = 1 | ARM_FMA = 1 | F16C = 0 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 0 | SSSE3 = 0 | VSX = 0 | MATMUL_INT8 = 0 |
sampling:
        repeat_last_n = 64, repeat_penalty = 1,000, frequency_penalty = 0,000, presence_penalty = 0,000
        top_k = 40, tfs_z = 1,000, top_p = 0,950, min_p = 0,050, typical_p = 1,000, temp = 0,800
        mirostat = 0, mirostat_lr = 0,100, mirostat_ent = 5,000
sampling order:
CFG -> Penalties -> top_k -> tfs_z -> typical_p -> top_p -> min_p -> temperature
generate: n_ctx = 512, n_batch = 2048, n_predict = 400, n_keep = 0


 <BOS_TOKEN><|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>Du bist ein KI-Programmierassistent und beantwortest nur Fragen aus dem Bereich der Java Programmierung.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|USER_TOKEN|>Schreibe eine Java Methode, welche entscheidet, ob es sich bei der übergebenen Jahreszahl um ein Schaltjahr handelt, oder nicht. Die Jahreszahl könnte man als Integer (int) übergeben, der Rückgabewert der Methode sollte ein Wahrheitswert (boolean) sein.<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>Hier ist die Java-Methode, die prüft, ob ein Jahr ein Schaltjahr ist oder nicht. Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100, oder wenn es durch 400 teilbar ist.

```java
public boolean isLeapYear(int year) {
    if (year % 4 == 0) {
        if (year % 100 == 0) {
            if (year % 400 == 0) {
                return true;
            } else {
                return false;
            }
        } else {
            return true;
        }
    } else {
        return false;
    }
}
```

<|END_OF_TURN_TOKEN|><|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>Diese Methode namens "isLeapYear" nimmt ein Jahr als Ganzzahl (int) entgegen und gibt einen booleschen Wert (boolean) zurück. Der boolesche Wert ist "true", wenn das Jahr ein Schaltjahr ist, und "false", wenn es kein Schaltjahr ist.<|END_OF_TURN_TOKEN|> [end of text]

llama_print_timings:        load time =  100380,31 ms
llama_print_timings:      sample time =      12,96 ms /   298 runs   (    0,04 ms per token, 22995,60 tokens per second)
llama_print_timings: prompt eval time =   12065,55 ms /   196 tokens (   61,56 ms per token,    16,24 tokens per second)
llama_print_timings:        eval time =   59149,97 ms /   297 runs   (  199,16 ms per token,     5,02 tokens per second)
llama_print_timings:       total time =   71388,16 ms /   493 tokens
Log end

Die Log Ausgabe enthält Informationen über:

  1. Lademodul des Modells (llama_model_loader):
    Es wurden Metadaten für das Modell geladen, einschließlich Schlüssel-Werte-Paare und Tensoren. Spezifische Eigenschaften des Modells wie Architektur, Blockanzahl, Kontextlänge und weitere wurden aufgelistet.
    Zusätzliche Informationen zu Tokenizer-Einstellungen und Token-IDs wurden dargestellt.
  2. Modellspezifikationen:
    Informationen zu verschiedenen Tensortypen und deren Anzahl im Modell.
  3. Systeminformationen und Sampling-Einstellungen:
    Details zu den Systemkapazitäten wie Thread-Anzahl und Unterstützung für verschiedene Befehlssatzerweiterungen.
    Einstellungen für das Sampling-Verfahren, einschließlich Parameter für Top-k, Temperatur und andere statistische Steuerungen.
  4. Laufzeit- und Leistungsmetriken
    Zeiten für verschiedene Phasen des Modellbetriebs, von der Ladezeit bis zur Ausführungszeit, sind aufgeführt.
    Das Modell ist auf die CUDA GPU geladen worden und nutzt deren Ressourcen.

Die Log-Ausgabe bietet einen Einblick in die Konfiguration und Leistung eines spezifischen maschinellen Lernmodells.

Fazit

Der Test des Mixtral-8x22B-Instruct-v0.1 Modells auf dem Jetson Orin 64 GB Developer Board liefert einige Erkenntnisse über die Machbarkeit und Leistung von Edge-Computing-Lösungen für KI-Aufgaben. Trotz der längeren Ladezeit zeigt das System eine gute Geschwindigkeit bei der Token-Generierung. Dies zeigt das Potential von integrierten Plattformen wie dem Jetson Orin, der gut für KI-Anwendungen in mobilen Umgebungen geeignet ist.https://www.youtube.com/watch?v=re–L8WM8dQ

Veröffentlicht in Allgemein