Nutzen einer Intel iGPU mit WSL2 zur Verarbeitung von KI-Workloads

Veröffentlicht am von
Tags: windows wsl iGPU intel ki künstliche intelligenz llm container virtualisierung podman linux ubuntu

cover-wsl-intel-gpu-ai

Hintergrund & Funktionsweise

Vielleicht haben Sie sich ebenfalls schon einmal die Frage gestellt, wie es möglich ist den oft in Notebooks verbauten integrierten Grafikprozessor (iGPU) von Intel für KI-Anwendungen zu nutzen. Unter Windows 111 in Verbindung mit WSL22 und dem Model-Server OpenVINO3 auf Basis der Container Management Umgebung Podman4 ist das relativ einfach umzusetzen. Dieser Artikel beschreibt die notwendigen Schritte, um schlussendlich eine Kommunikation mit einem Large Language Model zu ermöglichen. Anhand des Modells “DeepSeek-R1-Distill-Qwen-7B”5 wird gezeigt wie dies sicher lokal möglich ist. Nach Ausführung der gezeigten Schritte kann mit dem Modell per “Chat Completions” auf Basis der OpenAI-API6 kommuniziert werden.

Folgende Features werden unterstützt:

  • Sichere lokale Nutzung von Large Language Modellen (LLMs) innerhalb der WSL2-Umgebung
  • Lokaler Betrieb des OpenVINO Model-Servers auf Basis von Container Virtualisierung mit Podman
  • Nutzung der lokalen iGPU von Intel für Inference des Modells innerhalb des Containers
  • Lokale Prompts an das Modell “DeepSeek-R1-Distill-Qwen-7B”

Voraussetzungen

  1. Mindestens Windows 11 ist installiert
  2. WSL2 muss unter Windows 11 aktiviert sein
  3. → Eine WSL2-Linux-Distribution ist installiert
    • Die Schritte 1-3 sind bereits ausgeführt

Schritte

  1. Starten des installierten Subsystems

    - innerhalb der Windows Eingabeaufforderung -

    • Die Tastenkombination Windows-Taste + R-Taste betätigen
    • Im kleinen Fenster cmd eingeben und mit der Return-Taste bestätigen oder OK klicken
    • System starten 
      wsl -d mylinux
    • Hinweise:
      • Die Windows Eingabeaufforderung wechselt in das Terminal der Linux-Distribution
      • Der Distributionsname “mylinux” wurde innerhalb eines vorherigen Artikels festgelegt, siehe → 3. Voraussetzung

  2. Distribution aktualisieren

    - innerhalb des Terminals der Linux-Distribution -

    • APT-Repositories updaten und Pakete upgraden 
      sudo apt update && sudo apt upgrade -y

  3. Installieren der Intel GPU Treiber

    - innerhalb des Terminals der Linux-Distribution -

    • Key des APT-Repositories für Grafik-Treiber von Intel hinzufügen

      sudo wget -qO - https://repositories.intel.com/gpu/intel-graphics.key | sudo gpg --yes --dearmor --output /usr/share/keyrings/intel-graphics.gpg

    • APT-Repository hinzufügen

      sudo echo "deb [arch=amd64,i386 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/gpu/ubuntu noble unified" | sudo tee /etc/apt/sources.list.d/intel-gpu-noble.list

    • APT-Repositories updaten und Treiber installieren

      sudo apt update && sudo apt install -y libze-intel-gpu1 intel-opencl-icd clinfo

    • Optional: Benutzer zur Render-Gruppe hinzufügen

      - für den Fall, dass der aktuell angemeldete User NICHT “root” ist (check per “whoami”-Befehl) -

      sudo gpasswd -a ${USER} render

    • Überprüfen ob GPU korrekt erkannt wird

      clinfo | grep "Device Name"
      • Die resultierende Ausgabe sollte folgendermaßen aussehen 
        Device Name                                       Intel(R) Graphics [0x7d45]
    Device Name                                   Intel(R) Graphics [0x7d45]
    Device Name                                   Intel(R) Graphics [0x7d45]
    Device Name                                   Intel(R) Graphics [0x7d45]

  4. Vorbereiten des Modells

    - innerhalb des Terminals der Linux-Distribution -

    • Python Manager für virtuelle Umgebungen installieren 
      sudo apt install -y python3.12-venv
    • Virtuelle Python-Umgebung erzeugen 
      python3 -m venv ~/venv-optimum-cli
    • Virtuelle Python-Umgebung aktivieren 
      . ~/venv-optimum-cli/bin/activate
    • Installieren des Optimum CLI 
      python -m pip install  "optimum-intel[openvino]"@git+https://github.com/huggingface/optimum-intel.git@v1.22.0
    • Download des Modells und Durchführung der Quantisierung 
      optimum-cli export openvino --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B --weight-format int4 ~/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
    • Virtuelle Python-Umgebung deaktivieren 
      deactivate
    • Model-Repository Konfiguration anlegen 
      tee ~/models/config.json > /dev/null <<EOT
{
    "mediapipe_config_list": [
        {
            "name": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
            "base_path": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
        }
    ],
    "model_config_list": []
}
EOT
    • MediaPipe-Graph anlegen für HTTP-Inference 
      tee ~/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B/graph.pbtxt > /dev/null <<EOT
input_stream: "HTTP_REQUEST_PAYLOAD:input"
output_stream: "HTTP_RESPONSE_PAYLOAD:output"
node: {
    name: "LLMExecutor"
    calculator: "HttpLLMCalculator"
    input_stream: "LOOPBACK:loopback"
    input_stream: "HTTP_REQUEST_PAYLOAD:input"
    input_side_packet: "LLM_NODE_RESOURCES:llm"
    output_stream: "LOOPBACK:loopback"
    output_stream: "HTTP_RESPONSE_PAYLOAD:output"
    input_stream_info: {
        tag_index: 'LOOPBACK:0',
        back_edge: true
    }
    node_options: {
        [type.googleapis.com / mediapipe.LLMCalculatorOptions]: {
            models_path: "./",
            plugin_config: '{ }',
            enable_prefix_caching: false,
            cache_size: 2,
            max_num_seqs: 256,
            device: "GPU",
        }
    }
    input_stream_handler {
        input_stream_handler: "SyncSetInputStreamHandler",
        options {
            [mediapipe.SyncSetInputStreamHandlerOptions.ext] {
                sync_set {
                tag_index: "LOOPBACK:0"
                }
            }
        }
    }
}
EOT

  5. Installieren der Container Management Umgebung

    - innerhalb des Terminals der Linux-Distribution -

    • Podman installieren 
      sudo apt install -y podman

  6. Deployment des Modell Servers

    - innerhalb des Terminals der Linux-Distribution -

    • OpenVINO Image herunterladen und Container starten 
      podman run -d --name openvino-server --device /dev/dri/card0 --device /dev/dri/renderD128 --device /dev/dxg --group-add=$(stat -c "%g" /dev/dri/render*) --group-add=$(stat -c "%g" /dev/dxg) --rm -p 8000:8000 -v ~/models:/workspace:ro -v /usr/lib/wsl:/usr/lib/wsl docker.io/openvino/model_server:2025.0-gpu --rest_port 8000 --config_path /workspace/config.json

  7. Testen des Modell Servers

    - innerhalb des Terminals der Linux-Distribution -

    • Konfigurations-Endpunkt des OpenVINO Servers anfragen 
      curl http://localhost:8000/v1/config
      • Die Response des Requests sollte folgendermaßen aussehen: 
        {
"deepseek-ai/DeepSeek-R1-Distill-Qwen-7B": {
    "model_version_status": [
    {
        "version": "1",
        "state": "AVAILABLE",
        "status": {
        "error_code": "OK",
        "error_message": "OK"
        }
    }
    ]
}

  8. Mit dem Modell kommunizieren

    - innerhalb des Terminals der Linux-Distribution -

    • Einfaches Python-basiertes Chat-Tool für Demozwecke abspeichern 
      tee ~/ovchat.py > /dev/null <<EOT
import requests, json, readline

USER_COLOR, ASSISTANT_COLOR, RESET_COLOR = "\033[94m", "\033[92m", "\033[0m"
LOCAL_SERVER_URL = 'http://localhost:8000/v3/chat/completions'

def chat_with_local_server(messages):
    response = requests.post(LOCAL_SERVER_URL, json={"model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "messages": messages, "stream": True}, stream=True)
    if response.status_code == 200:
        for line in response.iter_lines():
            if line:
                try:
                    raw_data = line.decode('utf-8')
                    if raw_data.startswith("data: "):
                        raw_data = raw_data[6:]
                    if raw_data == '[DONE]':
                        break
                    json_data = json.loads(raw_data)
                    if 'choices' in json_data:
                        message_content = json_data['choices'][0]['delta'].get('content', '')
                        if message_content:
                            print(ASSISTANT_COLOR + message_content + RESET_COLOR, end='', flush=True)
                except json.JSONDecodeError as e:
                    print(f"JSON-Error: {e}")
                except Exception as e:
                    print(f"Exception: {e}")
    else:
        print(f"Fehler: {response.status_code} - {response.text}")

def main():
    messages = [{"role": "system", "content": "You're a helpful assistent."}]
    print("Type 'exit' quitting.")
    while True:
        user_input = input(USER_COLOR + "\nYou: " + RESET_COLOR)
        if user_input.lower() == 'exit':
            break
        messages.append({"role": "user", "content": user_input})
        print(ASSISTANT_COLOR + "Assistent: " + RESET_COLOR, end=' ')
        chat_with_local_server(messages)

if __name__ == "__main__":
    main()
EOT
    • Mit dem Modell chatten 
      python3 ~/ovchat.py

  9. GPU-Nutzung verifizieren

    - innerhalb der Windows Eingabeaufforderung -

    • Die Tastenkombination Windows-Taste + R-Taste betätigen
    • Im kleinen Fenster taskmgr eingeben und mit der Return-Taste bestätigen oder OK klicken
    • Auf den Reiter “Leistung” wechseln
      • Während der Kommunikation mit dem Modell sollte das Diagramm eine deutliche Auslastung der GPU zeigen: windows-host-gpu-utilization

Quellen

  1. ↗ https://www.microsoft.com/de-de/software-download/windows11  ↩︎

  2. ↗ https://learn.microsoft.com/en-us/windows/wsl/install  ↩︎

  3. ↗ https://docs.openvino.ai/2025/model-server/  ↩︎

  4. ↗ https://podman.io  ↩︎

  5. ↗ https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B  ↩︎

  6. ↗ https://platform.openai.com/docs/api-reference/chat  ↩︎

Siehe auch

  1. → USB-Audio unter WSL2 aktivieren
  2. → Linux mit einer Desktop-Umgebung unter Windows 11
Haftungsausschluss: Die Informationen in diesem Artikel sind als unverbindliche Hinweise zu verstehen.
Die Aktualität, inhaltliche Richtigkeit und Vollständigkeit kann nicht gewährleistet werden.

Die letzten 5

→ 
Nutzen einer Intel iGPU mit WSL2 zur Verarbeitung von KI-Workloads
→ 
USB-Audio unter WSL2 aktivieren
→ 
Linux mit einer Desktop-Umgebung unter Windows 11
→ 
ics2csv4win - Transformieren von iCalendar Ressourcen (ics) in zeichengetrennte Werte (csv)

Tags

audio batch container csv desktop exportieren ics igpu intel kernel ki kompilierung künstliche intelligenz linux llm podman remote transformieren ubuntu usb video virtualisierung windows wsl xfce xrdp