LeaderGPU® | GPU-Lösungen für High Performance Computing

Qwen3-Coder: Ein gebrochenes Paradigma

Tue, 12 Aug 2025 14:11:06 +0200

Wir sind daran gewöhnt, dass Open-Source-Modelle in ihrer Qualität immer hinter ihren kommerziellen Pendants zurückbleiben. Es mag den Anschein haben, dass sie ausschließlich von Enthusiasten entwickelt werden, die es sich nicht leisten können, große Summen in die Erstellung hochwertiger Datensätze und das Training von Modellen auf Zehntausenden moderner Grafikprozessoren zu investieren.

Anders sieht es aus, wenn sich große Unternehmen wie OpenAI, Anthropic oder Meta dieser Aufgabe annehmen. Sie verfügen nicht nur über die nötigen Ressourcen, sondern auch über die weltweit besten Spezialisten für neuronale Netze. Leider sind die von ihnen erstellten Modelle, insbesondere die neuesten Versionen, Closed-Source. Die Entwickler begründen dies mit den Risiken einer unkontrollierten Nutzung und mit der Notwendigkeit, die Sicherheit der KI zu gewährleisten.

Einerseits ist ihre Argumentation nachvollziehbar: Viele ethische Fragen sind nach wie vor ungelöst, und die Natur der Modelle neuronaler Netze erlaubt nur eine indirekte Einflussnahme auf das Endergebnis. Andererseits ist es auch ein solides Geschäftsmodell, die Modelle geschlossen zu halten und den Zugang nur über die eigene API anzubieten.

Allerdings verhalten sich nicht alle Unternehmen auf diese Weise. Das französische Unternehmen Mistral AI beispielsweise bietet sowohl kommerzielle als auch Open-Source-Modelle an, die von Forschern und Enthusiasten für ihre Projekte genutzt werden können. Besonderes Augenmerk sollte jedoch auf die Leistungen chinesischer Unternehmen gelegt werden, von denen die meisten Modelle mit offenem Gewicht und offenem Quellcode entwickeln, die mit proprietären Lösungen ernsthaft konkurrieren können.

DeepSeek, Qwen3 und Kimi K2

Der erste große Durchbruch gelang mit DeepSeek-V3. Dieses multimodale Sprachmodell von DeepSeek AI wurde unter Verwendung des Mixture of Experts (MoE)-Ansatzes entwickelt und umfasst beeindruckende 671B Parameter, von denen 37B für jedes Token aktiviert sind. Am wichtigsten ist, dass alle Komponenten (Modellgewichte, Inferenzcode und Trainingspipelines) offengelegt wurden.

Dies machte es sofort zu einem der attraktivsten LLMs für Entwickler von KI-Anwendungen und Forscher gleichermaßen. Der nächste Schlagzeilenmacher war DeepSeek-R1 - das erste quelloffene Reasoning-Modell. Am Tag seiner Veröffentlichung erschütterte es die US-Börse, nachdem seine Entwickler behauptet hatten, dass das Training eines so fortschrittlichen Modells nur 6 Millionen Dollar gekostet hatte.

Während sich der Hype um DeepSeek schließlich abkühlte, waren die nächsten Veröffentlichungen nicht weniger wichtig für die globale KI-Branche. Die Rede ist natürlich von Qwen 3. Wir haben die Funktionen in unserem Bericht über Was ist neu in Qwen 3 ausführlich beschrieben, so dass wir hier nicht weiter darauf eingehen wollen. Kurz darauf tauchte ein weiterer Spieler auf: Kimi K2 von Moonshot AI.

Mit seiner MoE-Architektur, 1T-Parametern (32B pro Token aktiviert) und Open-Source-Code zog Kimi K2 schnell die Aufmerksamkeit der Community auf sich. Moonshot AI konzentrierte sich nicht auf das logische Denken, sondern strebte nach Spitzenleistungen in Mathematik, Programmierung und tiefgreifendem interdisziplinärem Wissen.

Das Ass im Ärmel von Kimi K2 war seine Optimierung für die Integration in KI-Agenten. Dieses Netzwerk wurde im wahrsten Sinne des Wortes so konzipiert, dass es alle verfügbaren Werkzeuge voll ausschöpfen kann. Es eignet sich hervorragend für Aufgaben, die nicht nur das Schreiben von Code, sondern auch iterative Tests in jeder Entwicklungsphase erfordern. Allerdings hat es auch Schwächen, auf die wir später noch eingehen werden.

Kimi K2 ist in jeder Hinsicht ein großes Sprachmodell. Die Ausführung der Vollversion erfordert ~2 TB VRAM (FP8: ~1 TB). Aus offensichtlichen Gründen ist das nichts, was man zu Hause machen kann, und selbst viele GPU-Server werden das nicht schaffen. Das Modell benötigt mindestens 8 NVIDIA® H200 Beschleuniger. Quantisierte Versionen können Abhilfe schaffen, allerdings zu einem spürbaren Preis für die Genauigkeit.

Qwen3-Coder

Angesichts des Erfolgs von Moonshot AI hat Alibaba sein eigenes, Kimi K2-ähnliches Modell entwickelt, allerdings mit erheblichen Vorteilen, auf die wir gleich eingehen werden. Ursprünglich wurde es in zwei Versionen veröffentlicht:

Qwen3-Coder-480B-A35B-Instruct (~250 GB VRAM)
Qwen3-Coder-480B-A35B-Instruct-FP8 (~120 GB VRAM)

Einige Tage später erschienen kleinere Modelle ohne den Argumentationsmechanismus, die weit weniger VRAM benötigten:

Qwen3-Coder-30B-A3B-Instruct (~32 GB VRAM)
Qwen3-Coder-30B-A3B-Instruct-FP8 (~18 GB VRAM)

Qwen3-Coder wurde für die Integration mit Entwicklungswerkzeugen konzipiert. Es enthält einen speziellen Parser für Funktionsaufrufe (qwen3coder_tool_parser.py, analog zu OpenAIs Funktionsaufruf). Zusammen mit dem Modell wurde ein Konsolenprogramm veröffentlicht, das von der Codekompilierung bis zur Abfrage einer Wissensdatenbank reicht. Diese Idee ist nicht neu, im Wesentlichen handelt es sich um eine stark überarbeitete Erweiterung der Gemini-Code-App von Anthropic.

Das Modell ist mit der OpenAI-API kompatibel, so dass es lokal oder auf einem entfernten Server eingesetzt und mit den meisten Systemen, die diese API unterstützen, verbunden werden kann. Dazu gehören sowohl vorgefertigte Client-Anwendungen als auch Bibliotheken für maschinelles Lernen. Damit ist es nicht nur für das B2C-, sondern auch für das B2B-Segment geeignet und bietet einen nahtlosen Ersatz für das Produkt von OpenAI, ohne dass die Anwendungslogik geändert werden muss.

Eine der am meisten nachgefragten Funktionen ist die erweiterte Kontextlänge. Standardmäßig unterstützt es 256k Token, kann aber mit dem Mechanismus YaRN (Yet another RoPe extensioN) auf 1M erhöht werden. Moderne LLMs werden in der Regel auf kurzen Datensätzen (2k-8k Token) trainiert, und große Kontextlängen können dazu führen, dass sie den Überblick über frühere Inhalte verlieren.

YaRN ist ein eleganter "Trick", der dem Modell vorgaukelt, dass es mit seinen üblichen kurzen Sequenzen arbeitet, während es in Wirklichkeit viel längere Sequenzen verarbeitet. Die Schlüsselidee besteht darin, den Positionsraum zu "strecken" oder zu "dehnen", während die mathematische Struktur, die das Modell erwartet, erhalten bleibt. Dies ermöglicht die effektive Verarbeitung von Sequenzen mit einer Länge von Zehntausenden von Token, ohne dass eine Umschulung oder ein zusätzlicher Speicher erforderlich ist, wie es bei herkömmlichen Kontexterweiterungsmethoden der Fall ist.

Herunterladen und Ausführen der Inferenz

Vergewissern Sie sich, dass Sie zuvor CUDA® installiert haben. Verwenden Sie dazu entweder die offiziellen Anweisungen von NVIDIA® oder die Anleitung CUDA® Toolkit unter Linux installieren. Prüfen Sie, ob der erforderliche Compiler vorhanden ist:

nvcc --version

Erwartete Ausgabe:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Tue_Feb_27_16:19:38_PST_2024
Cuda compilation tools, release 12.4, V12.4.99
Build cuda_12.4.r12.4/compiler.33961263_0

Wenn Sie erhalten:

Command 'nvcc' not found, but can be installed with:
sudo apt install nvidia-cuda-toolkit

erhalten, müssen Sie die CUDA® Binärdateien zum $PATH Ihres Systems hinzufügen.

export PATH=/usr/local/cuda-12.4/bin:$PATH

export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH

Dies ist eine vorübergehende Lösung. Für eine dauerhafte Lösung editieren Sie ~/.bashrc und fügen Sie die gleichen zwei Zeilen am Ende hinzu.

Bereiten Sie nun Ihr System für die Verwaltung virtueller Umgebungen vor. Sie können Pythons eingebautes venv oder das fortschrittlichere Miniforge verwenden. Angenommen, Miniforge ist installiert:

conda create -n venv python=3.10

conda activate venv

Installieren Sie PyTorch mit CUDA® Unterstützung passend zu Ihrem System:

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124

Installieren Sie dann die wesentlichen Bibliotheken:

Transformers - Die Hauptmodellbibliothek von Hugging Face
Accelerate - ermöglicht Multi-GPU-Inferenz
HuggingFace Hub - zum Herunter-/Hochladen von Modellen und Datensätzen
Safetensors - sicheres Modellgewichtsformat
vLLM - empfohlene Inferenzbibliothek für Qwen

pip install transformers accelerate huggingface_hub safetensors vllm

Laden Sie das Modell herunter:

hf download Qwen/Qwen3-Coder-30B-A3B-Instruct --local-dir ./Qwen3-30B

Inferenz mit Tensor-Parallelität durchführen (Aufteilung der Schichttensoren auf GPUs, z. B. 8):

python -m vllm.entrypoints.openai.api_server \
--model /home/usergpu/Qwen3-30B \
--tensor-parallel-size 8 \
--gpu-memory-utilization 0.9 \
--dtype auto \
--host 0.0.0.0 \
--port 8000

Dadurch wird der vLLM OpenAI API Server gestartet.

Testen und Integration

cURL

Installieren Sie jq für das Pretty-Printing von JSON:

sudo apt -y install jq

Testen Sie den Server:

curl -s http://127.0.0.1:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "/home/usergpu/Qwen3-30B",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello! What can you do?"}
  ],
  "max_tokens": 180
}' | jq -r '.choices[0].message.content'

VSCode

Um Visual Studio Code zu integrieren, installieren Sie die Erweiterung Continue und fügen Sie sie zu config.yaml hinzu:

- name: Qwen3-Coder 30B
  provider: openai
  apiBase: http://[server_IP_address]:8000/v1
  apiKey: none
  model: /home/usergpu/Qwen3-30B
  roles:
    - chat
    - edit
    - apply

Qwen-Agent

Für eine GUI-basierte Einrichtung mit Qwen-Agent (einschließlich RAG, MCP und Code-Interpreter):

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"

Öffnen Sie den nano-Editor:

nano script.py

Beispiel Python-Skript zum Starten von Qwen-Agent mit einer Gradio WebUI:

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

llm_cfg = {
    'model': '/home/usergpu/Qwen3-30B',
    'model_server': 'http://localhost:8000/v1',
    'api_key': 'EMPTY',
    'generate_cfg': {'top_p': 0.8},
}

tools = ['code_interpreter']

bot = Assistant(
    llm=llm_cfg,
    system_message="You are a helpful coding assistant.",
    function_list=tools
)

WebUI(bot).run()

Führen Sie das Skript aus:

python script.py

Der Server wird verfügbar sein unter: http://127.0.0.1:7860

Sie können Qwen3-Coder auch in Agenten-Frameworks wie CrewAI integrieren, um komplexe Aufgaben mit Toolsets wie Websuche oder Vektordatenbank-Speicher zu automatisieren.

Siehe auch:

So installieren Sie CrewAI mit GUI

Wed, 23 Jul 2025 15:05:43 +0200

Die Fähigkeiten von Modellen neuronaler Netze werden täglich erweitert. Forscher und kommerzielle Unternehmen investieren mehr und mehr in ihre Ausbildung. Aber allein können diese Modelle nicht autonom handeln. Um bestimmte Aufgaben zu lösen, brauchen sie Anleitung: Kontexterweiterung und Richtungsvorgabe. Dieser Ansatz ist nicht immer effizient, insbesondere bei komplexen Problemen.

Was aber, wenn wir einem neuronalen Netz erlauben würden, autonom zu handeln? Und was wäre, wenn wir es mit vielen Werkzeugen ausstatten würden, um mit der Außenwelt zu interagieren? Man erhält einen KI-Agenten, der in der Lage ist, Aufgaben zu lösen, indem er selbständig entscheidet, welche Werkzeuge er verwendet. Klingt kompliziert, aber es funktioniert sehr gut. Doch selbst für einen fortgeschrittenen Benutzer kann die Erstellung eines KI-Agenten von Grund auf eine nicht triviale Aufgabe sein.

Der Grund dafür ist, dass den meisten gängigen Bibliotheken eine grafische Benutzeroberfläche fehlt. Sie erfordern die Interaktion über eine Programmiersprache wie Python. Dies erhöht die Einstiegshürde drastisch und macht KI-Agenten zu komplex für eine eigenständige Implementierung. Genau das ist bei CrewAI der Fall.

Was ist CrewAI?

CrewAI ist eine sehr beliebte und praktische Bibliothek, die jedoch standardmäßig nicht mit einer grafischen Benutzeroberfläche ausgestattet ist. Dies veranlasste unabhängige Entwickler, eine inoffizielle Schnittstelle zu schaffen. Der Open-Source-Charakter von CrewAI machte die Aufgabe viel einfacher, und bald veröffentlichte die Community das Projekt CrewAI Studio.

Entwickler und Enthusiasten erhielten einen tieferen Einblick in die Architektur des Systems und konnten Werkzeuge erstellen, die auf bestimmte Aufgaben zugeschnitten waren. Normale Benutzer konnten KI-Agenten erstellen, ohne eine einzige Zeile Code schreiben zu müssen. Es wurde einfacher, Aufgaben zuzuweisen und den Zugang zu neuronalen Netzen und Tools zu verwalten. Außerdem war es möglich, Agenten von Server zu Server zu exportieren und zu importieren und sie mit Freunden, Kollegen oder der Open-Source-Gemeinschaft zu teilen.

Ein weiterer Vorteil von CrewAI Studio ist seine Flexibilität bei der Bereitstellung. Es kann als normale App oder als Docker-Container installiert werden - die bevorzugte Methode, da sie alle notwendigen Bibliotheken und Komponenten für den Betrieb des Systems enthält.

Installation

Aktualisieren Sie Ihre Betriebssystem-Pakete und installierten Anwendungen auf die neuesten Versionen:

sudo apt update && sudo apt -y upgrade

Verwenden Sie das Skript zur automatischen Treiberinstallation oder folgen Sie unserer Anleitung Installieren Sie Nvidia-Treiber unter Linux:

sudo ubuntu-drivers autoinstall

Starten Sie den Server neu, damit die Änderungen wirksam werden:

sudo shutdown - r now

Installieren Sie nach der erneuten Verbindung über SSH die Apache 2-Webserver-Dienstprogramme, mit denen Sie Zugriff auf den .htpasswd -Dateigenerator erhalten, der für die grundlegende Benutzerauthentifizierung verwendet wird:

sudo apt install -y apache2-utils

Installieren Sie die Docker-Engine mit dem offiziellen Shell-Skript:

curl -sSL https://get.docker.com/ | sh

Fügen Sie Docker Compose zum System hinzu:

sudo apt install -y docker-compose

Klonen Sie das Repository:

git clone https://github.com/strnad/CrewAI-Studio.git

Navigieren Sie zu dem heruntergeladenen Verzeichnis:

cd CrewAI-Studio

Erstellen Sie eine Datei .htpasswd für den Benutzer usergpu. Sie werden zweimal aufgefordert, ein Passwort einzugeben:

htpasswd -c .htpasswd usergpu

Bearbeiten Sie nun die Container-Bereitstellungsdatei. Standardmäßig gibt es zwei Container:

sudo nano docker-compose.yaml

Löschen Sie den Abschnitt:

ports:
  - "5432:5432"

Und fügen Sie den folgenden Dienst hinzu:


nginx:
  image: nginx:latest
  container_name: crewai_nginx
  ports:
    - "80:80"
  volumes:
    - ./nginx.conf:/etc/nginx/nginx.conf:ro
    - ./.htpasswd:/etc/nginx/.htpasswd:ro
  depends_on:
    - web

Nginx benötigt eine Konfigurationsdatei, erstellen Sie also eine:

sudo nano nginx.conf

Fügen Sie das Folgende ein:

events {}

http {
  server {
    listen 80;

    location / {
      proxy_pass http://web:8501;

      # WebSocket headers
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      # Forward headers
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;

      auth_basic "Restricted Content";
      auth_basic_user_file /etc/nginx/.htpasswd;
    }
  }
}

Alle wichtigen Dienstvariablen für CrewAI sind in der Datei .env definiert. Öffnen Sie die Datei .env_example zur Bearbeitung:

nano .env_example

Fügen Sie die folgenden Zeilen ein:

OLLAMA_HOST="http://open-webui:11434"
OLLAMA_MODELS="ollama/llama3.2:latest"

Und fügen Sie Postgres config hinzu:

POSTGRES_USER="admin"
POSTGRES_PASSWORD="your_password"
POSTGRES_DB="crewai_db"
AGENTOPS_ENABLED="False"

Kopieren Sie nun die Beispieldatei und benennen Sie sie in .env um, damit das System sie während der Containerbereitstellung lesen kann:

cp .env_example .env

In diesem Beispiel werden wir lokale Modelle verwenden, wobei die Inferenz von Ollama durchgeführt wird. Wir empfehlen unseren Leitfaden Open WebUI: Alles in einem, und fügen Sie während des Deployments -e OLLAMA_HOST=0.0.0.0 hinzu, damit sich CrewAI direkt mit dem Ollama-Container verbinden kann. Laden Sie das gewünschte Modell (z. B. llama3.2:latest) über die WebUI oder durch Verbinden mit der Containerkonsole und Ausführen herunter:

ollama pull llama3.2:latest

Sobald alles eingerichtet ist, starten Sie das Deployment:

sudo docker-compose up -d --build

Wenn Sie http://[your_server_ip]/ besuchen, werden Sie zur Eingabe Ihrer Anmeldedaten aufgefordert. Nach korrekter Eingabe erscheint die CrewAI-Oberfläche.

Funktionen

Schauen wir uns die wichtigsten Funktionen von CrewAI an. Dies wird Ihnen helfen zu verstehen, wie Sie Arbeitsabläufe konfigurieren können. Die zentrale Entität in der Agent, ein autonomer Aufgabenausführer. Jeder Agent hat Attribute, die ihm helfen, seine Aufgaben zu erfüllen:

Role. Eine kurze, 2-3 Worte umfassende Aufgabenbeschreibung.
Backstory. Optional; hilft dem Sprachmodell zu verstehen, wie sich der Agent verhalten soll und auf welche Erfahrungen er sich stützen kann.
Goal. Das Ziel, das der Agent verfolgen soll.
Allow delegation. Ermöglicht es dem Agenten, Aufgaben (oder Teile davon) an andere zu delegieren.
Verbose. Weist den Agenten an, detaillierte Aktionen zu protokollieren.
LLM Provider and Model. Legt das zu verwendende Modell und den Anbieter fest.
Temperature. Bestimmt die Kreativität der Antwort. Höher = kreativer.
Max iterations. Anzahl der Versuche, die der Agent hat, um erfolgreich zu sein; dient als Schutz (z. B. gegen Endlosschleifen).

Agenten arbeiten, indem sie iterativ Eingaben analysieren, Schlussfolgerungen ziehen und die verfügbaren Werkzeuge nutzen.

Die Eingabe wird durch eine Task Entität definiert. Jede Aufgabe enthält eine Beschreibung, einen zugewiesenen Agenten und optional ein erwartetes Ergebnis. Die Aufgaben werden standardmäßig sequentiell ausgeführt, können aber mit dem Flag Async execution parallelisiert werden.

Die autonome Arbeit der Agenten wird durch Tools unterstützt, das die Interaktion mit der realen Welt ermöglicht. CrewAI enthält Werkzeuge für die Websuche, das Parsen von Websites, API-Aufrufe und die Handhabung von Dateien, die den Kontext verbessern und den Agenten helfen, ihre Ziele zu erreichen.

Schließlich gibt es noch Crew entity. Es vereint Agenten mit unterschiedlichen Rollen in einem Team, um komplexe Probleme zu lösen. Sie können miteinander kommunizieren, delegieren, überprüfen und korrigieren und bilden so eine kollektive Intelligenz.

Verwendung von

Nachdem Sie nun mit den Entitäten vertraut sind, lassen Sie uns einen minimalen CrewAI-Workflow erstellen und ausführen. In diesem Beispiel werden wir den globalen Fortschritt bei der Entwicklung von Krebsmedikamenten verfolgen.

Wir werden drei Agenten verwenden:

Oncology Drug Pipeline Analyst - verfolgt neue Entwicklungen von der Frühphase bis zur klinischen Erprobung.
Regulatory and Approval Watchdog - überwacht neue Arzneimittelzulassungen und regulatorische Änderungen.
Scientific Literature and Innovation Scout - scannt wissenschaftliche Veröffentlichungen und Patente im Bereich der Onkologie.

Öffnen Sie den Bereich Wirkstoffe und erstellen Sie den ersten Wirkstoff:

Im Moment verwenden wir das zuvor heruntergeladene Modell llama3.2:latest, aber in einem realen Szenario sollten Sie das Modell wählen, das am besten zur Aufgabe passt. Wiederholen Sie den Vorgang für die übrigen Agenten und fahren Sie mit der Aufgabenerstellung fort.

Versammeln Sie alle Agenten zu einem Team und weisen Sie ihnen die vorbereitete Aufgabe zu:

Aktivieren Sie die erforderlichen Werkzeuge aus der Liste:

Gehen Sie schließlich auf die Seite Kickoff! und klicken Sie auf Run Crew!. Nach einigen Iterationen wird das System ein Ergebnis zurückgeben, z. B:

Bevor wir fertig sind, sehen wir uns noch den Bereich Import/export an. Ihr Workflow oder Ihre Crew kann als JSON exportiert werden, um sie auf einen anderen CrewAI Server zu übertragen. Sie können auch eine Single-Page-Anwendung (SPA) mit einem einzigen Klick erstellen - perfekt für den Produktionseinsatz:

Fazit

CrewAI vereinfacht die Erstellung von KI-Agenten erheblich und ermöglicht die Integration in jede Anwendung oder die eigenständige Nutzung. Die Bibliothek basiert auf der Idee der verteilten Intelligenz, bei der jeder Agent ein Domänenexperte ist und das kombinierte Team einen einzelnen Generalisten-Agenten übertrifft.

Da sie in Python geschrieben ist, lässt sich CrewAI leicht in ML-Plattformen und -Tools integrieren. Seine Open-Source-Natur ermöglicht die Erweiterung durch Module von Drittanbietern. Die Kommunikation zwischen den Agenten reduziert die Verwendung von Token durch die Verteilung der Kontextverarbeitung.

Dadurch können komplexe Aufgaben schneller und effizienter erledigt werden. Die niedrigere Einstiegshürde, die CrewAI Studio bietet, vergrößert die Reichweite von KI-Agenten und Multi-Agenten-Systemen. Und die Unterstützung lokaler Modelle gewährleistet eine bessere Kontrolle über sensible Daten.

Siehe auch:

Was ist neu in Qwen 3

Mon, 14 Jul 2025 08:05:08 +0200

Der globale KI-Wettlauf wird immer schneller. Forschungseinrichtungen, Privatunternehmen und sogar ganze Nationen konkurrieren jetzt um die Führung im Bereich der KI. Im Großen und Ganzen lässt sich dieser Wettlauf in mehrere Phasen unterteilen. In der ersten Phase ging es um die Entwicklung von KI im engeren Sinne. Bestehende neuronale Netzwerkmodelle wie GPT, MidJourney und AlphaFold zeigen, dass diese Phase erfolgreich abgeschlossen wurde.

Der nächste Schritt sieht die Entwicklung von KI zu AGI (Artificial General Intelligence) vor. AGI sollte der menschlichen Intelligenz bei der Lösung eines breiten Spektrums von Aufgaben ebenbürtig sein, vom Schreiben von Geschichten über wissenschaftliche Berechnungen bis hin zum Verstehen sozialer Situationen und selbstständigem Lernen. Zum Zeitpunkt der Erstellung dieses Artikels ist diese Stufe noch nicht erreicht.

Die letzte Stufe der KI-Entwicklung wird als ASI (Artificial Super Intelligence) bezeichnet. Sie würde die menschlichen Fähigkeiten in allen Bereichen weit übertreffen. Damit wäre es möglich, Technologien zu entwickeln, die wir uns heute noch nicht einmal vorstellen können, und globale Systeme mit einer Präzision zu steuern, die menschliche Fähigkeiten übersteigt. Dies könnte jedoch erst nach Jahrzehnten (oder sogar Jahrhunderten) kontinuierlicher Weiterentwicklung Realität werden.

Daher konzentrieren sich die meisten Teilnehmer des KI-Wettlaufs darauf, die AGI zu erreichen und gleichzeitig die Kontrolle über sie zu behalten. Die Entwicklung von AGI ist eng mit einer Vielzahl komplexer technischer, ethischer und rechtlicher Herausforderungen verbunden. Dennoch überwiegen die potenziellen Vorteile bei weitem die Kosten, weshalb Unternehmen wie die Alibaba Group stark in diesen Bereich investieren.

Die Veröffentlichung von Qwen 3 stellt nicht nur für die neuronalen Netze eines Unternehmens, sondern auch auf globaler Ebene einen wichtigen Meilenstein dar. Im Vergleich zu seinem Vorgänger führt das Modell mehrere wichtige Neuerungen ein.

Merkmale

Qwen 2.5 wurde mit einem Datensatz von 18 Milliarden Token trainiert, während das neue Modell diese Menge auf 36 Milliarden Token verdoppelt hat. Der größere Datensatz hat die Genauigkeit des Basismodells erheblich verbessert. Interessanterweise wurde das System zusätzlich zu den öffentlich zugänglichen Internetdaten, die durch Parsing gesammelt wurden, auch auf PDF-Dokumenten trainiert. Diese sind in der Regel gut strukturiert und weisen eine hohe Wissensdichte auf, was dem Modell hilft, genauere Antworten zu geben und komplexe Formulierungen besser zu verstehen.

Eine der vielversprechendsten Richtungen in der KI-Entwicklung ist die Entwicklung von Modellen, die zu Schlussfolgerungen fähig sind und den Aufgabenkontext in einem iterativen Prozess erweitern können. Auf der einen Seite ermöglicht dies eine umfassendere Problemlösung, auf der anderen Seite verlangsamt das schlussfolgernde Denken den Prozess aber auch erheblich. Deshalb haben die Entwickler von Qwen 3 zwei Betriebsmodi eingeführt:

Thinking mode. Das Modell baut den Kontext schrittweise auf, bevor es eine endgültige Antwort liefert. Dies ermöglicht es, komplexe Probleme zu lösen, die ein tiefes Verständnis erfordern.
Non-thinking mode. Das Modell reagiert fast sofort, kann aber auch oberflächliche Antworten ohne tiefgreifende Analyse liefern.

Diese manuelle Kontrolle über das Verhalten des Modells verbessert die Benutzererfahrung bei der Bewältigung vieler Routineaufgaben. Die Verringerung der Verwendung des Denkmodus senkt auch die GPU-Belastung erheblich, so dass mehr Token im gleichen Zeitrahmen verarbeitet werden können.

Zusätzlich zu dieser binären Auswahl gibt es auch einen Soft-Switching-Mechanismus. Dieses hybride Verhalten ermöglicht es dem Modell, sich mithilfe interner Gewichtungsmechanismen an den Kontext anzupassen. Wenn das Modell eine Aufgabe als schwierig einstuft, löst es automatisch Überlegungen oder sogar eine Selbstüberprüfung aus. Es kann auch auf Benutzerhinweise reagieren, wie z. B. "Denken wir Schritt für Schritt".

Eine weitere wichtige Verbesserung ist die erweiterte Unterstützung von Mehrsprachigkeit. Während Qwen 2.5 nur 29 Sprachen unterstützte, kann die Version 3 nun Text in 119 Sprachen und Dialekten verstehen und erzeugen. Dies hat das Verfolgen von Anweisungen und das Verständnis von Zusammenhängen erheblich verbessert. Dadurch kann Qwen 3 nun auch in nicht-englischen Umgebungen effektiv eingesetzt werden.

Darüber hinaus ist Qwen 3 jetzt wesentlich besser mit MCP-Servern integriert, was dem Modell die Möglichkeit gibt, tiefer in Problemlösungen einzutauchen und Aktionen auszuführen. Es kann nun mit externen Quellen interagieren und komplexe Prozesse direkt verwalten.

Modell-Schulung

Vorschulung

Ein solch großer Fortschritt wäre ohne ein mehrstufiges Trainingssystem nicht möglich gewesen. Zunächst wurde das Modell mit 30B Token und einer Kontextlänge von 4K trainiert, damit es allgemeines Wissen und grundlegende Sprachkenntnisse erwerben konnte.

Danach folgte eine Verfeinerungsphase mit wissenschaftlicheren und besser strukturierten Daten. In dieser Phase erlangte das Modell auch die Fähigkeit, Anwendungen in mehreren Programmiersprachen effektiv zu schreiben.

Schließlich wurde es auf einem hochwertigen Datensatz mit erweitertem Kontext trainiert. Als Ergebnis unterstützt Qwen 3 jetzt eine effektive Kontextlänge von 128K Token, was je nach Sprache etwa 350 Seiten getippten Textes entspricht. Kyrillisch basierte Sprachen haben beispielsweise aufgrund der Morphologie und der Verwendung von Präfixen, Suffixen usw. oft kürzere Token.

Reasoning-Pipeline

Die Entwicklung von schlussfolgernden Modellen ist ein faszinierender, aber arbeitsintensiver Prozess, der verschiedene bestehende Techniken zur Simulation des menschlichen Denkens kombiniert. Ausgehend von den öffentlich zugänglichen Informationen können wir davon ausgehen, dass das Argumentationstraining von Qwen 3 vier Hauptphasen umfasste:

Cold start for long chains of thought. Das Modell wird darauf trainiert, Probleme ohne vorherige Anpassung in mehrere Schritte zu zerlegen. Auf diese Weise lernt es iteratives Denken und entwickelt eine grundlegende Ebene von Denkfähigkeiten.
Reinforcement learning based on reasoning. In dieser Phase hängt die Belohnung nicht nur von der endgültigen Antwort ab, sondern auch davon, wie gut das Modell logische, interpretierbare und strukturierte Argumentationsketten konstruiert. Auch das Ausbleiben von Fehlern und Halluzinationen wird bewertet.
Merging reasoning modes. Der Mensch arbeitet in der Regel mit zwei Denkstilen: schnell (intuitiv) und langsam (analytisch). Je nach Art der Aufgabe sollte das neuronale Modell lernen, zwischen diesen beiden Stilen zu wechseln und sie zu integrieren. Dies geschieht in der Regel anhand von Beispielen, die beide Stile kombinieren, oder durch spezielle Token, die angeben, welcher Stil anzuwenden ist.
General reinforcement learning. Diese letzte Phase ähnelt einer Sandkastenumgebung, in der das Modell lernt, mit Werkzeugen zu interagieren, mehrstufige Aufgaben auszuführen und adaptives Verhalten zu entwickeln. Hier wird es auch auf die Benutzerpräferenzen eingestellt.

Fazit

Qwen 3 ist ein wichtiger Meilenstein für die Alibaba Group. Seine Trainingsqualität und -methodik machen es zu einem ernsthaften Konkurrenten für etablierte Anbieter wie OpenAI und Anthropic. Die Verbesserungen gegenüber der Vorgängerversion sind beträchtlich.

Ein zusätzlicher Vorteil ist der Open-Source-Charakter: Die Codebasis ist auf GitHub unter der Apache-2.0-Lizenz öffentlich zugänglich.

Die Weiterentwicklung der Qwen-Modellfamilie wird dazu beitragen, ihre Position in der globalen KI-Arena zu stärken und die Lücke zu kommerziellen Closed-Source-Modellen zu schließen. Und alle aktuellen Errungenschaften sind auf die eine oder andere Weise ein Schritt in Richtung Fortschritt der Menschheit bei der Entwicklung von AGI.

Siehe auch:

MCP-Server auf der Grundlage von N8N

Wed, 02 Jul 2025 15:28:18 +0200

Die Entwicklung von generativen neuronalen Netzen hat sich in den letzten Jahren erheblich beschleunigt. Sie sind merklich schneller und genauer in ihren Antworten geworden und haben gelernt, logisch zu denken. Ihre Fähigkeiten sind jedoch nach wie vor grundsätzlich durch ihre Architektur begrenzt. Zum Beispiel hat jedes bestehende LLM zum Zeitpunkt der Abfassung dieses Artikels ein Wissensstoppdatum. Das bedeutet, dass mit jedem Tag, der verstreicht, die Wahrscheinlichkeit steigt, dass ein solches LLM falsche Antworten liefert, einfach weil ihm Informationen über Ereignisse fehlen, die nach diesem Datum eingetreten sind.

Diese Einschränkung macht es erforderlich, das Modell anhand neuerer Daten komplett neu zu trainieren, was teuer und zeitaufwändig ist. Es gibt jedoch eine andere Möglichkeit. Wenn Sie das Modell in die Lage versetzen, mit der Außenwelt zu interagieren, kann es die während einer Benutzerunterhaltung angeforderten Informationen selbständig finden und aktualisieren, ohne dass ein erneutes Training erforderlich ist.

So ungefähr funktioniert der RAG-Mechanismus (Retrieval Augmented Generation). Bei der Beantwortung einer Frage fragt das Modell zunächst eine vorbereitete Vektordatenbank ab, und wenn es relevante Informationen findet, fügt es diese in die Eingabeaufforderung ein. Durch die Erläuterung und Aktualisierung der Vektor-Datenbank kann die Qualität der LLM-Antworten also erheblich verbessert werden.

Es gibt aber noch eine andere, noch interessantere Möglichkeit, aktuellen Kontext in die Prompts einzubauen. Sie heißt MCP, was für Model Context Protocol steht. Es wurde ursprünglich von Anthropic für sein Claude-Modell entwickelt. Der Schlüsselmoment war, als der Quellcode für MCP als Open Source zur Verfügung gestellt wurde, was es Tausenden von KI-Forschern ermöglichte, benutzerdefinierte Server für verschiedene Zwecke zu erstellen.

Das Wesen von MCP besteht darin, einem neuronalen Netzmodell Zugang zu Werkzeugen zu verschaffen, mit denen es selbstständig sein Wissen aktualisieren und verschiedene Aktionen durchführen kann, um gegebene Aufgaben effizient zu lösen. Das Modell entscheidet selbst, welches Werkzeug es verwendet und ob es in der jeweiligen Situation angemessen ist.

Die Unterstützung für MCP tauchte bald in verschiedenen IDEs wie Cursor sowie in Automatisierungsplattformen wie N8N auf. Letztere ist besonders intuitiv, da Workflows visuell erstellt werden, was sie leichter verständlich macht. Innerhalb von N8N können Sie entweder eine Verbindung zu einem bestehenden MCP-Server herstellen oder einen eigenen erstellen. Darüber hinaus können Sie sogar eine direkte Verbindung innerhalb eines einzigen Workflows organisieren. Aber gehen wir Schritt für Schritt vor.

Erstellen eines einfachen KI-Agenten

Bevor Sie beginnen, stellen Sie sicher, dass die wichtigste Voraussetzung erfüllt ist: Sie haben ein LLM, das für Verbindungen bereit ist. Dies kann ein lokal laufendes Modell mit Ollama oder ein externer Dienst wie ChatGPT von OpenAI sein. Im ersten Fall müssen Sie die lokale Ollama-API-Adresse (und optional deren Authentifizierung) kennen, und im zweiten Fall benötigen Sie ein aktives OpenAI-Konto mit ausreichend Guthaben.

Der Aufbau eines Agenten beginnt mit dem Schlüsselknoten AI Agent. Er muss mindestens mit zwei anderen Knoten verbunden sein, von denen einer als Auslöser fungiert und der andere eine Verbindung zum LLM herstellt. Wenn Sie keinen Auslöser angeben, wird das System automatisch einen erstellen und den Agenten bei Erhalt einer Nachricht im internen Chat auslösen:

Das einzige fehlende Element ist das LLM. Sie können zum Beispiel unser Open WebUI: Alles in einem guide verwenden, um Ollama mit einer Weboberfläche einzurichten. Die einzige erforderliche Änderung ist, dass sich die Container für N8N und Open WebUI im selben Netzwerk befinden müssen. Wenn sich der N8N-Container beispielsweise in einem Netzwerk mit dem Namen web befindet, dann ersetzen Sie im Bereitstellungsbefehl für Open WebUI --network=host durch --network=web.

In einigen Fällen müssen Sie auch die Umgebungsvariable OLLAMA_HOST manuell setzen, z. B. -e OLLAMA_HOST=0.0.0.0. Dies ermöglicht Verbindungen zur Ollama-API nicht nur von localhost, sondern auch von anderen Containern aus. Angenommen, Ollama wird in einem Container namens ollama-webui bereitgestellt. Dann wäre die Basis-URL für eine Verbindung von N8N aus wie folgt:

http://open-webui:11434

Bevor Sie den Ollama Chat Model Knoten verbinden, vergessen Sie nicht, mindestens ein Modell herunterzuladen. Sie können dies entweder über die Weboberfläche oder über die Container-CLI tun. Mit dem folgenden Befehl wird das Llama 3.1-Modell mit 8 Milliarden Parametern heruntergeladen:

ollama pull llama3.1:8b

Sobald das Modell heruntergeladen und installiert ist, wird es automatisch in der Liste der verfügbaren Modelle angezeigt:

Ein minimaler Arbeitsablauf für einen KI-Agenten sieht wie folgt aus:

In dieser Form kann der Agent nur ein Modell verwenden und speichert keine Eingabedaten oder verbessert Eingabeaufforderungen mithilfe externer Tools. Daher ist es sinnvoll, zumindest den Knoten Simple Memory hinzuzufügen. Für leichte Lasten reicht es aus, Anfragen und Antworten zu speichern.

Aber zurück zu MCP. Erstellen Sie zunächst einen Server unter Verwendung des speziellen Knotens MCP Server Trigger:

Dieser Knoten ist völlig eigenständig und muss nicht von außen aktiviert werden. Er wird ausschließlich durch eine eingehende externe Anfrage an seine Webhook-Adresse ausgelöst. Standardmäßig gibt es zwei URLs: Test URL und Production URL. Die erste wird während der Entwicklung verwendet, während die zweite nur funktioniert, wenn der Workflow gespeichert und aktiviert wird.

Der Auslöser ist für sich allein nutzlos, er benötigt angeschlossene Tools. Schließen wir zum Beispiel eines der einfachsten Werkzeuge an: einen Taschenrechner. Er erwartet einen mathematischen Ausdruck als Eingabe. Die Knoten kommunizieren über einfaches JSON. Damit der Taschenrechner 2 + 2 berechnen kann, muss die Eingabe also lauten:

[
  {
    "query": {
      "input": "2 + 2"
    }
  }
]

LLMs können solche JSON leicht aus reinen Textaufgabenbeschreibungen generieren und sie an den Knoten senden, der die Berechnungen durchführt und das Ergebnis zurückgibt. Verbinden wir nun den MCP-Client mit dem Agenten:

Es ist erwähnenswert, dass dieser Knoten keine zusätzlichen Verbindungen benötigt. In seinen Einstellungen muss lediglich die Endpunktadresse angegeben werden, an die er Daten vom KI-Agenten senden wird. In unserem Beispiel verweist diese Adresse auf den Container namens n8n.

Natürlich können Sie an dieser Stelle jede beliebige externe MCP-Serveradresse angeben, die Ihnen zur Verfügung steht. Für diesen Artikel verwenden wir jedoch eine lokale Instanz, die innerhalb von N8N läuft. Schauen wir uns an, wie sich der Client und der Server verhalten, wenn der KI-Agent aufgefordert wird, eine einfache Rechenoperation auszuführen:

Nach Erhalt der Anfrage wird der KI-Agent:

Suche im einfachen Speicher, um zu sehen, ob der Benutzer diese Frage schon einmal gestellt hat oder ob irgendein Kontext wiederverwendet werden kann.
Er sendet die Aufforderung an den LLM, der den mathematischen Ausdruck korrekt aufschlüsselt und das entsprechende JSON vorbereitet.
Senden Sie das JSON an das Tool Calculator und erhalten Sie das Ergebnis.
Verwenden Sie den LLM, um die endgültige Antwort zu generieren und das Ergebnis in die Antwort einzufügen.
Speichern Sie das Ergebnis im Simple Memory.
Geben Sie die Nachricht im Chat aus.

Auf ähnliche Weise können Agenten mit anderen Tools auf dem MCP-Server arbeiten. Anstelle von Simple Memory können Sie auch fortschrittlichere Optionen wie MongoDB, Postgres, Redis oder sogar etwas wie Zep verwenden. Diese erfordern natürlich eine minimale Datenbankwartung, aber die Gesamtleistung wird erheblich gesteigert.

Auch bei der Auswahl der Tools gibt es weitaus mehr Möglichkeiten. Der Knoten MCP Server Trigger unterstützt von Haus aus über 200 Tools. Dabei kann es sich um alles Mögliche handeln, von einfachen HTTP-Anfragen bis hin zu vorgefertigten Integrationen mit öffentlichen Internetdiensten. Innerhalb eines einzigen Workflows können Sie sowohl einen Server als auch einen Client erstellen. Ein wichtiger Hinweis: Diese Knoten können im Editor nicht visuell verbunden werden, und das ist das erwartete Verhalten:

Anstelle des Standardauslösers können Sie auch andere Optionen verwenden, z. B. den Empfang einer Nachricht über einen Messenger, die Übermittlung eines Website-Formulars oder die Ausführung nach einem Zeitplan. So können Sie Workflows einrichten, die auf Ereignisse reagieren oder Routinevorgänge wie den täglichen Datenexport aus Google Ads durchführen.

Und das ist noch nicht alles, was mit KI-Agenten möglich ist. Sie können Multi-Agenten-Systeme mit verschiedenen neuronalen Netzwerkmodellen erstellen, die zusammenarbeiten, um Aufgaben mit größerer Genauigkeit zu lösen und dabei viele weitere Einflussfaktoren zu berücksichtigen.

Siehe auch:

Wie wird N8N installiert?

Mon, 23 Jun 2025 14:30:26 +0200

KI-Agenten sind im Jahr 2025 nach wie vor einer der vielversprechendsten Ansätze für die Lösung komplexer Aufgaben unter Verwendung großer Sprachmodelle. Diese Agenten sind autonom und in der Lage, selbständig verschiedene Werkzeuge auszuwählen, um die ihnen zugewiesenen Aufgaben zu erfüllen. Mit diesem Ansatz lassen sich Ergebnisse mit weniger menschlicher Beteiligung und höherer Qualität erzielen. Er eröffnet auch die Möglichkeit, originellere und effizientere Wege zur Lösung von Problemen zu finden.

Anstatt nur eine Aufgabe zu formulieren, weisen Sie das neuronale Netz an, sie auf der Grundlage der ihm zugewiesenen Ressourcen selbständig zu lösen. Damit dieses System funktioniert, muss es jedoch einen Mechanismus geben, der die Schnittstellen des neuronalen Netzes mit verschiedenen Werkzeugen verbindet, sei es eine Websuche oder eine Vektordatenbank zur Speicherung von Zwischenergebnissen.

n8n ist eine Automatisierungsplattform, die die Integration mit verschiedenen neuronalen Netzen und öffentlichen Diensten unterstützt. Die Benutzer können visuell entwerfen, wie die Daten verarbeitet werden und welches Endergebnis erzielt werden soll. Im Gegensatz zu klassischen No-Code-Lösungen kann bei n8n in jeder Phase des Prozesses beliebiger Code eingefügt werden, was besonders dann nützlich ist, wenn die integrierten Funktionen nicht ausreichen.

Das Ergebnis ist ein System, das die Einfachheit von No-Code mit der Flexibilität der traditionellen Programmierung verbindet. Um es vollständig zu verstehen, müssen Sie jedoch einige Zeit damit verbringen, Workflow-Beispiele zu erforschen und zu überprüfen, um es besser zu verstehen. In diesem Artikel zeigen wir Ihnen, wie Sie n8n auf LeaderGPU-Servern einsetzen können.

Vorbereiten des Servers

Aktualisieren des Systems

Aktualisieren Sie die Paketliste und aktualisieren Sie alle installierten Pakete:

sudo apt update && sudo apt -y upgrade

Installieren Sie automatisch den empfohlenen NVIDIA®-Treiber (proprietär) oder verwenden Sie unsere Schritt-für-Schritt-Anleitung Installieren Sie Nvidia-Treiber unter Linux:

sudo ubuntu-drivers autoinstall

Starten Sie nun den Server neu:

sudo shutdown -r now

Docker installieren

Sie können das offizielle Installationsskript verwenden:

curl -sSL https://get.docker.com/ | sh

Fügen wir den NVIDIA® Container Toolkit GPG-Schlüssel und das Repository für die Docker-Integration hinzu:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aktualisieren Sie die Paketliste und installieren Sie das NVIDIA®-Container-Toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Starten Sie Docker neu, um die Änderungen zu übernehmen und das installierte Toolkit zu aktivieren:

sudo systemctl restart docker

n8n installieren

Damit das System Daten speichern kann, müssen Sie ein Volume erstellen, bevor Sie den Container starten:

sudo docker volume create n8n_data

Starten wir nun einen Container, der den Port 5678 für externe Verbindungen öffnet und das erstellte Volume n8n_data in das Verzeichnis /home/node/.n8n innerhalb des Containers mounten wird:

sudo docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Wenn Sie die Anwendung zum ersten Mal starten, werden Sie vielleicht durch die folgende Fehlermeldung verwirrt sein:

Dabei handelt es sich nicht um einen Fehler, sondern eher um eine Warnung, wie Sie das System für den Zugriff richtig konfigurieren müssen. Das Problem ist, dass das System standardmäßig kein TLS/HTTPS-Zertifikat hat. Ohne dieses ist die Verbindung nicht sicher. Sie haben also drei Möglichkeiten:

Connect your own certificate. Sie können dies tun, indem Sie die Pfade zu den Zertifikatsdateien über Umgebungsvariablen angeben oder einen Reverse-Proxy-Server konfigurieren.
Create an SSH tunnel and forward port 5678 auf localhost auf dem Computer, von dem aus Sie sich verbinden. Auf diese Weise erhalten Sie sofort eine sichere persönliche Verbindung. Allerdings kann niemand sonst von außen auf den Server zugreifen.
Bypass the warning. Wenn es sich um einen Testserver handelt, der nicht für den produktiven Einsatz gedacht ist, und Sie sich nicht um die Sicherheit kümmern, können Sie die Warnung deaktivieren, indem Sie die Umgebungsvariable N8N_SECURE_COOKIE auf FALSE setzen. Dennoch kann dies in bestimmten Szenarien akzeptabel sein.

In diesem Artikel werden die einzelnen Optionen im Detail erläutert, damit Sie die richtige wählen können.

Verbindung zum Server herstellen

Wenn Sie noch kein SSL-Zertifikat haben, empfehlen wir Ihnen, eines bei LeaderSSL zu bestellen. Es kann für jede Website, jeden Online-Shop oder zur Überprüfung der Authentizität einer E-Mail verwendet werden.

Umgebungsvariablen verwenden

Der einfachste Weg, HTTPS zu konfigurieren, besteht darin, Ihr Zertifikat auf den Server hochzuladen und es über Docker-Umgebungsvariablen anzugeben. Beginnen Sie damit, ein Verzeichnis für die Zertifikatsdateien zu erstellen:

mkdir ~/n8n-certs

Sie können diese Dateien (normalerweise cert.crt und privkey.key) mit einer beliebigen Methode in dieses Verzeichnis hochladen. Ausführlichere Informationen finden Sie unter:

Starten wir nun den Container mit einem vollständigen Befehl:

sudo docker run -d \
--name n8n \
-p 5678:5678 \
-v n8n_data:/home/node/.n8n \
-v ~/n8n-certs:/certs \
-e N8N_PROTOCOL=https \
-e N8N_SSL_CERT="/certs/cert.crt" \
-e N8N_SSL_KEY="/certs/privkey.key" \
docker.n8n.io/n8nio/n8n

Hier ist eine Aufschlüsselung der einzelnen Argumente:

sudo docker run -d Startet den Docker-Container im Daemon-Modus (im Hintergrund)
--name n8n weist dem Container den Namen zu n8n
-p 5678:5678 leitet den Port 5678 an den Container weiter
-v n8n_data:/home/node/.n8n erstellt ein Volume mit dem Namen n8n_data und hängt es in das versteckte Verzeichnis /home/node/.n8n innerhalb des Containers ein
-v ~/n8n-certs:/certs mountet das Zertifikatsverzeichnis
-e N8N_PROTOCOL=https zwingt N8N zur Verwendung des HTTPS-Protokolls
-e N8N_SSL_CERT="/certs/cert.crt" legt den Pfad zur Zertifikatsdatei fest
-e N8N_SSL_KEY="/certs/privkey.key" legt den Pfad zum Zertifikatsschlüssel fest
docker.n8n.io/n8nio/n8n Container-Image-Quelle

Traefik

Eine etwas kompliziertere, aber flexible Einrichtung beinhaltet die Verwendung des Traefik-Reverse-Proxy-Servers zur Sicherung der Verbindung zu N8N. Die Konfigurationsdatei basiert auf der offiziellen Methode, die in der Dokumentation beschrieben ist. Installieren Sie zunächst das Tool docker-compose:

sudo apt -y install docker-compose

Wir werden Traefik und N8N gemeinsam einrichten, und sie müssen sich im selben Netzwerk befinden. Erstellen Sie ein Netzwerk mit dem Namen web.

sudo docker network create web

Erstellen Sie nun eine docker-compose.yml Datei, um beide Container zu definieren und auszuführen:

nano docker-compose.yml

services:
  traefik:
    image: "traefik"
    container_name: "proxy"
    restart: always
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true"
      - "--certificatesresolvers.mytlschallenge.acme.email=${SSL_EMAIL}"
      - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - traefik_data:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: "n8n"
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    labels:
      - traefik.enable=true
      - traefik.http.routers.n8n.rule=Host(`${SUBDOMAIN}.${DOMAIN_NAME}`)
      - traefik.http.routers.n8n.tls=true
      - traefik.http.routers.n8n.entrypoints=web,websecure
      - traefik.http.routers.n8n.tls.certresolver=mytlschallenge
      - traefik.http.middlewares.n8n.headers.SSLRedirect=true
      - traefik.http.middlewares.n8n.headers.STSSeconds=315360000
      - traefik.http.middlewares.n8n.headers.browserXSSFilter=true
      - traefik.http.middlewares.n8n.headers.contentTypeNosniff=true
      - traefik.http.middlewares.n8n.headers.forceSTSHeader=true
      - traefik.http.middlewares.n8n.headers.SSLHost=${DOMAIN_NAME}
      - traefik.http.middlewares.n8n.headers.STSIncludeSubdomains=true
      - traefik.http.middlewares.n8n.headers.STSPreload=true
      - traefik.http.routers.n8n.middlewares=n8n@docker
    environment:
      - N8N_HOST=${SUBDOMAIN}.${DOMAIN_NAME}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://${SUBDOMAIN}.${DOMAIN_NAME}/
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
    networks:
      - web

volumes:
  n8n_data:
  traefik_data:

networks:
  web:
    name: web

Zusätzlich zur Datei docker-compose.yml erstellen wir eine weitere Datei namens .env. Diese Datei enthält Variablen wie den Domainnamen und die E-Mail-Adresse, die für die Anforderung eines SSL-Zertifikats bei Let's Encrypt verwendet werden. Wenn wir etwas ändern müssen, z. B. den Domänennamen, brauchen wir ihn nur in dieser Datei zu aktualisieren und dann den Container neu zu erstellen.

nano .env

DOMAIN_NAME=example.com
SUBDOMAIN=n8n
GENERIC_TIMEZONE=Europe/Amsterdam
SSL_EMAIL=user@example.com

Zum Schluss stellen Sie beide Container bereit:

sudo docker-compose up -d

Jetzt ist N8N hier verfügbar: https://n8n.example.com.

Nginx Proxy Manager

Im Gegensatz zu Traefik, das über Dateien konfiguriert wird, bietet der Nginx Proxy Manager ein benutzerfreundliches Web-Interface. Allerdings werden die Dienste nicht dynamisch erkannt, sondern Sie müssen sie manuell hinzufügen. Dennoch funktioniert er gut für statische Dienste wie N8N.

Erstellen Sie eine weitere Datei docker-compose.yml in einem separaten Verzeichnis mit dem folgenden Inhalt:

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: proxy
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    environment:
      - N8N_HOST=n8n.example.com
      - N8N_PORT=5678
      - WEBHOOK_URL=https://n8n.example.com/
      - N8N_PROTOCOL=http
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - web

volumes:
  n8n_data:

networks:
  web:
    external: true

Bereitstellen mit:

sudo docker-compose up -d

Dann öffnen Sie das Web-Interface unter: http://your_hostname_or_ip:81

Benutzername: admin@example.com
Kennwort: changeme

Sie werden aufgefordert, Ihre Anmeldedaten zu aktualisieren. Öffnen Sie anschließend Hosts → Proxy Hosts → Add Proxy Host und geben Sie Ihren Domänennamen ein (z. B. n8n.example.com):

Füllen Sie die erforderlichen Felder aus:

Setzen Sie Destination/IP auf n8n.
Setzen Sie Port auf 5678.
Wählen Sie unter der Registerkarte SSL die Option Request a new SSL certificate with Let’s Encrypt.
Geben Sie Ihre E-Mail-Adresse ein und stimmen Sie den Bedingungen zu.
Klicken Sie auf Websockets support.
Klicken Sie optional auf Force SSL.

Nachdem Sie auf Save geklickt haben, wird das Zertifikat angefordert und installiert:

Wenn Sie Ihre Domain öffnen, gelangen Sie zur N8N-Schnittstelle.

SSH-Tunnel

Wenn Sie die N8N-Erreichbarkeit von außen nicht benötigen, können Sie Port 5678 über SSH weiterleiten. Dadurch wird der gesamte Datenverkehr verschlüsselt, und N8N wird unter http://localhost:5678/ verfügbar sein.

Hinweis: Diese Einrichtung funktioniert nicht für Integrationen mit externen Diensten wie Messengern, die einen öffentlichen HTTPS-Zugang benötigen.

Der einfachste Weg, den Port weiterzuleiten, ist mit dem beliebten SSH-Client PuTTY. Öffnen Sie nach der Installation SSH → Tunnels und setzen Sie Source port - 5678 und Destination - localhost:5678. Klicken Sie dann auf Add.

Gehen Sie zurück zu Session, geben Sie die IP Ihres Servers ein und klicken Sie auf Open. Sobald die Authentifizierung erfolgt ist, ist der Tunnel aktiv. Öffnen Sie http://localhost:5678 in einem Browser, um auf N8N zuzugreifen.

Hinweis: Die Verbindung funktioniert nur, solange die SSH-Sitzung aktiv ist. Wenn Sie PuTTY schließen, wird der Tunnel beendet.

Umgehung von

Diese Methode wird für den Einsatz in öffentlichen Netzwerken nicht empfohlen. Wenn Sie den Container mit der Umgebungsvariablen N8N_SECURE_COOKIE=false starten, verschwindet die Warnung, und Sie erhalten Zugang über HTTP:

sudo docker run -d --name n8n -p 5678:5678 -e N8N_SECURE_COOKIE=false -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Warning: Dadurch wird das N8N-Administrationspanel über unverschlüsseltes HTTP zugänglich gemacht, was es anfällig für MITM-Angriffe (Man-In-The-Middle) macht und es einem Angreifer ermöglicht, Ihren Server vollständig zu übernehmen.

Siehe auch:

Triton™ Inference Server

Wed, 26 Feb 2025 16:40:21 +0100

Die Anforderungen der Unternehmen mögen unterschiedlich sein, aber sie alle haben ein gemeinsames Grundprinzip: Die Systeme müssen schnell arbeiten und die höchstmögliche Qualität liefern. Bei der Inferenz neuronaler Netze ist die effiziente Nutzung von Rechenressourcen entscheidend. Jede unzureichende Nutzung der GPU oder Leerlaufzeit führt direkt zu finanziellen Verlusten.

Nehmen wir als Beispiel einen Marktplatz. Auf diesen Plattformen werden zahlreiche Produkte angeboten, die jeweils mehrere Attribute aufweisen: Textbeschreibungen, technische Spezifikationen, Kategorien und Multimedia-Inhalte wie Fotos und Videos. Alle Inhalte müssen moderiert werden, um faire Bedingungen für Verkäufer zu gewährleisten und zu verhindern, dass verbotene Waren oder illegale Inhalte auf der Plattform erscheinen.

Eine manuelle Moderation ist zwar möglich, aber sie ist langsam und ineffizient. Im heutigen Wettbewerbsumfeld müssen Verkäufer ihre Produktpalette schnell erweitern: Je schneller die Artikel auf dem Marktplatz erscheinen, desto größer sind die Chancen, entdeckt und gekauft zu werden. Die manuelle Moderation ist außerdem kostspielig und anfällig für menschliche Fehler, die dazu führen können, dass ungeeignete Inhalte durchgelassen werden.

Die automatische Moderation mit Hilfe speziell trainierter neuronaler Netze bietet eine Lösung. Dieser Ansatz bringt mehrere Vorteile mit sich: Er senkt die Moderationskosten erheblich und verbessert in der Regel die Qualität. Neuronale Netze verarbeiten Inhalte viel schneller als Menschen, so dass die Verkäufer die Moderationsphase schneller durchlaufen können, insbesondere bei großen Produktmengen.

Der Ansatz hat aber auch seine Tücken. Die Implementierung einer automatisierten Moderation erfordert die Entwicklung und das Training von neuronalen Netzwerkmodellen, was sowohl qualifiziertes Personal als auch umfangreiche Computerressourcen erfordert. Die Vorteile werden jedoch schnell nach der ersten Implementierung deutlich. Die Einführung einer automatischen Modellbereitstellung kann den laufenden Betrieb erheblich rationalisieren.

Schlussfolgerung

Nehmen wir an, wir haben die Verfahren des maschinellen Lernens herausgefunden. Der nächste Schritt ist die Festlegung, wie die Modellinferenz auf einem gemieteten Server ausgeführt werden soll. Für ein einzelnes Modell wählen Sie in der Regel ein Tool, das gut mit dem spezifischen Framework funktioniert, auf dem es erstellt wurde. Bei mehreren Modellen, die in verschiedenen Frameworks erstellt wurden, haben Sie jedoch zwei Möglichkeiten.

Sie können entweder alle Modelle in ein einziges Format konvertieren oder ein Tool wählen, das mehrere Frameworks unterstützt. Der Triton™ Inference Server eignet sich perfekt für den zweiten Ansatz. Er unterstützt die folgenden Backends:

TensorRT™
TensorRT-LLM
vLLM
Python
PyTorch (LibTorch)
ONNX Laufzeit
Tensorflow
FIL
DALI

Zusätzlich können Sie jede Anwendung als Backend verwenden. Wenn Sie zum Beispiel Post-Processing mit einer C/C++ Anwendung benötigen, können Sie diese nahtlos integrieren.

Skalierung

Der Triton™ Inference Server verwaltet die Rechenressourcen auf einem einzigen Server effizient, indem er mehrere Modelle gleichzeitig ausführt und die Arbeitslast auf die GPUs verteilt.

Die Installation erfolgt über einen Docker-Container. DevOps-Ingenieure können die GPU-Zuweisung beim Start steuern und entscheiden, ob sie alle GPUs nutzen oder deren Anzahl begrenzen möchten. Die Software ermöglicht zwar keine direkte horizontale Skalierung, aber Sie können zu diesem Zweck herkömmliche Load Balancer wie HAproxy verwenden oder Anwendungen in einem Kubernetes-Cluster bereitstellen.

Vorbereiten des Systems

Um Triton™ auf einem LeaderGPU-Server unter Ubuntu 22.04 einzurichten, aktualisieren Sie das System zunächst mit diesem Befehl:

sudo apt update && sudo apt -y upgrade

Installieren Sie zunächst die Nvidia-Treiber mit Hilfe des Auto-Installer-Skripts:

sudo ubuntu-drivers autoinstall

Starten Sie den Server neu, um die Änderungen zu übernehmen:

sudo shutdown -r now

Sobald der Server wieder online ist, installieren Sie Docker mit dem folgenden Installationsskript:

curl -sSL https://get.docker.com/ | sh

Da Docker standardmäßig keine GPUs an Container weitergeben kann, benötigen Sie das NVIDIA® Container Toolkit. Fügen Sie das Nvidia-Repository hinzu, indem Sie seinen GPG-Schlüssel herunterladen und registrieren:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aktualisieren Sie den Paket-Cache und installieren Sie das Toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Starten Sie Docker neu, um die neuen Funktionen zu aktivieren:

sudo systemctl restart docker

Das Betriebssystem ist nun einsatzbereit.

Installation von Triton™ Inference Server

Laden wir das Projekt-Repository herunter:

git clone https://github.com/triton-inference-server/server

Dieses Repository enthält vorkonfigurierte Beispiele für neuronale Netze und ein Modell-Download-Skript. Navigieren Sie zum Verzeichnis examples:

cd server/docs/examples

Laden Sie die Modelle herunter, indem Sie das folgende Skript ausführen, das sie unter ~/server/docs/examples/model_repository speichert:

./fetch_models.sh

Die Architektur des Triton™ Inference Servers erfordert, dass die Modelle separat gespeichert werden. Sie können sie entweder lokal in einem beliebigen Serververzeichnis oder auf einem Netzwerkspeicher ablegen. Wenn Sie den Server starten, müssen Sie dieses Verzeichnis in den Container unter dem Einhängepunkt /models einhängen. Dies dient als Repository für alle Modellversionen.

Starten Sie den Container mit folgendem Befehl

sudo docker run --gpus=all --rm -p8000:8000 -p8001:8001 -p8002:8002 -v ~/server/docs/examples/model_repository:/models nvcr.io/nvidia/tritonserver:25.01-py3 tritonserver --model-repository=/models

Die einzelnen Parameter sind wie folgt zu verstehen:

--gpus=all legt fest, dass alle verfügbaren GPUs im Server verwendet werden;
--rm zerstört den Container, nachdem der Prozess abgeschlossen oder angehalten wurde;
-p8000:8000 leitet Port 8000 weiter, um HTTP-Anfragen zu empfangen;
-p8001:8001 leitet Port 8001 weiter, um gRPC-Anfragen zu empfangen;
-p8002:8002 leitet Port 8002 weiter, um Metriken anzufordern;
-v ~/server/docs/examples/model_repository:/models leitet das Verzeichnis mit den Modellen weiter;
nvcr.io/nvidia/tritonserver:25.01-py3 Adresse des Containers aus dem NGC-Katalog;
tritonserver --model-repository=/models startet den Triton™ Inference Server mit dem Speicherort des Models Repository unter /models.

Die Befehlsausgabe zeigt alle verfügbaren Modelle im Repository an, die alle bereit sind, Anfragen zu akzeptieren:

+----------------------+---------+--------+
| Model                | Version | Status |
+----------------------+---------+--------+
| densenet_onnx        | 1       | READY  |
| inception_graphdef   | 1       | READY  |
| simple               | 1       | READY  |
| simple_dyna_sequence | 1       | READY  |
| simple_identity      | 1       | READY  |
| simple_int8          | 1       | READY  |
| simple_sequence      | 1       | READY  |
| simple_string        | 1       | READY  |
+----------------------+---------+--------+

Die drei Dienste wurden erfolgreich auf den Ports 8000, 8001 und 8002 gestartet:

I0217 08:00:34.930188 1 grpc_server.cc:2466] Started GRPCInferenceService at 0.0.0.0:8001
I0217 08:00:34.930393 1 http_server.cc:4636] Started HTTPService at 0.0.0.0:8000
I0217 08:00:34.972340 1 http_server.cc:320] Started Metrics Service at 0.0.0.0:8002

Mit dem Dienstprogramm nvtop können wir überprüfen, ob alle GPUs bereit sind, die Last aufzunehmen:

Installieren des Clients

Um auf unseren Server zuzugreifen, müssen wir eine entsprechende Anfrage mit dem im SDK enthaltenen Client erstellen. Wir können dieses SDK als Docker-Container herunterladen:

sudo docker pull nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Starten Sie den Container im interaktiven Modus, um auf die Konsole zuzugreifen:

sudo docker run -it --gpus=all --rm --net=host nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Testen wir dies mit dem DenseNet-Modell im ONNX-Format, indem wir die INCEPTION-Methode zur Vorverarbeitung und Analyse von Bildern verwenden mug.jpg:

/workspace/install/bin/image_client -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg

Der Client kontaktiert den Server, der einen Stapel erstellt und ihn mit den verfügbaren GPUs des Containers verarbeitet. Hier ist die Ausgabe:

Request 0, batch size 1
Image '/workspace/images/mug.jpg':
   15.349562 (504) = COFFEE MUG
   13.227461 (968) = CUP
   10.424891 (505) = COFFEEPOT

Vorbereiten des Repositorys

Damit Triton™ die Modelle korrekt verwalten kann, müssen Sie das Repository auf eine bestimmte Weise vorbereiten. Hier ist die Verzeichnisstruktur:

model_repository/ 
        └── your_model/ 
                ├── config.pbtxt 
                └── 1/
                    └── model.*

Jedes Modell benötigt ein eigenes Verzeichnis, das eine config.pbtxt Konfigurationsdatei mit der Beschreibung des Modells enthält. Hier ist ein Beispiel:

name: "Test"
platform: "pytorch_libtorch"
max_batch_size: 8
input [
  {
    name: "INPUT_0"
    data_type: TYPE_FP32
    dims: [ 3, 224, 224 ]
  }
]
output [
  {
    name: "OUTPUT_0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

In diesem Beispiel wird ein Modell namens Test auf dem PyTorch-Backend ausgeführt. Der Parameter max_batch_size legt die maximale Anzahl von Elementen fest, die gleichzeitig verarbeitet werden können, um einen effizienten Lastausgleich zwischen den Ressourcen zu ermöglichen. Wenn dieser Wert auf Null gesetzt wird, wird die Stapelverarbeitung deaktiviert, so dass das Modell die Anfragen sequentiell verarbeitet.

Das Modell akzeptiert eine Eingabe und erzeugt eine Ausgabe, die beide den Zahlentyp FP32 verwenden. Die Parameter müssen genau mit den Anforderungen des Modells übereinstimmen. Für die Bildverarbeitung ist eine typische Dimensionsangabe dims: [ 3, 224, 224 ], wobei:

3 - Anzahl der Farbkanäle (RGB);
224 - Bildhöhe in Pixeln;
224 - Bildbreite in Pixeln.

Die Ausgabe dims: [ 1000 ] stellt einen eindimensionalen Vektor mit 1000 Elementen dar, der sich für Bildklassifizierungsaufgaben eignet. Um die richtige Dimensionalität für Ihr Modell zu bestimmen, konsultieren Sie die Dokumentation des Modells. Wenn die Konfigurationsdatei unvollständig ist, versucht Triton™, die fehlenden Parameter automatisch zu generieren.

Starten eines benutzerdefinierten Modells

Starten wir die Inferenz des destillierten DeepSeek-R1-Modells, das wir zuvor besprochen haben. Zunächst erstellen wir die erforderliche Verzeichnisstruktur:

mkdir ~/model_repository && mkdir ~/model_repository/deepseek && mkdir ~/model_repository/deepseek/1

Navigieren Sie zum Modellverzeichnis:

cd ~/model_repository/deepseek

Erstellen Sie eine Konfigurationsdatei config.pbtxt:

nano config.pbtxt

Fügen Sie das Folgende ein:

# Copyright 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
# Note: You do not need to change any fields in this configuration.
    
backend: "vllm"
    
# The usage of device is deferred to the vLLM engine
instance_group [
  {
    count: 1
    kind: KIND_MODEL
  }
]

Speichern Sie die Datei, indem Sie Ctrl + O drücken, dann den Editor mit Ctrl + X. Wechseln Sie in das Verzeichnis 1:

cd 1

Erstellen Sie eine Modellkonfigurationsdatei model.json mit den folgenden Parametern:

{
    "model":"deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "disable_log_requests": true,
    "gpu_memory_utilization": 0.9,
    "enforce_eager": true
}

Beachten Sie, dass der Wert gpu_memory_utilization je nach GPU variiert und experimentell ermittelt werden sollte. Für diese Anleitung verwenden wir 0.9. Ihre Verzeichnisstruktur innerhalb von ~/model_repository sollte nun wie folgt aussehen:

└── deepseek
        ├── 1
        │   └── model.json
        └── config.pbtxt

Setzen Sie der Einfachheit halber die Variable LOCAL_MODEL_REPOSITORY:

LOCAL_MODEL_REPOSITORY=~/model_repository/

Starten Sie den Inferenzserver mit diesem Befehl:

sudo docker run --rm -it --net host --shm-size=2g  --ulimit memlock=-1 --ulimit stack=67108864 --gpus all -v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository  nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 tritonserver --model-repository=model_repository/

Die Bedeutung der einzelnen Parameter ist wie folgt:

--rm Entfernt den Container nach dem Stoppen automatisch;
-it führt den Container im interaktiven Modus mit Terminalausgabe aus;
--net Host verwendet den Netzwerkstack des Hosts anstelle der Container-Isolation;
--shm-size=2g setzt den gemeinsamen Speicher auf 2 GB;
--ulimit memlock=-1 hebt die Begrenzung der Speichersperre auf;
--ulimit stack=67108864 setzt die Stack-Größe auf 64 MB;
--gpus all ermöglicht den Zugriff auf alle Server-GPUs;
-v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository hängt das lokale Modellverzeichnis in den Container ein;
nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 spezifiziert den Container mit vLLM-Backend-Unterstützung;
tritonserver --model-repository=model_repository/ startet den Triton™ Inference Server mit dem Speicherort des Modell-Repository unter model_repository.

Testen Sie den Server, indem Sie eine Anfrage mit curl senden, wobei Sie eine einfache Eingabeaufforderung und ein Antwortlimit von 4096 Token verwenden:

curl -X POST localhost:8000/v2/models/deepseek/generate -d '{"text_input": "Tell me about the Netherlands?", "max_tokens": 4096}'

Der Server empfängt und verarbeitet die Anfrage erfolgreich.

Der interne Triton-Aufgabenplaner bearbeitet alle eingehenden Anfragen, wenn der Server unter Last steht.

Fazit

Der Triton™ Inference Server eignet sich hervorragend für den Einsatz von Machine-Learning-Modellen in der Produktion, indem er die Anfragen effizient auf die verfügbaren GPUs verteilt. Dies maximiert die Nutzung der gemieteten Serverressourcen und reduziert die Kosten für die Recheninfrastruktur. Die Software arbeitet mit verschiedenen Backends, einschließlich vLLM für große Sprachmodelle.

Da sie als Docker-Container installiert wird, können Sie sie problemlos in jede moderne CI/CD-Pipeline integrieren. Probieren Sie es selbst aus und mieten Sie einen Server von LeaderGPU.

DeepSeek-R1: Zukunft der LLMs

Wed, 19 Feb 2025 15:10:33 +0100

Generative neuronale Netze haben sich zwar rasant entwickelt, doch in den letzten Jahren waren ihre Fortschritte relativ konstant. Dies änderte sich mit DeepSeek, einem chinesischen neuronalen Netzwerk, das nicht nur die Börse beeinflusste, sondern auch die Aufmerksamkeit von Entwicklern und Forschern weltweit auf sich zog. Im Gegensatz zu anderen Großprojekten wurde der Code von DeepSeek unter der freizügigen MIT-Lizenz veröffentlicht. Dieser Schritt in Richtung Open Source wurde von der Community gelobt, die eifrig begann, die Fähigkeiten des neuen Modells zu erforschen.

Der beeindruckendste Aspekt war, dass das Training dieses neuen neuronalen Netzwerks Berichten zufolge 20 Mal weniger kostete als das von Konkurrenten, die eine ähnliche Qualität bieten. Das Modell benötigte nur 55 Tage und 5,6 Millionen Dollar für das Training. Als DeepSeek veröffentlicht wurde, löste es einen der größten Tageseinbrüche in der Geschichte des US-Aktienmarktes aus. Obwohl sich die Märkte schließlich stabilisierten, waren die Auswirkungen erheblich.

In diesem Artikel wird untersucht, wie genau die Schlagzeilen in den Medien die Realität widerspiegeln, und es wird erforscht, welche LeaderGPU-Konfigurationen geeignet sind, um dieses neuronale Netzwerk selbst zu installieren.

Architektonische Merkmale

DeepSeek hat einen Weg der maximalen Optimierung gewählt, was angesichts der Exportbeschränkungen Chinas in die USA nicht überrascht. Diese Beschränkungen hindern das Land daran, offiziell die fortschrittlichsten GPU-Modelle für die KI-Entwicklung zu nutzen.

Das Modell nutzt die Multi Token Prediction (MTP)-Technologie, die mehrere Token in einem einzigen Inferenzschritt vorhersagt statt nur eines. Dies funktioniert durch parallele Token-Dekodierung in Kombination mit speziellen maskierten Schichten, die die Autoregressivität aufrechterhalten.

MTP-Tests haben bemerkenswerte Ergebnisse gezeigt, die die Generierungsgeschwindigkeit im Vergleich zu herkömmlichen Methoden um das 2 bis 4-fache erhöhen. Die hervorragende Skalierbarkeit der Technologie macht sie für aktuelle und zukünftige Anwendungen der natürlichen Sprachverarbeitung wertvoll.

Das Multi-Head Latent Attention (MLA) Modell verfügt über einen erweiterten Aufmerksamkeitsmechanismus. Während das Modell lange Ketten von Schlussfolgerungen aufbaut, behält es in jeder Phase die Aufmerksamkeit auf den Kontext. Diese Erweiterung verbessert den Umgang mit abstrakten Konzepten und Textabhängigkeiten.

Das Hauptmerkmal von MLA ist die Fähigkeit, die Aufmerksamkeitsgewichtung auf verschiedenen Abstraktionsebenen dynamisch anzupassen. Bei der Verarbeitung komplexer Abfragen untersucht MLA die Daten aus mehreren Perspektiven: Wortbedeutungen, Satzstrukturen und Gesamtkontext. Diese Perspektiven bilden verschiedene Ebenen, die die endgültige Ausgabe beeinflussen. Um die Übersichtlichkeit zu wahren, gleicht MLA die Auswirkungen der einzelnen Ebenen sorgfältig aus und konzentriert sich dabei auf die Hauptaufgabe.

Die Entwickler von DeepSeek haben die Mixture of Experts (MoE) Technologie in das Modell integriert. Es enthält 256 vortrainierte neuronale Expertennetzwerke, die jeweils auf unterschiedliche Aufgaben spezialisiert sind. Das System aktiviert 8 dieser Netze für jede Token-Eingabe und ermöglicht so eine effiziente Datenverarbeitung ohne Erhöhung der Rechenkosten.

Im vollständigen Modell mit 671b Parametern werden nur 37b für jedes Token aktiviert. Das Modell wählt auf intelligente Weise die relevantesten Parameter für die Verarbeitung jedes eingehenden Tokens aus. Diese effiziente Optimierung spart Rechenressourcen bei gleichbleibend hoher Leistung.

Ein entscheidendes Merkmal jedes Chatbots mit neuronalem Netzwerk ist die Länge des Kontextfensters. Llama 2 hat ein Kontextlimit von 4.096 Token, GPT-3.5 kann 16.284 Token verarbeiten, während GPT-4 und DeepSeek bis zu 128.000 Token verarbeiten können (etwa 100.000 Wörter, was 300 Seiten maschinengeschriebenen Textes entspricht).

R - steht für Reasoning

DeepSeek-R1 verfügt über einen Reasoning-Mechanismus ähnlich dem von OpenAI o1, der es ihm ermöglicht, komplexe Aufgaben effizienter und genauer zu bearbeiten. Anstatt sofortige Antworten zu geben, erweitert das Modell den Kontext, indem es schrittweise Schlussfolgerungen in kleinen Absätzen generiert. Dieser Ansatz verbessert die Fähigkeit des neuronalen Netzwerks, komplexe Datenbeziehungen zu erkennen, was zu umfassenderen und präziseren Antworten führt.

Wenn DeepSeek mit einer komplexen Aufgabe konfrontiert wird, nutzt es seinen Argumentationsmechanismus, um das Problem in einzelne Komponenten zu zerlegen und jede einzelne zu analysieren. Das Modell fasst diese Erkenntnisse dann zusammen, um eine Antwort für den Benutzer zu generieren. Obwohl dies ein idealer Ansatz für neuronale Netze zu sein scheint, ist er mit erheblichen Herausforderungen verbunden.

Alle modernen LLMs haben eine besorgniserregende Eigenschaft gemeinsam - künstliche Halluzinationen. Wenn eine Frage gestellt wird, die es nicht beantworten kann, kann es passieren, dass das Modell, anstatt seine Grenzen anzuerkennen, fiktive Antworten erzeugt, die durch erfundene Fakten gestützt werden.

Bei der Anwendung auf ein logisch denkendes neuronales Netz könnten diese Halluzinationen den Denkprozess beeinträchtigen, da die Schlussfolgerungen eher auf fiktiven als auf faktischen Informationen beruhen. Dies könnte zu falschen Schlussfolgerungen führen - eine Herausforderung, der sich Forscher und Entwickler neuronaler Netze in Zukunft stellen müssen.

VRAM-Verbrauch

Untersuchen wir, wie DeepSeek R1 auf einem dedizierten Server ausgeführt und getestet werden kann, und konzentrieren wir uns dabei auf die Anforderungen an den GPU-Videospeicher.

Modell	VRAM (Mb)	Modellgröße (Gb)
deepseek-r1:1.5b	1,952	1.1
deepseek-r1:7b	5,604	4.7
Tiefensuche-r1:8b	6,482	4.9
Tiefensuche-r1:14b	10,880	9
Tiefensuche-r1:32b	21,758	20
Tiefensuche-r1:70b	39,284	43
Tiefensuche-r1:671b	470,091	404

Die ersten drei Optionen (1.5b, 7b, 8b) sind Basismodelle, die die meisten Aufgaben effizient erledigen können. Diese Modelle laufen reibungslos auf jeder Consumer-GPU mit 6-8 GB Videospeicher. Die mittleren Versionen (14b und 32b) sind ideal für professionelle Aufgaben, benötigen aber mehr VRAM. Die größten Modelle (70b und 671b) erfordern spezielle Grafikprozessoren und werden vor allem in der Forschung und für industrielle Anwendungen eingesetzt.

Server-Auswahl

Um Ihnen die Auswahl eines Servers für DeepSeek-Inferenz zu erleichtern, finden Sie hier die idealen LeaderGPU-Konfigurationen für jede Modellgruppe:

1,5b / 7b / 8b / 14b / 32b / 70b

Für diese Gruppe ist jeder Server mit den folgenden GPU-Typen geeignet. Die meisten LeaderGPU-Server können diese neuronalen Netze ohne Probleme ausführen. Die Leistung hängt hauptsächlich von der Anzahl der CUDA-Kerne ab. Wir empfehlen Server mit mehreren GPUs, wie zum Beispiel:

671b

Nun zum schwierigsten Fall: Wie können Sie Inferenzen für ein Modell mit einer Basisgröße von 404 GB durchführen? Das bedeutet, dass etwa 470 GB Videospeicher benötigt werden. LeaderGPU bietet mehrere Konfigurationen mit den folgenden GPUs, die diese Last bewältigen können:

A100
H100

Beide Konfigurationen handhaben die Modelllast effizient und verteilen sie gleichmäßig auf mehrere GPUs. So sieht zum Beispiel ein Server mit 8xH100 nach dem Laden des Modells deepseek-r1:671b aus:

Die Rechenlast verteilt sich dynamisch auf die GPUs, während Hochgeschwindigkeits-NVLink-Verbindungen Engpässe beim Datenaustausch verhindern und so für maximale Leistung sorgen.

Schlussfolgerung

DeepSeek-R1 kombiniert viele innovative Technologien wie Multi Token Prediction, Multi-Head Latent Attention und Mixture of Experts in einem signifikanten Modell. Diese Open-Source-Software zeigt, dass LLMs mit weniger Rechenressourcen effizienter entwickelt werden können. Das Modell hat verschiedene Versionen, von kleineren 1,5b bis zu riesigen 671b, die spezielle Hardware mit mehreren parallel arbeitenden High-End-GPUs erfordern.

Wenn Sie einen Server von LeaderGPU für DeepSeek-R1-Inferenz mieten, erhalten Sie eine breite Palette von Konfigurationen, Zuverlässigkeit und Fehlertoleranz. Unser technisches Support-Team hilft Ihnen bei allen Problemen oder Fragen, während die automatische Betriebssysteminstallation die Bereitstellungszeit reduziert.

Wählen Sie Ihren LeaderGPU-Server und entdecken Sie die Möglichkeiten, die sich bei der Verwendung moderner neuronaler Netzwerkmodelle eröffnen. Wenn Sie irgendwelche Fragen haben, zögern Sie nicht, sie in unserem Chat oder per E-Mail zu stellen.

Intel Habana Gaudi 2: installieren und testen

Thu, 23 Jan 2025 13:41:09 +0100

Bevor Sie mit der Installation der Gaudi 2 Accelerators Software beginnen, sollten Sie eine wichtige Funktion erwähnen. Wir sind daran gewöhnt, dass das Training und die Inferenz von neuronalen Netzen mit GPUs durchgeführt werden können. Intel Habana Gaudi 2 unterscheidet sich jedoch stark von GPUs und stellt eine andere Klasse von Geräten dar, die ausschließlich für die Beschleunigung von KI-Aufgaben konzipiert sind.

Viele bekannte Anwendungen und Frameworks funktionieren nicht ohne vorherige Vorbereitung des Betriebssystems und in einigen Fällen auch nicht ohne ein spezielles GPU Migration Toolkit. Dies erklärt die große Anzahl von Vorbereitungsschritten, die wir in diesem Artikel beschreiben. Beginnen wir der Reihe nach.

Schritt 1. SynapseAI Software Stack installieren

Um mit Intel Habana Gaudi 2 Beschleunigern arbeiten zu können, müssen Sie den SynapseAI Stack installieren. Er umfasst einen speziellen Graphen-Compiler, der die Topologie des neuronalen Netzwerkmodells umwandelt, um die Ausführung auf der Gaudi-Architektur effektiv zu optimieren, API-Bibliotheken für die horizontale Skalierung sowie ein separates SDK für die Erstellung von Hochleistungsalgorithmen und maschinellen Lernmodellen.

Unabhängig davon ist SynapseAI der Teil, der es Ihnen ermöglicht, eine Brücke zwischen beliebten Frameworks wie PyTorch/TensorFlow und den Gaudi 2 AI-Beschleunigern zu schlagen. Dadurch können Sie mit vertrauten Abstraktionen arbeiten, und Gaudi 2 optimiert unabhängig Berechnungen. Spezifische Operatoren, für die Beschleuniger keine Hardwareunterstützung haben, werden auf der CPU ausgeführt.

Um die Installation der einzelnen SynapseAI-Komponenten zu vereinfachen, wurde ein praktisches Shell-Skript erstellt. Lassen Sie es uns herunterladen:

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Machen Sie die Datei ausführbar:

chmod +x habanalabs-installer.sh

Führen Sie das Skript aus:

./habanalabs-installer.sh install --type base

Folgen Sie den Anweisungen des Systems während der Installation. Sie finden einen detaillierten Bericht in der Protokolldatei. Darin können Sie sehen, welche Pakete installiert wurden, und ob die Beschleuniger erfolgreich gefunden und initialisiert wurden.

Protokolle hier: /var/log/habana_logs/install-YYYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Genauso wie das nvidia-smi-Dienstprogramm Informationen über installierte GPUs und laufende Rechenprozesse liefert, hat SynapseAI ein ähnliches Programm. Sie können es ausführen, um einen Bericht über den aktuellen Zustand der Gaudi 2 AI-Beschleuniger zu erhalten:

hl-smi

Schritt 2. TensorFlow-Test

TensorFlow ist eine der beliebtesten Plattformen für maschinelles Lernen. Mit dem gleichen Installationsskript können Sie eine vorgefertigte Version von TensorFlow mit Unterstützung für Gaudi 2 Beschleuniger installieren. Lassen Sie uns mit der Installation der allgemeinen Abhängigkeiten beginnen:

./habanalabs-installer.sh install -t dependencies

Als nächstes werden wir die Abhängigkeiten für TensorFlow installieren:

./habanalabs-installer.sh install -t dependencies-tensorflow

Installieren Sie die TensorFlow Plattform innerhalb einer virtuellen Umgebung, die mit dem Python Virtual Environment (venv) Mechanismus implementiert wurde:

./habanalabs-installer.sh install --type tensorflow --venv

Lassen Sie uns die erstellte virtuelle Umgebung aktivieren:

source habanalabs-venv/bin/activate

Erstellen Sie ein einfaches Python-Codebeispiel, das die Fähigkeiten der Gaudi 2-Beschleuniger nutzt:

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Führen Sie schließlich die Anwendung aus:

python3 example.py

Um die virtuelle Umgebung zu beenden, führen Sie den folgenden Befehl aus:

deactivate

Schritt 3. Trainings-Repository klonen

Klonen Sie das Repository mit dem MLperf-Code:

git clone https://github.com/mlcommons/training_results_v3.0

Erstellen Sie ein separates Verzeichnis, das vom Docker-Container mit MLperf verwendet werden soll:

mkdir -p mlperf

Wechseln Sie das Verzeichnis:

cd mlperf

Lassen Sie uns einige Umgebungsvariablen exportieren:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Erstellen Sie neue Verzeichnisse unter Verwendung der erstellten Variablen:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Kopieren Sie die Benchmark-Anwendung nach $MLPERF_DIR/Habana:

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Exportieren Sie eine weitere Variable, in der ein Link zum Herunterladen der gewünschten Version des Docker-Containers gespeichert wird:

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Schritt 4. Docker installieren

Unsere Instanz läuft unter Ubuntu Linux 22.04 LTS und unterstützt Docker standardmäßig nicht. Bevor Sie also Container herunterladen und ausführen können, müssen Sie die Docker-Unterstützung installieren. Aktualisieren Sie den Paket-Cache und installieren Sie einige grundlegende Pakete, die Sie später benötigen werden:

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Um Docker zu installieren, müssen Sie ein digital signiertes Projekt-Repository hinzufügen. Laden Sie den Schlüssel für die digitale Signatur herunter und fügen Sie ihn dem Schlüsselspeicher des Betriebssystems hinzu:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker kann auf Plattformen mit verschiedenen Architekturen ausgeführt werden. Der folgende Befehl erkennt die Architektur Ihres Servers und fügt die entsprechende Repository-Zeile in die Liste des APT-Paketmanagers ein:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisieren Sie den Paket-Cache und die Richtlinien und installieren Sie docker-ce (Docker Community Edition):

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Prüfen Sie abschließend, ob der Docker-Daemon läuft und funktioniert:

sudo systemctl status docker

Schritt 5. Docker-Container starten

Starten wir den Container im privilegierten Modus unter Verwendung der zuvor angegebenen Variablen:

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Der Einfachheit halber können Sie über SSH auf das Terminal innerhalb des Containers zugreifen:

sudo docker exec mlperf3.0 bash -c "service ssh start"

Um eine Befehlsshell (bash) in der aktuellen Sitzung zu öffnen, führen Sie den folgenden Befehl aus:

sudo docker exec -it mlperf3.0 bash

Schritt 6. Vorbereiten eines Datensatzes

Um Bert-Implementierungstests mit MLperf durchzuführen, benötigen Sie einen vorbereiteten Datensatz. Die optimale Methode ist die Erzeugung eines Datensatzes aus vorgeladenen Daten. Das MLperf-Repository enthält ein spezielles Skript, prepare_data.sh, das eine bestimmte Anzahl von Paketen benötigt, um zu funktionieren. Wechseln wir in das folgende Verzeichnis:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Installieren Sie alle erforderlichen Pakete mit Hilfe der vorbereiteten Liste und dem pip-Paketmanager:

pip install -r requirements.txt

Setzen Sie die Variable PYTORCH_BERT_DATA, um dem Skript mitzuteilen, wo es Daten speichern soll:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Führen Sie das Skript aus:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

Das Generierungsverfahren ist recht langwierig und kann mehrere Stunden dauern. Bitte haben Sie Geduld und unterbrechen Sie den Vorgang nicht. Wenn Sie vorhaben, die SSH-Sitzung zu beenden, empfiehlt es sich, das Bildschirmdienstprogramm unmittelbar vor dem Start des Docker-Containers zu verwenden.

Schritt 7. Packen des Datensatzes

Der nächste Schritt besteht darin, den Datensatz für den anschließenden Start von MLperf in gleiche Teile zu "schneiden". Erstellen wir ein separates Verzeichnis für die gepackten Daten:

mkdir $PYTORCH_BERT_DATA/packed

Führen Sie das Packing-Skript aus:

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Schritt 8. Einen Test durchführen

Nun, da der Datensatz vorbereitet ist, ist es an der Zeit, den Test durchzuführen. Dies ist jedoch ohne vorherige Vorbereitung nicht möglich. Die Autoren des Bert-Tests haben einige fest kodierte Werte im Skript hinterlassen, die die Ausführung des Tests beeinträchtigen werden. Benennen Sie zunächst das folgende Verzeichnis um:

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Ändern Sie das Verzeichnis:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

Da der GNU Nano-Editor nicht im Container installiert ist, muss er separat installiert werden. Alternativ können Sie auch den eingebauten Vi-Editor verwenden:

apt update && apt -y install nano

Bearbeiten Sie nun das Teststartskript:

nano launch_bert_pytorch.sh

Suchen Sie die erste Zeile:

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Ersetzen Sie sie durch die folgende:

DATA_ROOT=/root/datasets/pytorch_bert

Suchen Sie die zweite Zeile:

INPUT_DIR=$DATA_ROOT/packed

Ersetzen Sie sie durch die folgende:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Speichern Sie die Datei und beenden Sie sie.

Der Testcode enthält eine Begrenzerfunktion, die den Gradienten daran hindert, bestimmte Werte zu überschreiten, um ein mögliches exponentielles Wachstum zu verhindern. Aus uns unbekannten Gründen fehlt diese Funktion in der im Container verwendeten PyTorch-Version, was dazu führt, dass der Test während der Aufwärmphase abnormal beendet wird.

Eine mögliche Abhilfe könnte darin bestehen, diese Funktion vorübergehend aus dem Code in der Datei fastddp.py zu entfernen. Dazu öffnen Sie die Datei:

nano ../PyTorch/fastddp.py

Suchen Sie die folgenden drei Codezeilen und kommentieren Sie sie mit dem Symbol # (shebang) aus, so dass sie wie folgt aussehen:

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Speichern Sie außerdem die Datei und beenden Sie sie. Wechseln Sie das Verzeichnis:

cd ../HLS-Gaudi2-PT

Führen Sie schließlich das Skript aus. Die Ausführung wird etwa 20 Minuten dauern:

./launch_bert_pytorch.sh

Siehe auch:

NVIDIA® RTX™ 50: Erwartungen und Realität

Thu, 23 Jan 2025 13:34:30 +0100

The highlight of CES 2025 was NVIDIA® CEO Jensen Huang’s speech. The revelation of new GPU specifications within minutes caught many off guard. In this article, we’ll examine how expert predictions matched the actual announcements.

Werfen wir zunächst einen Blick auf die Produktpalette. Die RTX™ 40-Serie wurde mit 6 Modellen eingeführt, die von der RTX™ 4060 bis zur RTX™ 4090 reichen. Während viele eine ähnliche Palette für die RTX™ 50-Serie erwartet haben, ist das nicht passiert. Stattdessen umfasst die RTX™ 50-Familie nur 4 Modelle: RTX™ 5070, RTX™ 5070 Ti, RTX™ 5080 und RTX™ 5090. Möglicherweise werden wir in Zukunft sowohl die RTX™ 5050 als auch die RTX™ 5060 sehen, aber es gibt noch keine offiziellen Quellen, die diese Grafikkarten bestätigt haben.

Technologischer Prozess

Das Mooresche Gesetz, die empirische Beobachtung, dass sich die Anzahl der Transistoren in einem integrierten Schaltkreis etwa alle zwei Jahre verdoppelt", wird oft als nicht mehr relevant für die Chipleistung bezeichnet. Seit 2022 hat Jensen Huang das Mooresche Gesetz wiederholt für tot erklärt. Stattdessen schlug er ein neues Konzept vor, das die gleichzeitige Entwicklung von Architektur, Mikrochips, Softwarebibliotheken und Algorithmen betont.

Diese Verlagerung ermöglicht es uns, uns auf die Gesamtleistung des Systems zu konzentrieren und nicht nur auf die Anzahl der Transistoren. Das Konzept der Computereffizienz hat in der Tech-Community immer wieder Diskussionen ausgelöst. Die Meinungen zu diesem Thema gehen zwar auseinander, doch steht die Branche eindeutig vor physischen und wirtschaftlichen Hindernissen für eine weitere Miniaturisierung.

Werfen wir einen Blick auf die neue Generation der GPU-Prozesstechnologie. In der Präsentation wurde dies nicht ausdrücklich erwähnt, aber alle Karten der vorherigen Generation wurden mit dem 4N-Prozess hergestellt. The RTX™ 50 series uses a different 4NP process technology. Gleichzeitig ist es wichtig zu verstehen, dass 4N und 4NP nur Marketingbezeichnungen sind. Die Transistoren selbst sind weiterhin 5 nm groß.

Die verbesserte 4NP-Prozesstechnologie ermöglicht in erster Linie eine höhere Transistordichte auf dem Chip und höhere Taktfrequenzen. Während Experten vorhersagten, dass der RTX™ 50 die gleiche Prozesstechnologie wie der RTX™ 40 verwenden würde, lagen sie technisch gesehen falsch, wenn auch nicht wesentlich, da die Transistorgröße unverändert bleibt und TSMC weiterhin als Hersteller fungiert.

Anzahl der Kerne

Vor der Veröffentlichung der RTX™ 50-Serie enthüllten zahlreiche Datenlecks die grundlegenden Eigenschaften der GPU. Erste Insiderberichte vom Juli 2024 besagten, dass das Flaggschiff über 24.576 Kerne, 192 Ray-Tracing-Kerne und 768 Tensor-Kerne verfügen würde. Spätere Leaks passten diese Zahlen jedoch an realistischere Werte an.

Die endgültige RTX™ 5090 wurde mit 21,760 CUDA® cores (gegenüber 16.384 bei der RTX™ 4090), 170 Ray-tracing cores und 680 Tensor cores ausgeliefert. Dies steht im Einklang mit der jüngsten Strategie des Unternehmens, die Leistung nicht nur durch eine erhöhte Transistoranzahl, sondern durch eine umfassende Optimierung der Architektur zu steigern.

Speicher

Die Verwendung von GDDR7-Speicher in den neuen GPUs kam nicht überraschend. Branchenexperten hatten diesen Schritt im Jahr 2024 vorausgesagt, nachdem die drei großen Hersteller (Samsung, Micron und SK hynix) nacheinander ihre GDDR7-Prototypen vorgestellt hatten. Bei der Speicherverteilung war NVIDIA® großzügig: Das Basismodell RTX™ 5070 verfügt über 12 GB GDDR7 auf einem 192-bit -Bus, während die beiden RTX™ 5070 Ti and RTX™ 5080 über 16 GB GDDR7 auf einem 256-bit -Bus verfügen. Am oberen Ende kommt das Flaggschiff RTX™ 5090 mit einem massiven 32 GB GDDR7 auf einem 512-bit -Bus.

Experten sagten ursprünglich voraus, dass der maximale Durchsatz dieser Speicherkonfiguration 1,5 Tbps betragen würde. Die Realität hat diese Erwartungen jedoch übertroffen, achieving a throughput of 1,7 Tbps. Diese dramatische Verbesserung kommt in erster Linie den KI-Verarbeitungsfähigkeiten des Grafikprozessors zugute und weniger der Spieleleistung. Die Kombination aus hoher Kapazität und schnellem Speicher der neuen Generation ist besonders wertvoll für große Sprachmodelle und generative neuronale Netze.

Technologien

Für Gamer

Echtzeit-Raytracing hat sich zu einer der revolutionärsten GPU-Technologien entwickelt und markiert den Beginn der RTX-Reihe. Für viele Verbraucher war diese Funktion ein Schlüsselfaktor für ihre Kaufentscheidung. Bei den Karten der RTX™ 50-Serie könnte DLSS (Deep Learning Super Sampling) Version 4 eine ebenso wichtige Rolle spielen. Diese Technologie steigert die GPU-Leistung in Spielen durch ihren Hybrid-Frame-Rendering-Ansatz erheblich.

Wenn DLSS aktiviert ist, werden einige Frames in Echtzeit mithilfe von KI generiert, anstatt jedes Frame auf herkömmliche Weise zu rendern. Während frühe Versionen dieser Technologie lediglich Frames auf höhere Auflösungen hochskalieren konnten, wurde mit DLSS 3 eine fortschrittlichere Fähigkeit eingeführt: Für jedes konventionell gerenderte Frame kann ein zusätzliches, von der KI erstelltes Frame generiert werden.

DLSS 4 erzeugt drei KI-gesteuerte Frames für jedes herkömmlich gerenderte Frame. This significantly increases the frame per second (FPS) without putting heavy load on the GPU. Die KI analysiert die Objekt- und Szenenbewegungen, um sicherzustellen, dass die generierten Frames den konventionell gerenderten Frames sehr nahe kommen.

Dies wirft eine wichtige Frage auf: Wie gehen wir mit der Eingabeverzögerung um? Da die Frame-Generierung Zeit in Anspruch nimmt, verlängert jede Iteration die Reaktionszeit. Ein flüssiges Bild mit langsamer Reaktion auf Spieleraktionen kann das Spielerlebnis stark beeinträchtigen. To address this, NVIDIA® has improved their Reflex 2 technology alongside DLSS to minimize latency.

Deshalb wurde Frame Warp in das System integriert. Diese Technologie reduziert die Latenzzeit im Spiel, indem die gerenderten Bilder kurz vor der Anzeige mit den neuesten Mauseingaben aktualisiert werden. Sie verbessert sowohl den Multiplayer-Wettbewerb als auch die Reaktionsfähigkeit im Einzelspielermodus.

Für die Ersteller von Inhalten

Die RTX™ 50-Serie ist nicht nur für Spiele geeignet. Ersteller von Videoinhalten werden in diesen neuen GPUs einen erheblichen Nutzen sehen. Das Flaggschiff RTX™ 5090 ist mit 3 Encodern und 2 Decodern ausgestattet, im Vergleich zu 2 Encodern und 1 Decoder bei der RTX™ 4090. Diese Komponenten wurden durch die Zusammenarbeit mit führenden Unternehmen der Branche verbessert: Adobe, Blackmagic Design, ByteDance und Wondershare. As a result, the RTX™ 5090 renders video 60% faster than the RTX™ 4090 and four times faster than the RTX™ 3090.

Neben den reinen Geschwindigkeitsverbesserungen wurde auch die Qualität verbessert. The 9th generation NVENC encoder delivers 5% better quality in HEVC and AV1 tasks. The AV1 Ultra Quality mode achieves better data compression while maintaining image quality, reducing file sizes by 5%. Dies bedeutet eine schnellere Videowiedergabe auf der RTX™ 5090 und eine Verkürzung der Zeit zwischen Bearbeitung und Produktion.

Fazit

Rückblickend auf sechs Monate erwiesen sich die Vorhersagen und Erwartungen der Experten als zu optimistisch. Je näher der Veröffentlichungstermin rückte, desto deutlicher wurde, dass die neuen GPUs mehr als nur zusätzliche Recheneinheiten bieten würden. The key innovation would be new optimization and AI technologies enhancing existing frame rendering systems.

Auf der CES 2025 wurde während der Präsentation der GPU 50-Serie eine neue KI-Ära vorgestellt. Diese Vision beschreibt eine Welt, in der digitale Assistenten und Roboter komplexe Aufgaben übernehmen. Den Kern bildet ein Ökosystem aus Supercomputern für das KI-Training, erschwinglichen Inferenzbeschleunigern für Verbrauchergeräte und vielseitiger Software, die sowohl lokal als auch in der Cloud arbeitet. Auch wenn das volle Ausmaß dieser Zukunft noch ungewiss ist, so ist doch eines klar: Wir stehen an der Schwelle von der Science-Fiction zur Realität.

LeaderGPU remains committed to providing reliable access to these cutting-edge technologies. Order your first GPU server today and begin transforming your ideas into reality.

Siehe auch:

Vor- und Nachteile der gemeinsamen Nutzung von GPUs

Thu, 23 Jan 2025 13:24:12 +0100

Das Mooresche Gesetz hat seit fast einem halben Jahrhundert seine Gültigkeit behalten. In Prozessorchips werden immer mehr Transistoren verbaut, und die Technologien werden täglich weiterentwickelt. So wie sich die Technologie weiterentwickelt, so entwickelt sich auch unsere Herangehensweise an die Datenverarbeitung. Das Aufkommen bestimmter Computeraufgaben hat die Hardwareentwicklung erheblich beeinflusst. So sind beispielsweise Geräte, die ursprünglich für die Grafikverarbeitung entwickelt wurden, heute wichtige und erschwingliche Werkzeuge für moderne neuronale Netze.

Auch die Verwaltung von Computerressourcen hat sich verändert. Massendienste verwenden heute nur noch selten Großrechner, wie sie es in den 1970er und 80er Jahren taten. Stattdessen bevorzugen sie Cloud-Dienste oder bauen ihre eigene Infrastruktur auf. Diese Verschiebung hat die Kundenanforderungen verändert, wobei der Schwerpunkt auf einer schnellen, bedarfsgerechten Skalierung und einer maximalen Nutzung der zugewiesenen Computerressourcen liegt.

Virtualisierungs- und Containerisierungstechnologien sind als Lösungen entstanden. Anwendungen werden nun in Containern mit allen erforderlichen Bibliotheken verpackt, was die Bereitstellung und Skalierung vereinfacht. Die manuelle Verwaltung wurde jedoch unpraktisch, als die Zahl der Container in die Tausende stieg. Spezialisierte Orchestratoren wie Kubernetes sorgen nun für eine effektive Verwaltung und Skalierung. Diese Tools sind ein wesentlicher Bestandteil jeder modernen IT-Infrastruktur geworden.

Server-Virtualisierung

Gleichzeitig wurden Virtualisierungstechnologien entwickelt, die die Schaffung von isolierten Umgebungen innerhalb eines einzigen physischen Servers ermöglichen. Virtuelle Maschinen verhalten sich identisch zu normalen physischen Servern und ermöglichen die Verwendung von Standard-Verwaltungstools. Je nach Hypervisor ist oft eine spezielle API enthalten, die die Automatisierung von Routineabläufen erleichtert.

Diese Flexibilität geht jedoch mit einer geringeren Sicherheit einher. Angreifer konzentrieren sich nicht mehr auf einzelne virtuelle Maschinen, sondern nutzen die Schwachstellen von Hypervisoren aus. Wenn sie die Kontrolle über einen Hypervisor erlangen, können Angreifer nach Belieben auf alle zugehörigen virtuellen Maschinen zugreifen. Trotz laufender Sicherheitsverbesserungen bleiben moderne Hypervisoren attraktive Ziele.

Die herkömmliche Virtualisierung befasst sich mit zwei Hauptproblemen. Erstens: Sie gewährleistet die Isolierung der virtuellen Maschinen voneinander. Bare-Metal-Lösungen umgehen dieses Problem, da die Kunden ganze physische Server unter ihrer Kontrolle mieten. Bei virtuellen Maschinen erfolgt die Isolierung jedoch softwarebasiert auf der Hypervisor-Ebene. Ein Code-Fehler oder ein zufälliger Bug kann diese Isolierung beeinträchtigen, so dass die Gefahr besteht, dass Daten verloren gehen oder beschädigt werden.

Das zweite Problem betrifft die Ressourcenverwaltung. Es ist zwar möglich, die Ressourcenzuweisung für bestimmte virtuelle Maschinen zu garantieren, aber die Verwaltung zahlreicher Maschinen stellt ein Dilemma dar. Die Ressourcen können unzureichend genutzt werden, was zu einer geringeren Anzahl virtueller Maschinen pro physischem Server führt. Dieses Szenario ist für die Infrastruktur unrentabel und führt unweigerlich zu Preissteigerungen.

Alternativ dazu können Sie automatische Ressourcenverwaltungsmechanismen nutzen. Obwohl einer virtuellen Maschine bestimmte deklarierte Eigenschaften zugewiesen werden, wird in Wirklichkeit nur das erforderliche Minimum innerhalb dieser Grenzen bereitgestellt. Benötigt die Maschine mehr Prozessorzeit oder Arbeitsspeicher, versucht der Hypervisor, dies bereitzustellen, kann es aber nicht garantieren. Diese Situation ist vergleichbar mit der Überbuchung von Flugzeugen, bei der die Fluggesellschaften mehr Tickets verkaufen, als Plätze vorhanden sind.

Die Logik ist identisch. Wenn die Statistik zeigt, dass etwa 10 % der Passagiere nicht pünktlich zu ihrem Flug erscheinen, können die Fluggesellschaften mit minimalem Risiko 10 % mehr Tickets verkaufen. Wenn alle Passagiere kommen, werden einige nicht an Bord passen. Die Fluggesellschaft wird mit geringfügigen Konsequenzen in Form von Ausgleichszahlungen rechnen müssen, aber wahrscheinlich wird sie diese Praxis fortsetzen.

Viele Infrastrukturanbieter wenden eine ähnliche Strategie an. Einige sind transparent und geben an, dass sie die ständige Verfügbarkeit von Rechenressourcen nicht garantieren können, aber deutlich niedrigere Preise anbieten. Andere setzen ähnliche Mechanismen ein, ohne dies bekannt zu geben. Sie setzen darauf, dass nicht alle Kunden ihre Serverressourcen ständig zu 100 % ausnutzen werden, und selbst wenn es einige tun, werden sie in der Minderheit sein. In der Zwischenzeit erwirtschaften die ungenutzten Ressourcen Gewinn.

In diesem Zusammenhang haben Bare-Metal-Lösungen einen Vorteil. Sie garantieren, dass die zugewiesenen Ressourcen vollständig vom Kunden verwaltet und nicht mit anderen Nutzern des Infrastrukturanbieters geteilt werden. Dadurch werden Szenarien vermieden, in denen eine hohe Belastung durch den Benutzer eines benachbarten Servers die Leistung negativ beeinflusst.

GPU-Virtualisierung

Die klassische Virtualisierung steht unweigerlich vor der Herausforderung, physische Geräte zu emulieren. Um die Overhead-Kosten zu senken, wurden spezielle Technologien entwickelt, die es virtuellen Maschinen ermöglichen, direkt auf die physischen Geräte des Servers zuzugreifen. Dieser Ansatz funktioniert in vielen Fällen gut, aber bei der Anwendung auf Grafikprozessoren stößt er sofort an seine Grenzen. Wenn ein Server beispielsweise 8 Grafikprozessoren installiert hat, können nur 8 virtuelle Maschinen darauf zugreifen.

Um diese Einschränkung zu überwinden, wurde die vGPU-Technologie erfunden. Sie unterteilt eine GPU in mehrere logische GPUs, die dann virtuellen Maschinen zugewiesen werden können. Auf diese Weise kann jede virtuelle Maschine ihr "Stück vom Kuchen" bekommen, und ihre Gesamtzahl ist nicht mehr durch die Anzahl der im Server installierten Grafikkarten begrenzt.

Virtuelle GPUs werden am häufigsten beim Aufbau von VDI (Virtual Desktop Infrastructure) in Bereichen eingesetzt, in denen virtuelle Maschinen 3D-Beschleunigung benötigen. Ein virtueller Arbeitsplatz für einen Designer oder Planer beinhaltet beispielsweise typischerweise Grafikverarbeitung. Die meisten Anwendungen in diesen Bereichen führen Berechnungen sowohl auf dem zentralen Prozessor als auch auf dem Grafikprozessor durch. Dieser hybride Ansatz erhöht die Produktivität erheblich und gewährleistet eine optimale Nutzung der verfügbaren Rechenressourcen.

Diese Technologie hat jedoch mehrere Nachteile. Sie wird nicht von allen GPUs unterstützt und ist nur im Serverbereich verfügbar. Die Unterstützung hängt auch von der installierten Version des Betriebssystems und des GPU-Treibers ab. vGPU hat einen separaten Lizenzierungsmechanismus, der die Betriebskosten erheblich erhöht. Außerdem können die Softwarekomponenten potenziell als Angriffsvektoren dienen.

Vor kurzem wurden Informationen über acht Schwachstellen veröffentlicht, die alle Benutzer von Nvidia-GPUs betreffen. Sechs Schwachstellen wurden in GPU-Treibern und zwei in der vGPU-Software gefunden. Diese Probleme wurden schnell behoben, aber sie erinnern daran, dass die Isolationsmechanismen in solchen Systemen nicht fehlerfrei sind. Ständige Überwachung und die rechtzeitige Installation von Updates bleiben die wichtigsten Maßnahmen zur Gewährleistung der Sicherheit.

Beim Aufbau einer Infrastruktur zur Verarbeitung vertraulicher und sensibler Benutzerdaten wird jede Virtualisierung zu einem potenziellen Risikofaktor. In solchen Fällen kann ein Bare-Metal-Ansatz bessere Qualität und Sicherheit bieten.

Schlussfolgerung

Der Aufbau einer Computerinfrastruktur erfordert immer eine Risikobewertung. Zu den wichtigsten Fragen, die dabei zu berücksichtigen sind, gehören: Sind die Kundendaten sicher geschützt? Schaffen die gewählten Technologien zusätzliche Angriffsvektoren? Wie können potenzielle Schwachstellen isoliert und beseitigt werden? Die Beantwortung dieser Fragen hilft dabei, fundierte Entscheidungen zu treffen und sich vor künftigen Problemen zu schützen.

Bei LeaderGPU sind wir zu einer klaren Schlussfolgerung gelangt: Derzeit ist die Bare-Metal-Technologie überlegen, wenn es darum geht, die Sicherheit der Benutzerdaten zu gewährleisten und gleichzeitig eine hervorragende Grundlage für den Aufbau einer Bare-Metal-Cloud zu bieten. Mit diesem Ansatz können unsere Kunden ihre Flexibilität beibehalten, ohne die mit der GPU-Virtualisierung verbundenen zusätzlichen Risiken auf sich zu nehmen.

Siehe auch:

Was ist Wissensdestillation?

Thu, 23 Jan 2025 13:21:29 +0100

Große Sprachmodelle (Large Language Models, LLMs) sind durch ihre einzigartigen Fähigkeiten zu einem festen Bestandteil unseres Lebens geworden. Sie verstehen den Kontext und erstellen darauf aufbauend kohärente, umfassende Texte. Sie können jede Sprache verarbeiten und in jeder Sprache reagieren und dabei die kulturellen Nuancen jeder Sprache berücksichtigen.

LLMs sind hervorragend in der Lage, komplexe Probleme zu lösen, zu programmieren, Konversationen zu führen und vieles mehr. Diese Vielseitigkeit ergibt sich aus der Verarbeitung großer Mengen von Trainingsdaten, daher der Begriff "groß". Diese Modelle können Dutzende oder Hunderte von Milliarden von Parametern enthalten, was sie für den täglichen Gebrauch sehr ressourcenintensiv macht.

Das Training ist der anspruchsvollste Prozess. Neuronale Netzmodelle lernen, indem sie riesige Datensätze verarbeiten und ihre internen "Gewichte" anpassen, um stabile Verbindungen zwischen den Neuronen zu bilden. Diese Verbindungen speichern Wissen, das das trainierte neuronale Netz später auf Endgeräten verwenden kann.

Den meisten Endgeräten fehlt jedoch die nötige Rechenleistung, um diese Modelle auszuführen. Um beispielsweise die Vollversion von Llama 2 (70B Parameter) auszuführen, ist ein Grafikprozessor mit 48 GB Videospeicher erforderlich - Hardware, die nur wenige Nutzer zu Hause haben, geschweige denn auf mobilen Geräten.

Daher arbeiten die meisten modernen neuronalen Netze in einer Cloud-Infrastruktur und nicht auf tragbaren Geräten, die über APIs auf sie zugreifen. Dennoch machen die Gerätehersteller in zweierlei Hinsicht Fortschritte: Sie statten ihre Geräte mit spezialisierten Recheneinheiten wie NPUs aus und entwickeln Methoden zur Verbesserung der Leistung kompakter neuronaler Netzwerkmodelle.

Verkleinerung der Größe

Überflüssiges abschneiden

Die Quantisierung ist die erste und wirksamste Methode zur Reduzierung der Größe eines neuronalen Netzes. Die Gewichte neuronaler Netze verwenden normalerweise 32-Bit-Gleitkommazahlen, aber wir können sie verkleinern, indem wir dieses Format ändern. Die Verwendung von 8-Bit-Werten (oder in manchen Fällen sogar von binären Einsen) kann die Größe des Netzwerks um das Zehnfache reduzieren, was jedoch die Genauigkeit der Antworten erheblich verringert.

Pruning ist ein weiterer Ansatz, bei dem unwichtige Verbindungen im neuronalen Netz entfernt werden. Dieser Prozess funktioniert sowohl während des Trainings als auch bei abgeschlossenen Netzen. Beim Pruning können nicht nur Verbindungen, sondern auch Neuronen oder ganze Schichten entfernt werden. Diese Reduzierung der Parameter und Verbindungen führt zu einem geringeren Speicherbedarf.

Die Matrix- oder Tensorzerlegung ist die dritte gängige Technik zur Größenreduzierung. Durch die Zerlegung einer großen Matrix in ein Produkt aus drei kleineren Matrizen werden die Gesamtparameter bei gleichbleibender Qualität reduziert. Dadurch kann die Größe des Netzes um das Dutzendfache verringert werden. Die Tensoredekomposition bietet sogar noch bessere Ergebnisse, erfordert jedoch mehr Hyperparameter.

Während diese Methoden die Größe effektiv reduzieren, stehen sie alle vor dem Problem des Qualitätsverlustes. Große komprimierte Modelle übertreffen ihre kleineren, nicht komprimierten Gegenstücke, aber jede Komprimierung birgt das Risiko, die Genauigkeit der Antworten zu verringern. Die Wissensdestillation stellt einen interessanten Versuch dar, Qualität und Größe in Einklang zu bringen.

Lassen Sie es uns gemeinsam versuchen

Die Wissensdestillation lässt sich am besten durch die Analogie zwischen einem Schüler und einem Lehrer erklären. Während die Schüler lernen, lehren die Lehrer und aktualisieren auch ständig ihr vorhandenes Wissen. Wenn beide mit neuem Wissen konfrontiert werden, hat der Lehrer einen Vorteil: Er kann auf sein breites Wissen aus anderen Bereichen zurückgreifen, während dem Schüler diese Grundlage noch fehlt.

Dieses Prinzip gilt auch für neuronale Netze. Wenn zwei neuronale Netze desselben Typs, aber unterschiedlicher Größe, mit identischen Daten trainiert werden, schneidet das größere Netz in der Regel besser ab. Seine größere Kapazität an "Wissen" ermöglicht genauere Antworten als sein kleineres Gegenstück. Daraus ergibt sich eine interessante Möglichkeit: Warum trainiert man das kleinere Netz nicht nur mit dem Datensatz, sondern auch mit den genaueren Ergebnissen des größeren Netzes?

Dieser Prozess ist die Wissensdestillation: eine Form des überwachten Lernens, bei der ein kleineres Modell lernt, die Vorhersagen eines größeren Modells zu replizieren. Diese Technik hilft zwar, den Qualitätsverlust auszugleichen, der durch die Verkleinerung des neuronalen Netzes entsteht, erfordert aber zusätzliche Rechenressourcen und Trainingszeit.

Software und Logik

Nachdem nun die theoretischen Grundlagen geklärt sind, wollen wir den Prozess aus technischer Sicht untersuchen. Wir beginnen mit Software-Tools, die Sie durch die Phasen des Trainings und der Wissensdestillation führen können.

Python bietet zusammen mit der TorchTune-Bibliothek aus dem PyTorch-Ökosystem den einfachsten Ansatz für die Untersuchung und Feinabstimmung großer Sprachmodelle. So funktioniert die Anwendung:

Es werden zwei Modelle geladen: ein vollständiges Modell (Lehrer) und ein reduziertes Modell (Schüler). Während jeder Trainingsiteration erzeugt das Lehrermodell Hochtemperaturvorhersagen, während das Schülermodell den Datensatz verarbeitet, um seine eigenen Vorhersagen zu treffen.

Die rohen Ausgabewerte (Logits) beider Modelle werden anhand einer Verlustfunktion (ein numerisches Maß dafür, wie stark eine Vorhersage vom richtigen Wert abweicht) bewertet. Die Gewichtungsanpassungen werden dann durch Backpropagation auf das Studentenmodell angewendet. Dadurch kann das kleinere Modell lernen und die Vorhersagen des Lehrermodells replizieren.

Die wichtigste Konfigurationsdatei im Anwendungscode wird als Rezept bezeichnet. In dieser Datei werden alle Destillationsparameter und -einstellungen gespeichert, so dass die Experimente reproduzierbar sind und die Forscher verfolgen können, wie die verschiedenen Parameter das Endergebnis beeinflussen.

Bei der Auswahl der Parameterwerte und der Anzahl der Iterationen ist die Wahrung des Gleichgewichts entscheidend. Ein Modell, das zu stark destilliert wurde, kann seine Fähigkeit verlieren, subtile Details und den Kontext zu erkennen, und zu schablonenhaften Antworten übergehen. Auch wenn ein perfektes Gleichgewicht kaum zu erreichen ist, kann eine sorgfältige Überwachung des Destillationsprozesses die Vorhersagequalität selbst bescheidener neuronaler Netzwerkmodelle erheblich verbessern.

Auch während des Trainingsprozesses lohnt es sich, auf die Überwachung zu achten. So können Probleme rechtzeitig erkannt und umgehend korrigiert werden. Hierfür können Sie das TensorBoard-Tool verwenden. Es lässt sich nahtlos in PyTorch-Projekte integrieren und ermöglicht die visuelle Auswertung vieler Metriken, wie Genauigkeit und Verluste. Außerdem können Sie damit einen Modellgraphen erstellen, die Speichernutzung und die Ausführungszeit von Operationen verfolgen.

Schlussfolgerung

Wissensdestillation ist eine effektive Methode zur Optimierung neuronaler Netze, um kompakte Modelle zu verbessern. Sie funktioniert am besten, wenn ein Gleichgewicht zwischen Leistung und Antwortqualität wichtig ist.

Obwohl die Wissensdestillation eine sorgfältige Überwachung erfordert, können ihre Ergebnisse bemerkenswert sein. Die Modelle werden bei gleichbleibender Vorhersagequalität wesentlich kleiner und erzielen mit weniger Rechenressourcen eine bessere Leistung.

Bei einer guten Planung mit geeigneten Parametern ist die Wissensdestillation ein wichtiges Instrument zur Erstellung kompakter neuronaler Netze ohne Qualitätseinbußen.

Siehe auch:

AudioCraft von MetaAI: Musik nach Beschreibung erstellen

Wed, 22 Jan 2025 15:51:35 +0100

Moderne generative neuronale Netze werden immer intelligenter. Sie schreiben Geschichten, führen Gespräche mit Menschen und erstellen ultra-realistische Bilder. Jetzt können sie auch einfache Musiktitel produzieren, ohne dass dafür professionelle Künstler benötigt werden. Diese Zukunft ist heute schon Realität. Das war zu erwarten, denn musikalische Harmonien und Rhythmen beruhen auf mathematischen Prinzipien.

Meta hat sein Engagement für die Welt der Open-Source-Software unter Beweis gestellt. Sie haben drei neuronale Netzwerkmodelle veröffentlicht, die die Erstellung von Klängen und Musik aus Textbeschreibungen ermöglichen:

MusicGen - erzeugt Musik aus Text.
AudioGen - erzeugt Audio aus Text.
EnCodec - Hochwertiger neuronaler Audiokompressor.

MusicGen wurde auf 20.000 Stunden Musik trainiert. Sie können es lokal über dedizierte LeaderGPU-Server als Plattform nutzen.

Standard-Installation

Aktualisieren Sie das Paket-Cache-Repository:

sudo apt update && sudo apt -y upgrade

Installieren Sie den Python-Paketmanager, pip, und die ffmpeg-Bibliotheken:

sudo apt -y install python3-pip ffmpeg

Installieren Sie Torch 2.0 oder eine neuere Version mit pip:

pip install 'torch>=2.0'

Mit dem folgenden Befehl werden audiocraft und alle erforderlichen Abhängigkeiten automatisch installiert:

pip install -U audiocraft

Lassen Sie uns eine einfache Python-Anwendung schreiben, die das große vortrainierte MusicGen-Modell mit 3,3B Parametern verwendet:

nano generate.py

from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained("facebook/musicgen-large")
model.set_generation_params(duration=30)  # generate a 30 seconds sample.
descriptions = ["rock solo"]
wav = model.generate(descriptions)  # generates sample.
for idx, one_wav in enumerate(wav):
    # Will save under {idx}.wav, with loudness normalization at -14 db LUFS.
    audio_write(f'{idx}', one_wav.cpu(), model.sample_rate, strategy="loudness")

Führen Sie die erstellte Anwendung aus:

python3 generate.py

Nach ein paar Sekunden erscheint die erzeugte Datei (0.wav) im Verzeichnis.

Kaffee Vampir 3

Klonen Sie ein Projekt-Repository:

git clone https://github.com/CoffeeVampir3/audiocraft-webui.git

Öffnen Sie das geklonte Verzeichnis:

cd audiocraft-webui

Führen Sie den Befehl aus, der Ihr System vorbereitet und alle erforderlichen Pakete installiert:

pip install -r requirements.txt

Starten Sie dann den Coffee Vampire 3 Server mit dem folgenden Befehl:

python3 webui.py

Coffee Vampire 3 verwendet Flask als Framework. Standardmäßig läuft es auf localhost mit Port 5000. Wenn Sie einen Fernzugriff wünschen, verwenden Sie bitte die Portweiterleitung in Ihrem SSH-Client. Ansonsten können Sie eine VPN-Verbindung zum Server organisieren.

Aber Achtung! Dies ist eine potenziell gefährliche Aktion; die Verwendung erfolgt auf eigene Gefahr:

nano webui.py

Scrollen Sie bis zum Ende und ersetzen Sie socketio.run(app) durch socketio.run(app, host=’0.0.0.0’, port=5000)

Speichern Sie die Datei und starten Sie den Server mit dem obigen Befehl. Dies ermöglicht den Zugriff auf den Server aus dem öffentlichen Internet ohne jegliche Authentifizierung.

Vergessen Sie nicht disable AdBlock software, da dies den Musik-Player auf der rechten Seite der Webseite blockieren kann. Sie können beginnen, indem Sie die Eingabeaufforderung eingeben und mit der Schaltfläche Submit bestätigen:

TTS Generation WebUI

Schritt 1. Treiber

Aktualisieren Sie das Paket-Cache-Repository:

sudo apt update && sudo apt -y upgrade

Installieren Sie Nvidia-Treiber mit dem automatischen Installationsprogramm oder mit unserer Anleitung Nvidia-Treiber unter Linux installieren:

sudo ubuntu-drivers autoinstall

Starten Sie den Server neu:

sudo shutdown -r now

Schritt 2. Docker

Der nächste Schritt ist die Installation von Docker. Lassen Sie uns einige Pakete installieren, die dem Docker-Repository hinzugefügt werden müssen:

sudo apt -y install apt-transport-https curl gnupg-agent ca-certificates software-properties-common

Laden Sie den Docker-GPG-Schlüssel herunter und speichern Sie ihn:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Fügen Sie das Repository hinzu:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Installieren Sie Docker CE (Community Edition) mit CLI und die containerd Laufzeitumgebung:

sudo apt -y install docker-ce docker-ce-cli containerd.io

Fügen Sie den aktuellen Benutzer zur Docker-Gruppe hinzu:

sudo usermod -aG docker $USER

Übernehmen Sie die Änderungen ohne das Ab- und Anmeldeverfahren:

newgrp docker

Schritt 3. GPU-Passthrough

Aktivieren wir NVIDIA® GPUs Passthrough in Docker. Der folgende Befehl liest die aktuelle Betriebssystemversion in die Distributionsvariable, die wir im nächsten Schritt verwenden können:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)

Laden Sie den GPG-Schlüssel des Nvidia-Repositorys herunter und speichern Sie ihn:

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -

Laden Sie die Liste der Nvidia-Repos herunter und speichern Sie sie zur Verwendung im Standard-APT-Paketmanager:

curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

Aktualisieren Sie das Paket-Cache-Repository und installieren Sie das GPU-Passthrough-Toolkit:

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

Starten Sie den Docker-Daemon neu:

sudo systemctl restart docker

Schritt 4. WebUI

Laden Sie das Repository-Archiv herunter:

wget https://github.com/rsxdalv/tts-generation-webui/archive/refs/heads/main.zip

Entpacken Sie es:

unzip main.zip

Öffnen Sie das Verzeichnis des Projekts:

cd tts-generation-webui-main

Beginnen Sie mit der Erstellung des Images:

docker build -t rsxdalv/tts-generation-webui .

Führen Sie den erstellten Container aus:

docker compose up -d

Öffnen Sie nun http://[server_ip]:7860, geben Sie Ihre Eingabeaufforderung ein, wählen Sie das gewünschte Modell aus und klicken Sie auf die Schaltfläche Generate:

Das System lädt das ausgewählte Modell automatisch während der ersten Generation herunter. Viel Spaß!

Siehe auch:

Wie man die LangFlow-Anwendung überwacht

Wed, 22 Jan 2025 15:14:55 +0100

In unserem Artikel Low-Code-KI-App-Builder Langflow haben wir untersucht, wie man mit der visuellen Programmierumgebung dieses Low-Code-KI-App-Builders loslegen kann. Damit kann jeder, auch ohne Programmierkenntnisse, Anwendungen erstellen, die auf großen neuronalen Netzwerkmodellen basieren. Dabei kann es sich um KI-Chatbots oder Anwendungen zur Dokumentenverarbeitung handeln, die Inhalte analysieren und zusammenfassen können.

Langflow verwendet einen Bausteinansatz, bei dem die Benutzer vorgefertigte Komponenten miteinander verbinden, um ihre gewünschte Anwendung zu erstellen. Dabei treten jedoch häufig zwei zentrale Herausforderungen auf: die Fehlerbehebung bei unerwartetem Verhalten neuronaler Netze und das Kostenmanagement. Neuronale Netze erfordern beträchtliche Rechenressourcen, so dass es wichtig ist, die Infrastrukturkosten zu überwachen und vorherzusagen.

LangWatch geht beide Herausforderungen an. Dieses spezielle Tool hilft den Entwicklern von Langflow bei der Überwachung von Benutzeranfragen, der Verfolgung von Kosten und der Erkennung von Anomalien, z. B. wenn Anwendungen auf unbeabsichtigte Weise verwendet werden.

Dieses Tool wurde ursprünglich als Dienst entwickelt, kann aber auf jedem Server, auch lokal, eingesetzt werden. Es lässt sich mit den meisten LLM-Anbietern integrieren, egal ob Cloud-basiert oder vor Ort. Da LangWatch ein Open-Source-Tool ist, kann es an fast jedes Projekt angepasst werden, indem neue Funktionen hinzugefügt oder mit internen Systemen verbunden werden.

Mit LangWatch können Sie Warnungen einrichten, wenn bestimmte Metriken definierte Schwellenwerte überschreiten. So können Sie unerwartete Kostensteigerungen bei Anfragen oder ungewöhnliche Verzögerungen bei der Beantwortung schnell erkennen. Eine frühzeitige Erkennung hilft, ungeplante Ausgaben und potenzielle Service-Angriffe zu verhindern.

Für Forscher, die sich mit neuronalen Netzen beschäftigen, ermöglicht diese Anwendung sowohl die Überwachung als auch die Optimierung gängiger Benutzeranfragen. Außerdem bietet sie Werkzeuge zur Bewertung der Antwortqualität des Modells und zur Vornahme von Anpassungen, wenn dies erforderlich ist.

Schnellstart

System vorbereiten

Wie bei Langflow ist der einfachste Weg, die Anwendung in einem Docker-Container auszuführen. Bevor Sie LangWatch installieren, müssen Sie die Docker Engine auf Ihrem Server installieren. Aktualisieren Sie zunächst Ihren Paket-Cache und die Pakete auf ihre neuesten Versionen:

sudo apt update && sudo apt -y upgrade

Installieren Sie zusätzliche Pakete, die von Docker benötigt werden:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Laden Sie den GPG-Schlüssel herunter, um das offizielle Docker-Repository hinzuzufügen:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Fügen Sie das Repository zur APT hinzu, indem Sie den Schlüssel verwenden, den Sie zuvor heruntergeladen und installiert haben:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisieren Sie die Paketliste:

sudo apt update

Um sicherzustellen, dass Docker aus dem neu hinzugefügten Repository und nicht aus dem System-Repository installiert wird, können Sie den folgenden Befehl ausführen:

apt-cache policy docker-ce

Docker-Engine installieren:

sudo apt install docker-ce

Überprüfen Sie, ob Docker erfolgreich installiert wurde und der entsprechende Daemon läuft und den Status active (running) hat:

sudo systemctl status docker

● docker.service - Docker Application Container Engine
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
    Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
      Docs: https://docs.docker.com
  Main PID: 1842 (dockerd)
     Tasks: 29
    Memory: 1.8G
       CPU: 3min 15.715s
    CGroup: /system.slice/docker.service

Erstellen und Ausführen

Wenn die Docker-Engine installiert ist und läuft, können Sie das LangWatch-Anwendungs-Repository herunterladen:

git clone https://github.com/langwatch/langwatch

Die Anwendung enthält eine Beispielkonfigurationsdatei mit Umgebungsvariablen. Kopieren Sie diese Datei, damit das Image-Build-Dienstprogramm sie verarbeiten kann:

cp langwatch/.env.example langwatch/.env

Jetzt sind Sie bereit für den ersten Start:

sudo docker compose up --build

Das System wird einen Moment brauchen, um alle notwendigen Containerschichten für LangWatch herunterzuladen. Sobald dies abgeschlossen ist, wird eine Konsolenmeldung angezeigt, die besagt, dass die Anwendung unter folgender Adresse verfügbar ist:

http://[LeaderGPU_IP_address]:3000

Navigieren Sie zu dieser Seite in Ihrem Browser, wo Sie aufgefordert werden, ein Benutzerkonto zu erstellen:

Im Gegensatz zu Langflow ist bei diesem System die Authentifizierung standardmäßig aktiviert. Nachdem Sie sich angemeldet haben, müssen Sie das System so konfigurieren, dass es Daten von Ihrem Langflow-Server sammelt.

Langflow-Integration

LangWatch benötigt eine Datenquelle, um zu funktionieren. Der Server lauscht auf Port 3000 und verwendet eine RESTful API, die eingehende Daten durch einen automatisch generierten API-Schlüssel authentifiziert.

Um die Datenübertragung zu ermöglichen, müssen Sie zwei Variablen in den Langflow-Konfigurationsdateien setzen: LANGWATCH_ENDPOINT und LANGWATCH_API_KEY. Stellen Sie zunächst eine SSH-Verbindung zu Ihrem Langflow-Server her (der während dieses Vorgangs offline sein sollte).

Wechseln Sie in das Verzeichnis mit der Beispielkonfiguration für Docker:

cd langflow/docker_example

Öffnen Sie die Konfigurationsdatei zur Bearbeitung:

nano docker-compose.yml

Fügen Sie im Abschnitt "Umgebung:" die folgenden Variablen hinzu (ohne Klammern [] oder Anführungszeichen):

- LANGWATCH_API_KEY= [YOUR_API_KEY]
- LANGWATCH_ENDPOINT=http://[IP_ADDRESS]:3000

Die YML-Datei erfordert eine bestimmte Formatierung. Befolgen Sie diese beiden wichtigen Regeln:

Verwenden Sie Leerzeichen (2 oder 4) für die Einrückung, niemals Tabulatoren.
Behalten Sie die richtige hierarchische Struktur mit konsistenter Einrückung bei.

Speichern Sie die Datei mit Ctrl + O und beenden Sie den Editor mit Ctrl + X. Langflow ist nun startbereit:

sudo docker compose up

Überprüfen Sie nach dem Start, ob alles ordnungsgemäß funktioniert. Erstellen Sie ein neues Projekt oder öffnen Sie ein bestehendes und starten Sie einen Dialog über Playground. Langflow sendet automatisch Daten zur Überwachung an LangWatch, die Sie in der Weboberfläche einsehen können.

Im Abschnitt zur Überprüfung der Integration erscheint ein Häkchen auf dem Punkt "Sync your first message". Dies zeigt an, dass die Daten aus Langflow erfolgreich in LangWatch fließen und bestätigt, dass Ihre Einrichtung korrekt ist. Schauen wir uns an, was im Abschnitt Messages erscheint:

Der Abschnitt Nachrichten zeigt die in die Anwendung eingegebenen Daten, die für die Antwortgenerierung verwendeten Parameter und die Antwort des neuronalen Netzes selbst an. Sie können die Antwortqualität bewerten und verschiedene Filter verwenden, um die Daten zu sortieren, selbst bei Hunderten oder Tausenden von Nachrichten.

Nach dieser Ersteinrichtung sollten Sie die Funktionen der Anwendung systematisch erkunden. Im Bereich Evaluations können Sie Algorithmen zur Dialogüberprüfung entweder für die Dialogmoderation oder für die Datenerkennung einrichten, z. B. PII Detection. Diese Funktion prüft Eingaben auf sensible Informationen wie Sozialversicherungsnummern oder Telefonnummern.

Die Anwendung bietet sowohl lokale als auch cloudbasierte Optionen über Anbieter wie Azure oder Cloudflare. Um Cloud-Funktionen zu nutzen, benötigen Sie Konten bei diesen Diensten sowie deren Endpunktadressen und API-Schlüssel. Beachten Sie, dass es sich dabei um Drittanbieter handelt, informieren Sie sich also direkt über deren Servicekosten.

Für lokale Optionen bietet die Anwendung ausgefeilte RAG-Funktionen (Retrieval-augmented generation). Sie können die Genauigkeit und Relevanz der von RAG generierten Inhalte messen und die gesammelten Statistiken nutzen, um das RAG-System für genauere Antworten des neuronalen Netzes zu optimieren.

Siehe auch:

KI-Anwendungsentwickler Langflow mit geringem Programmieraufwand

Wed, 22 Jan 2025 15:11:30 +0100

Die Softwareentwicklung hat sich in den letzten Jahren dramatisch weiterentwickelt. Moderne Programmierer haben jetzt Zugang zu Hunderten von Programmiersprachen und Frameworks. Neben den traditionellen imperativen und deklarativen Ansätzen hat sich eine neue und aufregende Methode zur Erstellung von Anwendungen entwickelt. Dieser innovative Ansatz macht sich die Leistungsfähigkeit neuronaler Netze zunutze und eröffnet den Entwicklern fantastische Möglichkeiten.

Die Menschen haben sich an KI-Assistenten in IDEs gewöhnt, die bei der automatischen Vervollständigung von Code helfen, und an moderne neuronale Netze, die problemlos Code für einfache Python-Spiele erzeugen. Es entstehen jedoch neue hybride Tools, die die Entwicklungslandschaft revolutionieren könnten. Ein solches Werkzeug ist Langflow.

Langflow dient mehreren Zwecken. Für professionelle Entwickler bietet es eine bessere Kontrolle über komplexe Systeme wie neuronale Netze. Für diejenigen, die mit der Programmierung nicht vertraut sind, ermöglicht es die Erstellung einfacher, aber praktischer Anwendungen. Diese Ziele werden mit verschiedenen Mitteln erreicht, auf die wir im Folgenden näher eingehen werden.

Neuronale Netze

Das Konzept eines neuronalen Netzes lässt sich für Benutzer vereinfachen. Stellen Sie sich eine Blackbox vor, die Eingabedaten und Parameter empfängt, die das Endergebnis beeinflussen. Diese Box verarbeitet die Eingaben mit Hilfe komplexer Algorithmen, die oft als "Magie" bezeichnet werden, und erzeugt Ausgabedaten, die dem Benutzer präsentiert werden können.

Das Innenleben dieser Blackbox hängt vom Design des neuronalen Netzes und den Trainingsdaten ab. Man muss sich darüber im Klaren sein, dass Entwickler und Benutzer nie eine 100-prozentige Sicherheit der Ergebnisse erreichen können. Im Gegensatz zur traditionellen Programmierung, bei der 2 + 2 immer gleich 4 ist, kann ein neuronales Netz diese Antwort mit 99 %iger Sicherheit geben, wobei immer eine Fehlerspanne bleibt.

Die Kontrolle über den "Denk"-Prozess eines neuronalen Netzes ist indirekt. Wir können nur bestimmte Parameter einstellen, z. B. die "Temperatur". Dieser Parameter bestimmt, wie kreativ oder eingeschränkt das neuronale Netz bei seinem Ansatz sein kann. Ein niedriger Temperaturwert schränkt das Netz auf einen eher formalen, strukturierten Ansatz für Aufgaben und Lösungen ein. Umgekehrt gewähren hohe Temperaturwerte dem Netz mehr Freiheit, was dazu führen kann, dass es sich auf weniger zuverlässige Fakten stützt oder sogar fiktive Informationen erstellt.

Dieses Beispiel verdeutlicht, wie die Benutzer das Endergebnis beeinflussen können. Für die traditionelle Programmierung stellt diese Ungewissheit eine große Herausforderung dar - Fehler können unerwartet auftreten, und bestimmte Ergebnisse werden unvorhersehbar. Diese Unvorhersehbarkeit ist jedoch in erster Linie ein Problem für Computer und nicht für Menschen, die sich auf unterschiedliche Ergebnisse einstellen und diese interpretieren können.

Wenn die Ausgabe eines neuronalen Netzes für einen Menschen bestimmt ist, ist die spezifische Formulierung, mit der sie beschrieben wird, im Allgemeinen weniger wichtig. Wenn der Kontext gegeben ist, kann der Mensch verschiedene Ergebnisse aus der Sicht der Maschine richtig interpretieren. Während Begriffe wie "positiver Wert", "erzieltes Ergebnis" oder "positive Entscheidung" für einen Menschen in etwa das Gleiche bedeuten könnten, hätte die herkömmliche Programmierung mit dieser Flexibilität ihre Schwierigkeiten. Sie müsste alle möglichen Antwortvarianten berücksichtigen, was nahezu unmöglich ist.

Wird die weitere Verarbeitung hingegen an ein anderes neuronales Netz übergeben, kann dieses das erhaltene Ergebnis richtig verstehen und verarbeiten. Auf dieser Grundlage kann es dann, wie bereits erwähnt, mit einem gewissen Maß an Sicherheit seine eigene Schlussfolgerung ziehen.

Niedriger Code

Die meisten Programmiersprachen erfordern das Schreiben von Code. Programmierer erstellen die Logik für jeden Teil einer Anwendung in ihren Köpfen und beschreiben sie dann mit sprachspezifischen Ausdrücken. Dieser Prozess bildet einen Algorithmus: eine klare Abfolge von Aktionen, die zu einem bestimmten, vorher festgelegten Ergebnis führen. Dies ist eine komplexe Aufgabe, die erhebliche geistige Anstrengung und ein tiefes Verständnis für die Möglichkeiten der Sprache erfordert.

Es besteht jedoch keine Notwendigkeit, das Rad neu zu erfinden. Viele Probleme, mit denen moderne Entwickler konfrontiert sind, wurden bereits auf verschiedene Weise gelöst. Einschlägige Codeschnipsel sind oft auf StackOverflow zu finden. Modernes Programmieren lässt sich mit dem Zusammensetzen eines Ganzen aus Teilen verschiedener Baukästen vergleichen. Das Lego-System bietet ein erfolgreiches Modell, da es verschiedene Teilesätze standardisiert hat, um Kompatibilität zu gewährleisten.

Die Methode der Low-Code-Programmierung folgt einem ähnlichen Prinzip. Verschiedene Codeteile werden so modifiziert, dass sie nahtlos zusammenpassen, und werden den Entwicklern als fertige Blöcke präsentiert. Jeder Block kann Dateneingaben und -ausgaben haben. Die Dokumentation gibt an, welche Aufgabe jeder Blocktyp löst und in welchem Format er Daten annimmt oder ausgibt.

Durch die Verknüpfung dieser Blöcke in einer bestimmten Reihenfolge können Entwickler den Algorithmus einer Anwendung bilden und ihre Funktionslogik klar darstellen. Das vielleicht bekannteste Beispiel für diese Programmiermethode ist die Schildkrötengrafikmethode, die häufig in der Ausbildung verwendet wird, um Programmierkonzepte einzuführen und algorithmisches Denken zu entwickeln.

Das Wesen dieser Methode ist einfach: Sie zeichnet Bilder auf dem Bildschirm mit Hilfe einer virtuellen Schildkröte, die eine Spur hinterlässt, während sie über die Leinwand krabbelt. Mithilfe von vorgefertigten Blöcken, wie z. B. dem Bewegen einer bestimmten Anzahl von Pixeln, dem Drehen in bestimmten Winkeln oder dem Heben und Senken des Stifts, können Entwickler Programme erstellen, die ihre gewünschten Bilder zeichnen. Die Erstellung von Anwendungen mit einem Low-Code-Konstruktor ähnelt der Schildkrötengrafik, ermöglicht es den Benutzern jedoch, eine Vielzahl von Problemen zu lösen, die sich nicht auf das Zeichnen auf einer Leinwand beschränken.

Diese Methode wurde am besten in IBMs Programmierwerkzeug Node-RED umgesetzt. Es wurde als universelles Mittel entwickelt, um den gemeinsamen Betrieb verschiedener Geräte, Online-Dienste und APIs zu gewährleisten. Das Äquivalent zu Codeschnipseln waren Knoten aus der Standardbibliothek (Palette).

Die Fähigkeiten von Node-RED können durch die Installation von Add-Ons oder die Erstellung benutzerdefinierter Knoten, die bestimmte Datenaktionen ausführen, erweitert werden. Die Entwickler platzieren Knoten aus der Palette auf dem Desktop und bauen Beziehungen zwischen ihnen auf. Durch diesen Prozess entsteht die Logik der Anwendung, wobei die Visualisierung dazu beiträgt, die Übersichtlichkeit zu wahren.

Wenn man diesem Konzept neuronale Netze hinzufügt, entsteht ein faszinierendes System. Anstatt Daten mit bestimmten mathematischen Formeln zu verarbeiten, können Sie sie in ein neuronales Netz einspeisen und die gewünschte Ausgabe festlegen. Obwohl die Eingabedaten jedes Mal leicht variieren können, bleiben die Ergebnisse für die Interpretation durch Menschen oder andere neuronale Netze geeignet.

Retrieval Augmented Generation (RAG)

Die Genauigkeit der Daten in großen Sprachmodellen ist ein dringendes Problem. Diese Modelle stützen sich ausschließlich auf das beim Training gewonnene Wissen, das von der Relevanz der verwendeten Datensätze abhängt. Folglich kann es bei großen Sprachmodellen an ausreichend relevanten Daten mangeln, was zu falschen Ergebnissen führen kann.

Um dieses Problem zu lösen, sind Methoden zur Datenaktualisierung erforderlich. Wenn es neuronalen Netzen ermöglicht wird, Kontext aus zusätzlichen Quellen, wie z. B. Websites, zu extrahieren, kann die Qualität der Antworten erheblich verbessert werden. Genau auf diese Weise funktioniert RAG (Retrieval-Augmented Generation). Zusätzliche Daten werden in Vektordarstellungen umgewandelt und in einer Datenbank gespeichert.

Im Betrieb können neuronale Netzmodelle Benutzeranfragen in Vektordarstellungen umwandeln und diese mit den in der Datenbank gespeicherten vergleichen. Wenn ähnliche Vektoren gefunden werden, werden die Daten extrahiert und für die Erstellung einer Antwort verwendet. Vektordatenbanken sind schnell genug, um dieses Verfahren in Echtzeit zu unterstützen.

Damit dieses System korrekt funktioniert, muss eine Interaktion zwischen dem Benutzer, dem neuronalen Netzmodell, externen Datenquellen und der Vektordatenbank hergestellt werden. Langflow vereinfacht diese Einrichtung durch seine visuelle Komponente - der Benutzer baut einfach Standardblöcke und "verknüpft" sie, wodurch ein Pfad für den Datenfluss entsteht.

Der erste Schritt besteht darin, die Vektordatenbank mit relevanten Quellen zu füllen. Dazu können Dateien von einem lokalen Computer oder Webseiten aus dem Internet gehören. Hier ist ein einfaches Beispiel für das Laden von Daten in die Datenbank:

Nun, da wir neben dem trainierten LLM auch eine Vektordatenbank haben, können wir sie in das allgemeine Schema einbinden. Wenn ein Benutzer eine Anfrage im Chat stellt, wird gleichzeitig eine Eingabeaufforderung erstellt und die Vektordatenbank abgefragt. Wenn ähnliche Vektoren gefunden werden, werden die extrahierten Daten geparst und als Kontext zu dem gebildeten Prompt hinzugefügt. Das System sendet dann eine Anfrage an das neuronale Netz und gibt die erhaltene Antwort an den Nutzer im Chat aus.

Während im Beispiel Cloud-Dienste wie OpenAI und AstraDB erwähnt werden, können Sie alle kompatiblen Dienste verwenden, einschließlich derer, die lokal auf LeaderGPU-Servern bereitgestellt werden. Wenn Sie die von Ihnen benötigte Integration in der Liste der verfügbaren Blöcke nicht finden können, können Sie sie entweder selbst schreiben oder eine von jemand anderem erstellte hinzufügen.

Schnellstart

System vorbereiten

Die einfachste Art, Langflow einzusetzen, ist in einem Docker-Container. Um den Server einzurichten, installieren Sie zunächst die Docker Engine. Aktualisieren Sie dann sowohl den Paket-Cache als auch die Pakete auf ihre neuesten Versionen:

sudo apt update && sudo apt -y upgrade

Installieren Sie zusätzliche Pakete, die von Docker benötigt werden:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Laden Sie den GPG-Schlüssel herunter, um das offizielle Docker-Repository hinzuzufügen:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Fügen Sie das Repository zur APT hinzu, indem Sie den Schlüssel verwenden, den Sie zuvor heruntergeladen und installiert haben:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisieren Sie die Paketliste:

sudo apt update

Um sicherzustellen, dass Docker aus dem neu hinzugefügten Repository und nicht aus dem System-Repository installiert wird, können Sie den folgenden Befehl ausführen:

apt-cache policy docker-ce

Docker-Engine installieren:

sudo apt install docker-ce

Überprüfen Sie, ob Docker erfolgreich installiert wurde und der entsprechende Daemon läuft und den Status active (running) hat:

sudo systemctl status docker

● docker.service - Docker Application Container Engine
  Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
  Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
    Docs: https://docs.docker.com
Main PID: 1842 (dockerd)
   Tasks: 29
  Memory: 1.8G
     CPU: 3min 15.715s
  CGroup: /system.slice/docker.service

Erstellen und Ausführen

Alles ist bereit, um einen Docker-Container mit Langflow zu erstellen und auszuführen. Es gibt jedoch eine Einschränkung: Zum Zeitpunkt der Erstellung dieses Leitfadens hat die neueste Version (mit dem Tag v1.1.0) einen Fehler und lässt sich nicht starten. Um dieses Problem zu vermeiden, verwenden wir die vorherige Version, v1.0.19.post2, die direkt nach dem Herunterladen einwandfrei funktioniert.

Der einfachste Ansatz ist der Download des Projekt-Repositorys von GitHub:

git clone https://github.com/langflow-ai/langflow

Navigieren Sie zu dem Verzeichnis, das die Beispielkonfiguration für die Bereitstellung enthält:

cd langflow/docker_example

Nun müssen Sie zwei Dinge tun. Erstens ändern Sie das Release-Tag, so dass eine funktionierende Version (zum Zeitpunkt der Erstellung dieser Anleitung) erstellt wird. Zweitens fügen Sie eine einfache Autorisierung hinzu, damit niemand das System benutzen kann, ohne Login und Passwort zu kennen.

Öffnen Sie die Konfigurationsdatei:

sudo nano docker-compose.yml

anstelle der folgenden Zeile:

image: langflowai/langflow:latest

Geben Sie die Version anstelle des Tags latest an:

image: langflowai/langflow:v1.0.19.post2

Sie müssen auch drei Variablen in den Abschnitt environment aufnehmen:

  - LANGFLOW_AUTO_LOGIN=false
  - LANGFLOW_SUPERUSER=admin
  - LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

Die erste Variable deaktiviert den Zugriff auf die Webschnittstelle ohne Autorisierung. Die zweite fügt den Benutzernamen hinzu, der Systemadministratorrechte erhalten soll. Die dritte fügt das entsprechende Passwort hinzu.

Wenn Sie vorhaben, die Datei docker-compose.yml in einem Versionskontrollsystem zu speichern, sollten Sie das Passwort nicht direkt in diese Datei schreiben. Erstellen Sie stattdessen eine separate Datei mit der Erweiterung .env im selben Verzeichnis und speichern Sie den Variablenwert dort.

LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

In der Datei docker-compose.yml können Sie nun auf eine Variable verweisen, anstatt direkt ein Kennwort anzugeben:

LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}

Um zu verhindern, dass die Datei *.env versehentlich auf GitHub veröffentlicht wird, denken Sie daran, sie zu .gitignore hinzuzufügen. So ist Ihr Passwort vor unerwünschtem Zugriff einigermaßen sicher.

Jetzt müssen wir nur noch unseren Container bauen und ihn ausführen:

sudo docker compose up

Öffnen Sie die Webseite http://[LeaderGPU_IP_address]:7860, und Sie werden das Autorisierungsformular sehen:

Nach Eingabe Ihres Logins und Passworts gewährt Ihnen das System Zugriff auf die Weboberfläche, auf der Sie Ihre eigenen Anwendungen erstellen können. Für eine ausführlichere Anleitung empfehlen wir, die offizielle Dokumentation zu konsultieren. Sie enthält Einzelheiten zu verschiedenen Umgebungsvariablen, die eine einfache Anpassung des Systems an Ihre Bedürfnisse ermöglichen.

Siehe auch:

Easy Diffusion UI

Wed, 22 Jan 2025 12:13:37 +0100

Easy Diffusion UI ist eine Open-Source-Software, die auf GitHub zum Download bereitsteht. Hier erfahren Sie, wie Sie sie auf Ubuntu 22.04 LTS installieren. Wenn Sie gerade einen Server gemietet haben, installieren Sie die GPU-Treiber und erweitern Sie Ihr Home-Verzeichnis. Laden Sie dann die neueste Version von Easy Diffusion UI herunter:

wget https://github.com/cmdr2/stable-diffusion-ui/releases/latest/download/Easy-Diffusion-Linux.zip

Entpacken Sie das heruntergeladene ZIP-Archiv:

unzip Easy-Diffusion-Linux.zip

Wechseln Sie in das Verzeichnis easy-diffusion:

cd easy-diffusion

Starten Sie die Installation:

./start.sh

Dies ist eine Skriptsammlung, die automatisch alle erforderlichen Komponenten herunterlädt und installiert. Sie lädt auch das Standard-Stable-Diffusion-Modell im SafeTensors-Format herunter. Sobald alle Downloads und Installationen abgeschlossen sind, wird die Easy Diffusion-Benutzeroberfläche automatisch gestartet.

Verwendung von

Der vorherige Artikel, Stable Diffusion WebUI, beschreibt eine Methode zur Annahme von Verbindungen aus dem öffentlichen Internet und bietet eine einfache Anmeldung und Passwortautorisierung. In diesem Fall wollen wir eine andere universelle Methode zur Weiterleitung von Ports über eine SSH-Verbindung demonstrieren. Wir verwenden PuTTY, um eine sichere Verbindung zum Remote-Server herzustellen. Weitere Informationen dazu finden Sie in unserem Leitfaden Connect to a Linux server.

Um auszuwählen, welche Ports weitergeleitet werden sollen, öffnen Sie bitte Connection > SSH > Tunnels im linken Optionsbaum. Geben Sie 9000 in das Feld Source Port und 127.0.0.1:9000 in das Feld Destination ein. Klicken Sie dann auf die Schaltfläche Add:

Danach können Sie zu Session zurückkehren und es zur späteren Verwendung speichern. Verbinden Sie sich wie gewohnt mit dem entfernten Server. Nun werden alle Daten, die Sie über Port 9000 an der Loopback-Adresse 127.0.0.1 senden oder empfangen, an den Remote-Server umgeleitet. Mit dieser Methode wird ein virtueller sicherer Tunnel geschaffen, der so lange besteht, wie die Verbindung besteht.

Sobald Easy Diffusion UI startet und die Portweiterleitung aktiviert ist, können Sie einen Webbrowser öffnen und zur Adresse http://127.0.0.1:9000 navigieren. Wir empfehlen Ihnen, benutzerdefinierte Modelle, wie in diesem Artikel beschrieben, herunterzuladen und zu installieren, anstatt sich ausschließlich auf das Standardmodell zu verlassen, um Bilder zu erzeugen. Vergessen Sie nicht, die Anzahl der Inferenzschritte zu erhöhen und die gewünschte Bildauflösung einzustellen (mit Sternchen gekennzeichnet).

Einer der größten Vorteile der Easy Diffusion UI ist die Unterstützung für mehrere GPUs. Wenn Sie einen Stapel von Bildern erstellen möchten, können Sie wählen, wie viele Bilder parallel erstellt werden sollen. Zum Beispiel, wenn Sie eine Konfiguration mit zwei GPUs haben:

Sie können die Auslastung der GPUs während der Bilderstellung anzeigen. Stellen Sie eine weitere SSH-Verbindung her und führen Sie einen einzigen Befehl aus:

watch -n 1 nvidia-smi

Außerdem vereinfacht Easy Diffusion UI die Erstellung von Prompts, da es zahlreiche Beispiele für Bildmodifikatoren bietet. Sie können diese mischen, um genauere Ergebnisse zu erzielen:

Es ist eine gute Idee, PromptBook von OpenArt zu entdecken. Diese Anleitung kann Ihre Fähigkeiten bei der Erstellung von Prompts erheblich verbessern. Mit der Easy Diffusion UI können Sie ein einmal erstelltes Bild herunterladen, als Beispiel für die Erstellung des nächsten Bildes verwenden oder mit nur einem Klick Änderungen vornehmen:

Am häufigsten wird die Schaltfläche Upscale verwendet, um die Auflösung eines Bildes zu erhöhen. Das generative neuronale Netzwerk verwendet das Originalbild als Grundlage und fügt zusätzliche Pixel hinzu, wodurch das Quellbild auf die gewünschte Größe interpoliert wird.

Bei der Generierung von Gesichtern können Probleme auftreten, z. B. falsch ausgerichtete Augen, unproportionierte Größen oder missgebildete Teile. Glücklicherweise können diese Probleme mit der Schaltfläche Fix Faces behoben werden. Außerdem können negative Eingabeaufforderungen verwendet werden, um zu verhindern, dass falsche Gesichter erzeugt werden.

Deinstallieren

Alle Dateien, Skripte, Bibliotheken und Modelle werden in einem einzigen Verzeichnis gespeichert. Wenn Sie Easy Diffusion UI von Ihrem Server entfernen möchten, löschen Sie einfach dieses Verzeichnis zusammen mit dem gesamten Inhalt:

sudo rm -rf easy-diffusion

Siehe auch:

Stable Video Diffusion

Wed, 22 Jan 2025 11:53:04 +0100

Generative neuronale Netze können verschiedene Arten von Inhalten erstellen. Stable Diffusion wurde entwickelt, um Bilder aus Textbeschreibungen zu erzeugen. Es kann jedoch auch zur Erstellung von Musik, Sounds und sogar Videos verwendet werden. Heute zeigen wir Ihnen, wie Sie mit Stable Diffusion mit WebUI und ComfyUI kurze Videos aus einem einzigen Bild erstellen können.

Installieren Sie Stable Diffusion

Beginnen wir mit der Installation von Stable Diffusion anhand unserer Schritt-für-Schritt-Anleitung. Nach der Installation unterbrechen Sie bitte die Ausführung des Skripts webui.sh durch Drücken der Tastenkombination Strg + C und schließen Sie die SSH-Verbindung. Das System erlaubt es nicht, Erweiterungen mit der aktivierten Option --listen (--share) zu installieren. Das bedeutet, dass Sie eine Portweiterleitung (7860 und 8189) von Ihrem lokalen Rechner zum Remote-Server einrichten müssen. Der erste Port wird für WebUI und der zweite für ComfyUI benötigt.

In PuTTY müssen Sie zum Beispiel Connection >> SSH >> Tunnels öffnen und zwei neue weitergeleitete Ports hinzufügen, wie im folgenden Screenshot gezeigt:

Nun können Sie sich erneut mit dem Remote-Server verbinden und ./webui.sh erneut ausführen.

Öffnen Sie diese URL in Ihrem Browser:

http://127.0.0.1:7860

Navigieren Sie zu Extensions >> Available und klicken Sie dann auf die Schaltfläche Load from::

Das System wird die JSON-Datei mit allen verfügbaren Erweiterungen herunterladen. Geben Sie ComfyUI in das Sucheingabefeld ein und klicken Sie auf die Schaltfläche Install:

Die Webseite wird neu geladen und Sie erhalten eine neue Registerkarte ComfyUI im Hauptfenster. Wechseln Sie dorthin und klicken Sie auf Install ComfyUI:

Wenn die Installation abgeschlossen ist, unterbrechen Sie die Ausführung des Skripts webui.sh erneut, indem Sie Ctrl + C drücken.

Stable Video Diffusion Modell installieren

Öffnen Sie das Verzeichnis des Modells:

cd stable-diffusion-webui/models/Stable-diffusion/

Laden Sie das vollständige Stable Video Diffusion-Modell herunter:

curl -L https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt/resolve/main/svd_xt.safetensors?download=true --output svd_xt.safetensors

Zurück zum Home-Verzeichnis:

cd ~/

Führen Sie den Stable Diffusion-Dienst erneut aus:

./webui.sh

Laden Sie das Beispiel für den Stable Video Diffusion Workflow im JSON-Format herunter. Löschen Sie den ComfyUI-Standard-Workflow, indem Sie auf Clear drücken und dann Load das heruntergeladene Beispiel:

Vergewissern Sie sich, dass Sie das richtige Modell im Knoten Image Only Checkpoint Loader (img2vid model) ausgewählt haben:

Klicken Sie auf die Schaltfläche choose file to upload im Knoten Load Image und wählen Sie ein beliebiges Einzelbild aus, das das generative neuronale Netzwerk in ein Video umwandeln soll:

Versuchen Sie, ein Video mit allen Standardparametern zu erzeugen, indem Sie auf die Schaltfläche Queue Prompt klicken:

Nachdem der Prozess abgeschlossen ist, erhalten Sie Ihr Video im WEBP-Format im Knoten SaveAnimatedWEBP. Klicken Sie mit der rechten Maustaste auf das generierte Video und wählen Sie Save Image:

Hier sehen Sie das Endergebnis als GIF.

Fehlersuche

Wenn Sie eine Fehlermeldung erhalten: ModuleNotFoundError: No module named 'utils.json_util'; 'utils' is not a package führen Sie bitte die folgenden Schritte aus:

Benennen Sie das Verzeichnis utils in utilities um:

mv /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utils /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utilities

Bearbeiten Sie custom_node_manager.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/app/custom_node_manager.py

Ersetzen Sie diese Zeile:

from utils.json_util import merge_json_recursive

mit:

from utilities.json_util import merge_json_recursive

Speichern Sie die Datei (Ctrl + O) und beenden Sie den Editor (Ctrl + X). Bearbeiten Sie dann main.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/main.py

Ersetzen Sie diese Zeile:

import utils.extra_config

mit:

import utilities.extra_config

Speichern Sie die Datei, beenden Sie den Editor, und führen Sie den Stable Diffusion-Dienst erneut aus:

./webui.sh

Siehe auch:

PyTorch für Windows

Wed, 22 Jan 2025 11:35:30 +0100

Bevor Sie mit der Installation von PyTorch beginnen, müssen Sie den Python-Interpreter und Microsoft Visual C++ Redistributable installieren. Öffnen Sie einen Web-Browser und navigieren Sie zur Download-Seite von Python. Suchen Sie die neueste Python 3 Version und klicken Sie auf den Link:

Scrollen Sie dann auf der Seite nach unten und klicken Sie auf Windows Installer (64-bit):

Öffnen Sie die heruntergeladene Datei, um mit der Installation fortzufahren:

Aktivieren Sie das Kontrollkästchen für Add python.exe to PATH und klicken Sie auf Install Now:

Warten Sie eine Minute, bis der Installationsvorgang abgeschlossen ist:

Sie können optional Disable path length limit wählen, wenn Sie lange Namen verwenden möchten, die die Grenzen von MAX_PATH überschreiten könnten:

MS Visual C++ installieren

Als nächstes laden Sie Microsoft Visual C++ Redistributable über diesen Link herunter und klicken auf das Installationsprogramm:

Sie müssen das Kästchen I agree to the license terms and conditions ankreuzen und auf die Schaltfläche Install klicken:

Nach ein paar Sekunden wird die Software installiert und Sie können das Installationsprogramm unter Close aufrufen:

Jetzt ist alles bereit für die Installation von PyTorch. Klicken Sie auf die Schaltfläche Start und geben Sie cmd auf der Tastatur ein. Klicken Sie mit der rechten Maustaste auf Command Prompt und wählen Sie Run as administrator aus dem Kontextmenü:

PyTorch installieren

Führen Sie den folgenden Befehl aus:

pip install torch torchvision

Wenn Sie eine bestimmte Version von PyTorch installieren möchten, können Sie diese während der Installation angeben:

pip install torch==1.9.0 torchvision==0.10.0

Wenn die Installation abgeschlossen ist, lassen Sie uns überprüfen, ob PyTorch richtig funktioniert. Führen Sie den folgenden Befehl aus, um den Python-Interpreter zu öffnen:

python

Geben Sie diese beiden Zeichenfolgen ein und beenden Sie Ihre Eingabe mit der Taste Enter:

import torch
print(torch.__version__)

Wenn Sie ein solches Ergebnis erhalten, bedeutet dies, dass PyTorch korrekt installiert wurde:

2.0.1+cu117

Siehe auch:

PyTorch für Linux

Wed, 22 Jan 2025 10:14:16 +0100

Moderne Linux-Distributionen sind in hohem Maße von der installierten Version von Python abhängig. Daher empfehlen wir, vor der Installation von PyTorch eine virtuelle Umgebung mit Hilfe unserer Schritt-für-Schritt-Anleitung Linux System Utilities zu erstellen.

Aktivieren Sie die erstellte venv und fahren Sie mit dem pip3-Upgrade fort:

pip3 install --upgrade pip

Starten Sie die PyTorch-Installation:

pip3 install torch torchvision

Wenn Sie eine bestimmte Version von PyTorch installieren möchten, geben Sie einfach die gewünschte Versionsnummer ein:

pip3 install torch==1.9.0 torchvision==0.10.0

Wenn die Installation abgeschlossen ist, lassen Sie uns überprüfen, ob PyTorch korrekt installiert wurde. Öffnen Sie den Python-Interpreter:

python3

Geben Sie diese beiden Zeichenfolgen ein und beenden Sie Ihre Eingabe mit der Eingabetaste:

import torch
print(torch.__version__)

Wenn Sie ein Ergebnis wie dieses erhalten, bedeutet dies, dass PyTorch korrekt installiert wurde:

2.0.1+cu117

Siehe auch:

Stable Diffusion: Riffusion

Tue, 21 Jan 2025 14:12:29 +0100

In unseren vorangegangenen Artikeln haben wir die faszinierenden Möglichkeiten von Stable Diffusion zur Erzeugung fesselnder Bilder erkundet. Es ist jedoch wichtig zu wissen, dass dieses leistungsstarke generative neuronale Netzwerk noch mehr zu bieten hat.

Riffusion ist ein Stable Diffusion-Modell für die Erstellung und Bearbeitung von Musik. Mit Riffusion können Sie ein Spektrogramm eines gewünschten musikalischen Segments erzeugen und es mühelos in einen musikalischen Ausschnitt verwandeln. Lassen Sie uns Riffusion auf einem LeaderGPU-Server installieren und in Aktion ausprobieren.

Voraussetzungen

Aktualisieren Sie zunächst das Paket-Cache-Repository und die installierten Pakete:

sudo apt update && sudo apt -y upgrade

Vergessen Sie nicht, die Nvidia-Treiber mit dem Befehl autoinstall oder manuell mit Hilfe unserer Schritt-für-Schritt-Anleitung zu installieren:

sudo ubuntu-drivers autoinstall

Starten Sie den Server neu:

sudo shutdown -r now

Für die Erstellung einer virtuellen Umgebung empfehlen die Entwickler ein Tool namens Anaconda. Sie können auch venv verwenden, das wir in der Anleitung zu den Linux-Systemdienstprogrammen besprochen haben. Laden Sie das Anaconda-Installationsskript mit curl herunter:

curl --output anaconda.sh https://repo.anaconda.com/archive/Anaconda3-5.3.1-Linux-x86_64.sh

Machen Sie es ausführbar:

chmod +x anaconda.sh

Und ausführen:

./anaconda.sh

Beantworten Sie alle Fragen mit JA, außer der letzten (Microsoft VSCode installieren). Melden Sie sich dann erneut an der SSH-Konsole an und erstellen Sie eine neue virtuelle Umgebung mit Python v3.9:

conda create --name riffusion python=3.9

Aktivieren Sie die neue virtuelle Umgebung:

conda activate riffusion

Wenn Sie andere Musikformate als wav verwenden möchten, müssen Sie auch das FFmpeg-Bibliotheksset installieren:

conda install -c conda-forge ffmpeg

Riffusion installieren

Klonen Sie das Riffusion-Repository:

git clone https://github.com/riffusion/riffusion.git

Öffnen Sie das heruntergeladene Verzeichnis:

cd riffusion

Lassen Sie uns einige Änderungen in der Anforderungsdatei vornehmen. Dies verhindert Fehler bei der Kompatibilität der Taschenlampe:

nano requirements.txt

Paketversionen finden und korrigieren:

diffusers==0.9.0
torchaudio==2.0.1

Speichern Sie die Änderungen und fahren Sie mit der Vorbereitung einer virtuellen Umgebung fort. Mit dem folgenden Befehl werden alle erforderlichen Pakete installiert:

python -m pip install -r requirements.txt

Schließlich können Sie eine "Spielwiese" öffnen. Dies ist eine einfache Weboberfläche, die Ihnen hilft, mehr über die Funktionen von Riffusion zu erfahren:

python -m riffusion.streamlit.playground

Öffnen Sie Ihren Lieblingsbrowser und geben Sie die Adresse http://[SERVER_IP]:8501/

Testen Sie einen Spielplatz

Jetzt können Sie mit Hilfe von Textaufforderungen und durch Ändern der anderen Parameter Musik erzeugen:

Außerdem können Sie einige knifflige Dinge tun, wie z. B. das Aufteilen von Audio in einzelne Komponenten. Zum Beispiel können Sie die Stimme aus Bohemian Rhapsody von Queen extrahieren:

Denken Sie daran, dass dies nur ein einziges Beispiel dafür ist, wie Riffusion genutzt werden kann. Wenn Sie Ihre eigene Anwendung erstellen, können Sie wesentlich fesselndere Ergebnisse erzielen. Leistungsstarke Server von LeaderGPU kümmern sich um die Berechnungen.

Siehe auch:

Stable Diffusion: Wiederholbare Gesichter generieren

Tue, 21 Jan 2025 13:51:05 +0100

Wiederholbarkeit ist der wichtigste Aspekt bei der Erstellung grafischer Inhalte mit generativen neuronalen Netzen. Dies gilt unabhängig von der Art des Inhalts, den Sie erstellen, sei es eine Film- oder Spielfigur, eine Landschaft oder eine Szenenumgebung. Das Hauptproblem kann folgendermaßen formuliert werden: "Wie kann ich mein Ergebnis wiederholen?". Jedes Mal, wenn Sie beginnen, Bilder mit denselben positiven und negativen Vorgaben zu erstellen, werden Sie unterschiedliche Ergebnisse erhalten. Manchmal sind die Unterschiede gering und akzeptabel, aber in den meisten Fällen können sie ein Problem darstellen.

Stable Diffusion wurde anhand eines großen Datensatzes aus der realen Welt erlernt, was erklärt, warum die Wiederholbarkeit keine Stärke dieses neuronalen Netzwerkmodells ist. Diese Regel gilt jedoch nicht für Fotos von Prominenten. Diese Fotos kommen in der realen Welt viel häufiger vor und sind daher auch in dem Datensatz enthalten, mit dem Stable Diffusion trainiert wurde. Sie können diese Fotos als "Konstante" oder als "Ausgangspunkt" für den Generierungsprozess verwenden.

Methode 1. "Geschüttelt, nicht gerührt"

Natürlich müssen Sie nicht nur Bilder von Prominenten erstellen, sondern können mehrere relevante Aufforderungen verwenden, um mehr oder weniger konsistente Ergebnisse zu erhalten. Nehmen wir zum Beispiel zwei berühmte griechische Sängerinnen: Elena Paparizou und Marina Satti, und erhalten wiederholbare Ergebnisse:

Model: Realistic Vision v6.0 beta 1

Positive prompts:

Elena Paparizou, Marina Satti, fashion portrait, alone, solo, greek woman in beautiful clothes, natural skin, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Es funktioniert mit allen Berühmtheiten, da Stable Diffusion versucht, die markantesten Gesichtszüge zu reproduzieren. Hier verwenden wir dasselbe Modell und "schütteln" zwei Hollywood-Stars (Dwayne Johnson und Danny Trejo) in eine neue synthetische Figur.

Positive prompts:

Dwayne Johnson, Danny Trejo, fashion portrait, alone, solo, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Jedes Mal, wenn Sie die gleichen Prominenten mischen, erhalten Sie ähnliche Ergebnisse. Schauen wir uns eine andere Methode an, um wiederholbare Zeichen zu erzeugen.

Methode 2. Namensanker

Berühmte Persönlichkeiten sind ein guter Anfang, aber lassen Sie uns andere Methoden in Betracht ziehen, um wiederholbare Ergebnisse zu erzielen. Die Antwort ist ganz einfach: Wir können mehrere menschliche Namen verwenden. Jede Nation hat einzigartige Namen, die mit sprachlichen Merkmalen verbunden sind. Der griechische Name Kostas zum Beispiel kann mit "Arbeit" oder "Mühe" übersetzt werden, während Nikos "Sieg des Volkes" bedeutet. Diese beiden Namen schaffen ein einzigartiges Bild einer generierten Person und helfen den Modellen des neuronalen Netzes, unsere Erstellungsziele zu verstehen.

Positive prompts:

Portrait of [Kostas | Nikos] on a white background, greek man, short haircut, beard

Negative prompts:

woman, bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Lassen Sie uns zahlreiche Bilder (80-100) für die weitere Erstellung von Datensätzen erzeugen. Die Hauptaufforderung wurde so gewählt, dass sie praktische Bilder liefert, die leicht vom Hintergrund entfernt werden können. Negative Prompts schützen uns davor, zufällige Bilder mit Verzerrungen in den Datensatz aufzunehmen, ebenso wie Bilder von Frauen.

Tipp: Wenn Sie sehr unterschiedliche Bilder erhalten, versuchen Sie, den Parameter CFG Scale von 7,5 auf 15 zu ändern. Dadurch wird das neuronale Netz gezwungen, den Aufforderungen formaler zu folgen.

Sie können Ihre eigenen Namen mit einem einfachen Namensgenerator wie Behind the Name auswählen. Außerdem können Sie die ControlNet-Funktion verwenden, um mehr Kontrolle zu erhalten.

Methode 3. Aussehen beibringen

Wir können das Endergebnis nicht direkt beeinflussen, aber wir beobachten, dass einige Token (z. B. Token mit Prominentenbildern) mehr Gewicht haben als andere. Das bedeutet, dass wir unser bedingtes "Prominenten"-Token erstellen können, indem wir eine geeignete Eingabeaufforderung für es erstellen und das Modell damit weiter trainieren. Das ist die Funktionsweise von LoRA (Low-Rank Adaptation of Large Language Models). Sie können unsere Schritt-für-Schritt-Anleitung verwenden, um Ihr eigenes LoRA-Modell auf der Grundlage eines selbst erstellten Datensatzes zu trainieren.

Nachdem wir den Hintergrund entfernt haben, erhalten wir klare Porträts und verwenden diese, um ein spezifisches LoRA-Modell zu erstellen. Dieses Modell hilft dabei, ein Gesicht mit ein paar kleinen Änderungen nachzubilden:

Nun können wir diese Figur an verschiedenen Orten generieren, Geschichten erstellen und sie in verschiedene Rollen versetzen: vom Gärtner bis zum Geschäftsmann. Sein Gesicht wird stets erkennbar und wiederholbar sein:

Diese Methode ist nicht ideal, aber sie funktioniert in einer Vielzahl von Situationen perfekt. Sie müssen keinen Datensatz von einer realen Person vorbereiten, und er kann aus der Ferne erstellt werden:

Sie können versuchen, eine solche virtuelle Figur selbst zu erstellen, ohne die Hilfe eines professionellen Designers oder 3D-Modellierungsspezialisten. Alles, was Sie brauchen, sind schnelle GPUs, die Sie in den dedizierten Servern von LeaderGPU finden können.

Siehe auch:

Stable Diffusion: LoRA-Selfie

Tue, 21 Jan 2025 13:44:25 +0100

Sie können Ihren ersten Datensatz mit einer einfachen Kamera und einem relativ einheitlichen Hintergrund erstellen, z. B. einer weißen Wand oder einem einfarbigen Verdunkelungsvorhang. Für einen Beispieldatensatz habe ich eine spiegellose Kamera Olympus OM-D EM5 Mark II mit 14-42 Kit-Objektiven verwendet. Diese Kamera unterstützt die Fernsteuerung von jedem Smartphone aus und verfügt über einen sehr schnellen Serienbildmodus.

Ich habe die Kamera auf einem Stativ befestigt und die Fokuspriorität auf Gesicht eingestellt. Danach wählte ich den Modus, in dem die Kamera alle 3 Sekunden 10 Bilder hintereinander aufnimmt, und startete den Vorgang. Während der Aufnahme drehte ich meinen Kopf langsam in die ausgewählte Richtung und änderte die Richtung nach jeweils 10 Bildern:

Das Ergebnis waren etwa 100 Bilder mit einem eintönigen Hintergrund:

Der nächste Schritt besteht darin, den Hintergrund zu entfernen und das Porträt auf einem weißen Hintergrund zu belassen.

Hintergrund löschen

Sie können die Standardfunktion von Adobe Photoshop Remove background und die Stapelverarbeitung verwenden. Lassen Sie uns Aktionen speichern, die wir auf jedes Bild in einem Datensatz anwenden wollen. Öffnen Sie ein beliebiges Bild, klicken Sie auf das Dreieckssymbol und dann auf das Symbol +:

Geben Sie den Namen der neuen Aktion ein, z. B. Remove Background, und klicken Sie auf Record:

Suchen Sie auf der Registerkarte Layers das Schlosssymbol und klicken Sie es an:

Klicken Sie anschließend auf die Schaltfläche Remove background auf dem schwebenden Bedienfeld:

Klicken Sie mit der rechten Maustaste auf Layer 0 und wählen Sie Flatten Image:

Alle unsere Aktionen sind aufgezeichnet worden. Lassen Sie uns diesen Prozess beenden:

Jetzt können Sie die geöffnete Datei schließen, ohne die Änderungen zu speichern, und wählen Sie File >> Scripts >> Image Processor…

Wählen Sie die Eingabe- und Ausgabeverzeichnisse aus, wählen Sie die in Schritt 4 erstellte Aktion Remove Background und klicken Sie auf die Schaltfläche Run:

Bitte haben Sie etwas Geduld. Adobe Photoshop wird jedes Bild im ausgewählten Verzeichnis öffnen, die aufgezeichneten Aktionen wiederholen (Ebenensperre ausschalten, Hintergrund löschen, Bild reduzieren) und es in einem anderen ausgewählten Verzeichnis speichern. Dieser Vorgang kann einige Minuten dauern, je nach Anzahl der Bilder.

Wenn der Vorgang abgeschlossen ist, können Sie zum nächsten Schritt übergehen.

Hochladen auf den Server

Verwenden Sie eine der folgenden Anleitungen (zugeschnitten auf Ihr PC-Betriebssystem), um das Verzeichnis dataset auf den Remote-Server hochzuladen. Legen Sie es zum Beispiel im Home-Verzeichnis des Standardbenutzers /home/usergpu ab:

Vor-Installation

Aktualisieren Sie vorhandene Systempakete:

sudo apt update && sudo apt -y upgrade

Installieren Sie zwei zusätzliche Pakete:

sudo apt install -y python3-tk python3.10-venv

Installieren wir das CUDA® Toolkit Version 11.8. Laden wir die spezifische Pin-Datei herunter:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

Der folgende Befehl legt die heruntergeladene Datei im Systemverzeichnis ab, das vom apt Paketmanager kontrolliert wird:

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

Der nächste Schritt ist das Herunterladen des CUDA-Hauptrepositorys:

wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Danach fahren Sie mit der Installation des Pakets mit dem Standardprogramm dpkg fort:

sudo dpkg -i cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Kopieren Sie den GPG-Schlüsselring in das Systemverzeichnis. Dadurch wird er für die Verwendung durch die Dienstprogramme des Betriebssystems, einschließlich des apt-Paketmanagers, verfügbar:

sudo cp /var/cuda-repo-ubuntu2204-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/

Aktualisieren Sie die System-Cache-Repositories:

sudo apt-get update

Installieren Sie das CUDA® Toolkit mit apt:

sudo apt-get -y install cuda

Fügen Sie CUDA® zu PATH hinzu. Öffnen Sie die Bash-Shell-Konfiguration:

nano ~/.bashrc

Fügen Sie die folgenden Zeilen am Ende der Datei hinzu:

export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64\
                         ${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Speichern Sie die Datei und starten Sie den Server neu:

sudo shutdown -r now

Trainer installieren

Kopieren Sie das Repository des Kohya-Projekts auf den Server:

git clone https://github.com/bmaltais/kohya_ss.git

Öffnen Sie das heruntergeladene Verzeichnis:

cd kohya_ss

Machen Sie das Setup-Skript ausführbar:

chmod +x ./setup.sh

Führen Sie das Skript aus:

./setup.sh

Sie erhalten eine Warnmeldung vom Beschleunigungsprogramm. Lassen Sie uns das Problem lösen. Aktivieren Sie die virtuelle Umgebung des Projekts:

source venv/bin/activate

Installieren Sie das fehlende Paket:

pip install scipy

Und konfigurieren Sie das Beschleunigungsprogramm manuell:

accelerate config

Seien Sie vorsichtig, denn die Aktivierung einer ungeraden Anzahl von CPUs wird einen Fehler verursachen. Wenn ich zum Beispiel 5 GPUs habe, können nur 4 mit dieser Software verwendet werden. Andernfalls wird beim Start des Prozesses ein Fehler auftreten. Sie können die neue Konfiguration des Dienstprogramms sofort überprüfen, indem Sie einen Standardtest aufrufen:

accelerate test

Wenn alles in Ordnung ist, erhalten Sie eine Meldung wie diese:

Test is a success! You are ready for your distributed training!

deactivate

Jetzt können Sie den öffentlichen Server des Trainers mit der Gradio-GUI und einer einfachen Login/Passwort-Authentifizierung starten (ändern Sie den Benutzer/das Passwort in Ihr eigenes):

./gui.sh --share --username user --password password

Sie werden zwei Zeichenfolgen erhalten:

Running on local URL: http://127.0.0.1:7860
Running on public URL: https://.gradio.live

Öffnen Sie Ihren Webbrowser und geben Sie die öffentliche URL in die Adressleiste ein. Geben Sie Ihren Benutzernamen und Ihr Passwort in die entsprechenden Felder ein und klicken Sie dann auf Anmelden:

Vorbereiten des Datensatzes

Beginnen Sie damit, einen neuen Ordner zu erstellen, in dem Sie das trainierte LoRA-Modell speichern werden:

mkdir /home/usergpu/myloramodel

Öffnen Sie die folgenden Registerkarten: Utilities >> Captioning >> BLIP captioning. Füllen Sie die Lücken wie in der Abbildung gezeigt aus und klicken Sie auf Caption images:

Trainer lädt ein spezielles neuronales Netzwerkmodell (1,6 GB) herunter und führt es aus, das für jede Bilddatei im ausgewählten Verzeichnis Textaufforderungen erstellt. Der Vorgang wird auf einem einzelnen Grafikprozessor ausgeführt und dauert etwa eine Minute.

Wechseln Sie zur Registerkarte LoRA >> Tools >> Dataset preparation >> Dreambooth/LoRA folder preparation, füllen Sie die Lücken aus und drücken Sie nacheinander Prepare training data und Copy info to Folders Tab:

In diesem Beispiel verwenden wir den Namen nikolai als Instance prompt und "Person" als Class prompt. Wir setzen auch /home/usergpu/dataset als Training Images und /home/usergpu/myloramodel als Destination training directory.

Wechseln Sie erneut auf die Registerkarte LoRA >> Training >> Folders. Vergewissern Sie sich, dass die Felder Image folder, Output folder und Logging folder korrekt ausgefüllt sind. Falls gewünscht, können Sie Model output name durch Ihre eigene Adresse ersetzen. Klicken Sie abschließend auf die Schaltfläche Start training:

Das System beginnt mit dem Herunterladen von zusätzlichen Dateien und Modellen (~10 GB). Danach beginnt der Trainingsprozess. Je nach der Menge der Bilder und den vorgenommenen Einstellungen kann dies mehrere Stunden dauern. Sobald das Training abgeschlossen ist, können Sie das Verzeichnis /home/usergpu/myloramodel zur weiteren Verwendung auf Ihren Computer herunterladen.

Testen Sie Ihren LoRA

Wir haben einige Artikel über Stable Diffusion und seine Forks vorbereitet. Sie können versuchen, Easy Diffusion mit unserer Anleitung Easy Diffusion UI zu installieren. Nachdem das System installiert wurde und läuft, können Sie Ihr LoRA-Modell im SafeTensors-Format direkt hochladen auf /home/usergpu/easy-diffusion/models/lora

Aktualisieren Sie die Easy Diffusion-Webseite und wählen Sie Ihr Modell aus der Dropdown-Liste:

Lassen Sie uns eine einfache Eingabeaufforderung schreiben, portrait of <nikolai> wearing a cowboy hat, und unsere ersten Bilder erzeugen. Hier haben wir ein benutzerdefiniertes Stable Diffusion-Modell verwendet, das wir von civitai.com heruntergeladen haben: Realistic Vision v6.0 B1:

Sie können mit Prompts und Modellen, die auf Stable Diffusion basieren, experimentieren, um bessere Ergebnisse zu erzielen. Viel Spaß!

Siehe auch:

Stable Diffusion: Was ist ControlNet?

Tue, 21 Jan 2025 10:42:39 +0100

Ein weit verbreitetes Missverständnis unter denjenigen, die zum ersten Mal mit generativen neuronalen Netzen in Berührung kommen, ist, dass die Kontrolle der endgültigen Ausgabe eine enorme Herausforderung darstellt, insbesondere wenn man versucht, die Ausgabe durch unterschiedliche Eingabeaufforderungen zu verändern. Derzeit gibt es eine Reihe von Tools, die unter dem Namen ControlNet bekannt sind und eine relativ unkomplizierte und effektive Kontrolle der Generierungsergebnisse ermöglichen.

In diesem Artikel zeigen wir, wie man mit Hilfe eines solchen Tools, OpenPose, die Pose der generierten Charaktere mit Hilfe von bereits existierenden Bildern und benutzerdefinierten "Skeletten" leicht manipulieren kann.

Schritt 1. Stabile Diffusion installieren

Bitte verwenden Sie unsere Schritt-für-Schritt-Anleitung, um Stable Diffusion mit dem Grundmodell und der WebUI zu installieren. Diese Anleitung basiert auf dem AUTOMATIC1111-Skript.

Schritt 2. ControlNet-Erweiterung installieren

Wir raten dringend davon ab, die ControlNet-Erweiterung (sd-webui-controlnet) aus dem Standard-Repository zu installieren, da es zu Problemen mit der Funktionalität kommen kann. Ein wichtiges Problem, auf das wir bei der Erstellung dieses Leitfadens gestoßen sind, war das Einfrieren der Weboberfläche. Obwohl das Image zunächst erfolgreich erstellt wird, reagiert die WebUI nicht mehr, wenn das Image ein zweites Mal erstellt wird. Eine alternative Lösung wäre die Installation der gleichen Erweiterung aus einer externen Quelle.

Öffnen Sie WebUI und folgen Sie den Registerkarten: Extensions > Install from URL. Fügen Sie diese URL in das entsprechende Feld ein:

https://github.com/Mikubill/sd-webui-controlnet

Klicken Sie dann auf die Schaltfläche Install:

Wenn der Vorgang erfolgreich abgeschlossen ist, sollte die folgende Meldung erscheinen:

Installed into /home/usergpu/stable-diffusion-webui/extensions/sd-webui-controlnet. Use Installed tab to restart.

Starten wir die URL neu, indem wir auf der Registerkarte Installiert auf die Schaltfläche Anwenden und UI neu starten klicken:

Nach dem Neustart der Schnittstelle wird das neue ControlNet-Element mit vielen zusätzlichen Optionen angezeigt:

Schritt 3. OpenPose herunterladen

HF-Schlüssel hinzufügen

Lassen Sie uns einen SSH-Schlüssel generieren und hinzufügen, den Sie in Hugging Face verwenden können:

cd ~/.ssh && ssh-keygen

Wenn das Schlüsselpaar generiert ist, können Sie den öffentlichen Schlüssel im Terminalemulator anzeigen:

cat id_rsa.pub

Kopieren Sie alle Informationen, die mit ssh-rsa beginnen und mit usergpu@gpuserver enden, wie im folgenden Screenshot gezeigt:

Öffnen Sie einen Webbrowser, geben Sie https://huggingface.co/ in die Adresszeile ein, und drücken Sie Enter. Melden Sie sich bei Ihrem HF-Konto an und öffnen Sie die Profileinstellungen. Wählen Sie dann SSH and GPG Keys und klicken Sie auf die Schaltfläche Add SSH Key:

Füllen Sie Key name aus und fügen Sie den kopierten SSH Public key aus dem Terminal ein. Speichern Sie den Schlüssel, indem Sie Add key drücken:

Jetzt ist Ihr HF-Konto mit dem öffentlichen SSH-Schlüssel verknüpft. Der zweite Teil (privater Schlüssel) ist auf dem Server gespeichert. Der nächste Schritt ist die Installation einer speziellen Git-LFS-Erweiterung (Large File Storage), die für das Herunterladen großer Dateien wie Modelle neuronaler Netze verwendet wird.

Git LFS installieren

Als Nächstes müssen Sie eine spezielle Git LFS-Erweiterung (Large File Storage) installieren, die für das Herunterladen großer Dateien, wie z. B. Modelle neuronaler Netze, verwendet wird. Öffnen Sie Ihr Home-Verzeichnis:

cd ~/

Laden Sie das Shell-Skript herunter und führen Sie es aus. Dieses Skript installiert ein neues Drittanbieter-Repository mit git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Nun können Sie es mit dem Standard-Paketmanager installieren:

sudo apt-get install git-lfs

Lassen Sie uns git so konfigurieren, dass es unseren HF-Nickname verwendet:

git config --global user.name "John"

Und mit dem HF-E-Mail-Konto verknüpft:

git config --global user.email "john.doe@example.com"

Download des Repositorys

Wir empfehlen, wenn möglich, eine lokale Festplatte zum Herunterladen und Speichern von Modellen zu verwenden. Mehr dazu erfahren Sie in unserem Leitfaden Festplattenpartitionierung in Linux. Für dieses Beispiel haben wir ein SSD-Laufwerk mit dem Mountpoint /mnt/fastdisk verbunden. Wir machen es zum Eigentum des Standardbenutzers:

sudo chown usergpu:usergpu /mnt/fastdisk

Öffnen Sie das Verzeichnis:

cd /mnt/fastdisk

Klonen Sie das ControlNet-Repository von HuggingFace. Zuvor installiertes Git-LFS ersetzt automatisch Zeiger durch echte Dateien:

git clone git@hf.co:lllyasviel/ControlNet-v1-1

In diesem Beispiel fügen wir der Stable Diffusion WebUI nur ein Modell hinzu. Sie können jedoch alle verfügbaren Modelle aus dem Repository (~18 GB) kopieren:

cp /mnt/fastdisk/ControlNet-v1-1/control_v11p_sd15_openpose.pth /home/usergpu/stable-diffusion-webui/models/ControlNet/

Schritt 4. Generierungsprozess starten

Das derzeitige Modell ist recht einfach und liefert möglicherweise keine zufriedenstellenden Ergebnisse. Wir schlagen daher vor, es durch ein eigenes Modell zu ersetzen. Eine Anleitung dazu finden Sie in diesem Artikel: Stabile Diffusionsmodelle: Anpassung und Optionen. Für dieses Beispiel haben wir RealisticVision v6.0 B1 heruntergeladen.

Wenn Sie Ihr erstes Bild mit OpenPose erstellen möchten, öffnen Sie die Registerkarte ControlNet, wählen Sie OpenPose, markieren Sie Enable und Allow Preview. Klicken Sie dann auf Upload, um ein Bild mit der gewünschten Pose hinzuzufügen:

Sie können das System auffordern, eine Posenvorschau zu erstellen, indem Sie auf die Schaltfläche mit dem Explosionssymbol klicken:

Auf der linken Seite wird das Originalbild angezeigt. Rechts sehen Sie das "Skelett", das die vom neuronalen Netzmodell erkannte Pose darstellt:

Jetzt können Sie die Haupteingabeaufforderung eingeben, zum Beispiel "dancing bear, by Pixar" oder "dancing fox, by Pixar", und auf die Schaltfläche Generate klicken. Nach ein paar Sekunden erhalten Sie ein Ergebnis wie dieses:

Das System versucht, anhand des "Skeletts" aus dem Originalbild ein neues Bild zu erstellen. In manchen Fällen ist die Pose nicht genau, aber das lässt sich leicht durch manuelle Bearbeitung des "Skeletts" korrigieren.

Schritt 5. Ändern der Pose

Auch wenn es wie Zauberei aussieht, ist das Modell nicht perfekt, und gelegentliche Fehler können sich auf das endgültige Bild auswirken. Um Probleme bei der Bilderstellung zu vermeiden, haben Sie die Möglichkeit, das "Skelett" manuell anzupassen, indem Sie auf die Schaltfläche Edit klicken:

Im mitgelieferten Editor können Sie die Pose einfach durch Ziehen und Ablegen anpassen oder unerwünschte Punkte mit einem Rechtsklick entfernen. Danach klicken Sie einfach auf die Schaltfläche Send pose to ControlNet und die neue Pose wird übernommen:

Über OpenPose hinaus bietet ControlNet eine Vielzahl von Tools zur Anpassung und Perfektionierung Ihrer Ergebnisse. Darüber hinaus gewährleisten die von LeaderGPU bereitgestellten dedizierten Server einen schnellen und bequemen Prozess.

Siehe auch:

Fooocus: Überdenken von SD und MJ

Tue, 21 Jan 2025 10:36:52 +0100

Das Aufkommen von Stable Diffusion und MidJourney hat unser Verständnis für das Potenzial generativer neuronaler Netze revolutioniert. Diese Werkzeuge haben uns eine neue Perspektive auf den Prozess der Bilderzeugung und das Ausmaß, in dem wir ihn manipulieren können, eröffnet. Der primäre Ansatz besteht darin, dem System Hinweise auf das gewünschte Ergebnis zu geben. Im Wesentlichen heben wir drei wichtige Aspekte hervor: Objekt, Stil und Umgebung.

Zusätzliche Aufforderungen, die spezifischere Anweisungen geben, wie z. B. die gewünschte Komposition, die Art der Kamera/Objektiv und die Farbgebung, sind ebenfalls wichtig, aber nicht unerlässlich. Je umfassender die Anweisungen sind, desto einfacher ist es für das neuronale Netz, sie zu verarbeiten. Im professionellen Bereich hat sich sogar die Rolle eines Souffleurs herausgebildet. Diese Rolle kann jedoch leicht durch die gleichen generativen neuronalen Netze ersetzt werden. Durch die Kombination von Bild- und Texterstellungsfähigkeiten können wir zusätzliche Prompts generieren, um ein optimales Ergebnis zu erzielen.

Dies ist das grundlegende Konzept von Fooocus. Es integriert das XL Stable Diffusion Modell und einen GPT2-basierten Prompt-Generator, der Ihren einfachen Prompt bereichert und detailliert. Darüber hinaus ist Fooocus mit verschiedenen Verbesserungen und Erweiterungen ausgestattet. Diese Funktionen erleichtern die Erzeugung spektakulärer Bilder über eine einfache Schnittstelle, die keine komplexen Tools enthält. Lassen Sie uns in seine Funktionalität eintauchen und Fooocus auf einem LeaderGPU Dedicated Server installieren.

Voraussetzungen

Beginnen Sie mit den Installationsvoraussetzungen und starten Sie danach neu:

sudo apt update && sudo apt -y upgrade && sudo ubuntu-drivers autoinstall && sudo shutdown -r now

Laden Sie das Shell-Skript herunter, das Anaconda für die Verwaltung virtueller Umgebungen installiert:

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

Setzen Sie das Ausführungskennzeichen und geben Sie den Datenzugriff frei:

chmod a+x Anaconda3-2023.09-0-Linux-x86_64.sh

Führen Sie das Installationsskript aus:

./Anaconda3-2023.09-0-Linux-x86_64.sh

Nachdem der Prozess abgeschlossen ist, empfehlen wir, die SSH-Sitzung zu trennen und die Portweiterleitung vorzubereiten. Sie müssen Port 7865 vom entfernten Server an eine lokale Loopback-Adresse weiterleiten, 127.0.0.1:7865. Weitere Informationen finden Sie in einem unserer früheren Leitfäden: Stabile Video-Diffusion. Stellen Sie dann die Verbindung wieder her und fahren Sie mit dem Klonen des Projekt-Repositorys auf GitHub fort.

Fooocus installieren

git clone https://github.com/lllyasviel/Fooocus.git

Wechseln Sie in das Verzeichnis Fooocus:

cd Fooocus

Erstellen Sie eine virtuelle Umgebung mit Anaconda und der vom Projektautor vorbereiteten YAML-Konfiguration:

conda env create -f environment.yaml

Lassen Sie uns unsere Basisumgebung in eine neu erstellte Umgebung ändern:

conda activate fooocus

Der nächste Schritt ist die Installation der Python-Bibliotheken:

pip install -r requirements_versions.txt

Nun ist alles bereit für den Start:

Fooocus starten

python entry_with_update.py

Der erste Start kann einige Zeit in Anspruch nehmen, da die Anwendung alle für den Betrieb erforderlichen Dateien prüft und herunterlädt. Sie sollten in der Zwischenzeit eine Tasse Kaffee trinken. Sobald der Vorgang abgeschlossen ist, öffnen Sie Ihren Browser und geben Sie die folgende URL in die Adressleiste ein:

http://127.0.0.1:7865

Geben Sie Ihre einfache Eingabeaufforderung ein und klicken Sie auf die Schaltfläche Generate. Wenn Sie mehr Kontrolle wünschen, kreuzen Sie Advanced an und wählen Sie die erforderlichen Optionen:

Der eigentliche Zauber spielt sich hinter den Kulissen ab. In dem Moment, in dem Sie auf die Schaltfläche Generate klicken, wird Ihre Eingabeaufforderung an das GPT2-basierte Sprachmodell übertragen. Dieses Modell wandelt Ihre kurze Eingabeaufforderung in eine Mischung aus elaborativen positiven und negativen Aufforderungen um. Diese Mischung wird anschließend in das Stable Diffusion XL-Modell eingegeben, das auf die Nachahmung des MidJourney-Stils abgestimmt ist. Auf diese Weise kann selbst eine kurze Aufforderung beeindruckende Ergebnisse erzielen.

Natürlich gibt es keine Beschränkung für das Schreiben eigener Prompts. Nach mehreren Durchläufen wird jedoch deutlich, dass die generierten Inhalte auch ohne diese Einschränkung faszinierend und vielfältig bleiben.

Siehe auch:

Blender Remote-Rendering mit Flamenco

Tue, 21 Jan 2025 09:47:24 +0100

Wenn das Rendern umfangreicher Szenen in Blender zu viel Zeit Ihres Teams in Anspruch nimmt, haben Sie zwei Möglichkeiten: Entweder Sie rüsten den Computer jedes Teammitglieds auf oder Sie lagern das Rendering an eine spezielle Farm aus. Viele Unternehmen bieten fertige Rendering-Lösungen an, aber wenn Sie die volle Kontrolle über die Infrastruktur benötigen, sind diese Lösungen möglicherweise nicht die zuverlässigste Option.

Ein alternativer Ansatz könnte der Aufbau einer hybriden Infrastruktur sein. In diesem Fall würden Sie die Datenspeicherung und die Verwaltung der Rendering-Farm innerhalb Ihrer bestehenden Infrastruktur belassen. Das einzige Element, das sich außerhalb befinden würde, wären die gemieteten GPU-Server, auf denen das Rendering durchgeführt würde.

Im Allgemeinen sieht die Rendering-Farm-Infrastruktur für Blender wie folgt aus:

Hier haben wir einen zentralen Manager Knoten, der alle Prozesse organisiert. Er erhält Rendering-Aufgaben von Benutzern über einen bestimmten Blender Add-on und verschiebt alle notwendigen Dateien zu Shared Storage. Dann verteilt Manager die Aufgaben an Worker nodes. Diese erhalten einen Auftrag, der alle Informationen darüber enthält, wo der Worker Dateien zum Rendern finden kann und was mit den erhaltenen Ergebnissen zu tun ist. Um dieses Schema zu implementieren, können Sie eine völlig freie und quelloffene Anwendung namens Flamenco verwenden. In diesem Leitfaden zeigen wir, wie Sie alle Knoten vorbereiten, insbesondere Manager und Worker.

Für den Knoten Storage gibt es keine besonderen Anforderungen. Er kann mit jedem Betriebssystem verwendet werden, das SMB/CIFS- oder NFS-Protokolle unterstützt. Die einzige Voraussetzung ist, dass das Speicherverzeichnis eingehängt und für das Betriebssystem zugänglich sein muss. In Ihrer Infrastruktur kann dies ein beliebiger gemeinsamer Ordner sein, der für alle Knoten zugänglich ist.

Jeder Knoten hat unterschiedliche IP-Adressen, und der Wireguard VPN Server wird ein zentraler Punkt sein, der sie zu einem L2-Netzwerk zusammenführt. Dieser Server, der sich an der Außengrenze befindet, ermöglicht es Ihnen, ohne Änderungen an der bestehenden NAT-Richtlinie zu arbeiten.

Für dieses Beispiel erstellen wir die folgende gemischte Konfiguration:

10.0.0.1 - Wireguard VPN server (virtueller Server eines beliebigen Infrastrukturanbieters) mit einer externen IP;
10.0.0.2 - Worker node (dedizierter Server von LeaderGPU) mit einer externen IP;
10.0.0.3 - Manager node (virtueller Server im Büronetzwerk), der sich hinter NAT befindet;
10.0.0.4 - Storage node (virtueller Server im Büronetzwerk), der sich hinter NAT befindet;
10.0.0.5 - User node (Verbraucher-Laptop im Büronetz) hinter NAT.

Schritt 1. Wireguard

VPN-Server

Sie können Wireguard manuell installieren und konfigurieren, indem Sie eine offizielle Anleitung und Beispiele verwenden. Es gibt jedoch eine einfachere Alternative: ein inoffizielles Skript von einem Softwareentwickler aus Paris (Stanislas alias angristan).

Laden Sie das Skript von GitHub herunter:

wget https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

Machen Sie es ausführbar:

sudo chmod +x wireguard-install.sh

Ausführen:

sudo ./wireguard-install.sh

Folgen Sie den Anweisungen und legen Sie den IP-Adressbereich 10.0.0.1/24 fest. Das System wird Sie auffordern, sofort eine Konfigurationsdatei für den ersten Client zu erstellen. Laut Plan wird dieser Client der Arbeitsknoten mit dem Namen Worker und der Adresse 10.0.0.2 sein. Wenn das Skript abgeschlossen ist, erscheint eine Konfigurationsdatei im Stammverzeichnis: /root/wg0-client-Worker.conf.

Führen Sie den folgenden Befehl aus, um diese Konfiguration anzuzeigen:

cat /home/usergpu/wg0-client-Worker.conf

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0

Führen Sie das Installationsskript erneut aus, um einen weiteren Client zu erstellen. Fügen Sie auf diese Weise alle künftigen Clients hinzu, und überprüfen Sie abschließend, ob alle Konfigurationsdateien erstellt wurden:

cd ~/

ls -l | grep wg0

-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Manager.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Storage.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-User.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:58 wg0-client-Worker.conf

VPN-Klienten

VPN-Clients umfassen alle Knoten, die mit einem einzigen Netzwerk verbunden sein müssen. In unserer Anleitung bezieht sich dies auf den Manager-Knoten, den Storage-Knoten, den Client-Knoten (bei Verwendung von Linux) und die Worker-Knoten. Wenn der VPN-Server auf einem Worker-Knoten läuft, muss er nicht als Client konfiguriert werden (dieser Schritt kann übersprungen werden).

Aktualisieren Sie das Paket-Cache-Repository und installieren Sie dann die Pakete Wireguard und CIFS-Unterstützung:

sudo apt update && sudo apt -y install wireguard cifs-utils

Erhöhen Sie die Rechte auf Superuser:

sudo -i

Öffnen Sie das Wireguard-Konfigurationsverzeichnis:

cd /etc/wireguard

Führen Sie den Befehl umask aus, so dass nur der Superuser Zugriff auf die Dateien in diesem Verzeichnis hat:

umask 077

Erzeugen Sie einen privaten Schlüssel und speichern Sie ihn in einer Datei:

wg genkey > private-key

Erzeugen Sie einen öffentlichen Schlüssel mit dem privaten Schlüssel:

wg pubkey > public-key < private-key

Erstellen Sie eine Konfigurationsdatei:

nano /etc/wireguard/wg0.conf

Fügen Sie Ihre eigene, für diesen Client erstellte Konfiguration ein:

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [SERVER_IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0
PersistentKeepalive = 1

Vergessen Sie nicht, auf jedem Knoten, der sich hinter NAT befindet, die Option PersistentKeepalive = 1 hinzuzufügen (wobei 1 für 1 Sekunde steht). Sie können diesen Zeitraum experimentell wählen. Der von den Autoren von Wireguard empfohlene Wert ist 25. Speichern Sie die Datei und beenden Sie sie mit der Tastenkombination CTRL + X und der Taste Y zur Bestätigung.

Wenn Sie den Internetverkehr durchleiten möchten, setzen Sie AllowedIPs auf 0.0.0.0/0,::/0

Melden Sie sich dann mit dem Root-Konto ab:

exit

Starten Sie die Verbindung mit systemctl:

sudo systemctl start wg-quick@wg0.service

Prüfen Sie, ob alles in Ordnung ist und der Dienst erfolgreich gestartet wurde:

sudo systemctl status wg-quick@wg0.service

● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2023-10-23 09:47:53 UTC; 1h 45min ago
  Docs: man:wg-quick(8)
        man:wg(8)
        https://www.wireguard.com/
        https://www.wireguard.com/quickstart/
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8
Process: 4128 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
Main PID: 4128 (code=exited, status=0/SUCCESS)
  CPU: 76ms

Wenn Sie unter Ubuntu 22.04 eine Fehlermeldung wie "resolvconf: command not found" erhalten, erstellen Sie einfach einen Symbol-Link:

sudo ln -s /usr/bin/resolvectl /usr/local/bin/resolvconf

Aktivieren Sie den neuen Dienst, damit er sich beim Booten des Betriebssystems automatisch verbindet:

sudo systemctl enable wg-quick@wg0.service

Jetzt können Sie die Konnektivität überprüfen, indem Sie Echo-Pakete senden:

ping 10.0.0.1

PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=145 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=4 ttl=64 time=72.2 ms
--- 10.0.0.1 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 71.981/90.230/144.750/31.476 ms

Schritt 2. NAS-Knoten

Verbinden Sie sich mit dem VPN-Server unter Verwendung der Anleitung aus Schritt 1. Installieren Sie dann die Server- und Client-Samba-Pakete:

sudo apt install samba samba-client

Sichern Sie Ihre Standardkonfiguration:

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

Erstellen Sie ein Verzeichnis, das als Freigabe verwendet werden soll:

sudo mkdir /mnt/share

Erstellen Sie eine neue Benutzergruppe, die Zugriff auf die neue Freigabe erhalten soll:

sudo groupadd smbusers

Fügen Sie einen bestehenden Benutzer zu der erstellten Gruppe hinzu:

sudo usermod -aG smbusers user

Legen Sie ein Passwort für diesen Benutzer fest. Dieser Schritt ist notwendig, da das Systempasswort und das Samba-Passwort unterschiedliche Entitäten sind:

sudo smbpasswd -a $USER

Entfernen Sie die Standardkonfiguration:

sudo rm /etc/samba/smb.conf

Und erstellen Sie eine neue:

sudo nano /etc/samba/smb.conf

[global]
workgroup = WORKGROUP
security = user
map to guest = bad user
wins support = no
dns proxy = no
[private]
path = /mnt/share
valid users = @smbusers
guest ok = no
browsable = yes
writable = yes

Speichern Sie die Datei und testen Sie die neuen Parameter:

testparm -s

Starten Sie beide Samba-Dienste neu:

sudo service smbd restart

sudo service nmbd restart

Geben Sie schließlich die Erlaubnis, den Ordner freizugeben:

sudo chown user:smbusers /mnt/share

Schritt 3. Verbindung mit dem Samba-Client

Alle Knoten in Flamenco verwenden ein gemeinsames Verzeichnis, das sich unter /mnt/flamenco befindet. Sie müssen dieses Verzeichnis auf jedem Knoten einhängen, bevor Sie die Skripte flamenco-client oder flamenco-manager ausführen. In diesem Beispiel verwenden wir einen auf LeaderGPU gehosteten Arbeitsknoten mit dem Benutzernamen usergpu. Bitte ersetzen Sie diese Angaben durch Ihre eigenen, falls sie abweichen.

Erstellen Sie eine versteckte Datei, in der Sie die Anmeldeinformationen für die SMB-Freigabe speichern können:

nano /home/usergpu/.smbcredentials

Geben Sie diese beiden Zeichenfolgen ein:

username=user # your Samba username
password=password # your Samba password

Speichern Sie diese Datei und beenden Sie sie. Sichern Sie dann diese Datei, indem Sie die Zugriffsrechte ändern:

sudo chmod 600 /home/usergpu/.smbcredentials

Erstellen Sie ein neues Verzeichnis, das als Einhängepunkt für den entfernten Speicher verwendet werden kann:

sudo mkdir /mnt/flamenco

Und machen Sie den Benutzer zum Eigentümer dieses Verzeichnisses:

sudo chown usergpu:users /mnt/flamenco

Das Einzige, was noch fehlt, ist, dass das Netzwerkverzeichnis automatisch eingehängt wird:

sudo nano /etc/systemd/system/mnt-flamenco.mount

[Unit]
Description=Mount Remote Storage
[Mount]
What=//10.0.0.4/private
Where=/mnt/flamenco
Type=cifs
Options=mfsymlinks,credentials=/home/usergpu/.smbcredentials,uid=usergpu,gid=users
[Install]
WantedBy=multi-user.target

Fügen Sie Ihrer VPN-Konfiguration im Abschnitt [Interface] zwei Zeilen hinzu:

sudo -i

nano /etc/wireguard/wg0.conf

…
PostUp = ping 10.0.0.4 -c 4 && systemctl start mnt-flamenco.mount
PostDown = systemctl stop mnt-flamenco.mount
…

Starten Sie den Server neu:

sudo shutdown -r now

Überprüfen Sie, ob die Dienste geladen sind und das gemeinsame Verzeichnis erfolgreich gemountet wurde:

df -h

Filesystem          Size  Used Avail Use% Mounted on
tmpfs                35G  3.3M   35G   1% /run
/dev/sda2            99G   18G   77G  19% /
tmpfs               174G     0  174G   0% /dev/shm
tmpfs               5.0M     0  5.0M   0% /run/lock
tmpfs                35G  8.0K   35G   1% /run/user/1000
//10.0.0.4/private   40G  9.0G   31G  23% /mnt/flamenco

Schritt 4. Manager-Knoten

Richten Sie eine VPN-Verbindung anhand der Anleitung aus Schritt 1 ein. Beenden Sie den VPN-Dienst, bevor Sie fortfahren:

sudo systemctl stop wg-quick@wg0.service

Bereiten Sie sich vor. Automatisches Einbinden der für das CIFS-Protokoll erforderlichen Dienstprogramme:

sudo apt -y install cifs-utils

Der nächste wichtige Schritt ist die Installation von Blender. Sie können dazu den standardmäßigen APT-Paketmanager verwenden, aber damit wird höchstwahrscheinlich eine der älteren Versionen installiert (weniger als v3.6.4). Lassen Sie uns Snap verwenden, um die neueste Version zu installieren:

sudo snap install blender --classic

Überprüfen Sie die installierte Version mit dem folgenden Befehl:

blender --version

Blender 4.4.3
build date: 2025-04-29
build time: 15:12:13
build commit date: 2025-04-29
build commit time: 14:09
build hash: 802179c51ccc
build branch: blender-v4.4-release
build platform: Linux
build type: Release
…

Wenn Sie eine Fehlermeldung erhalten, die auf fehlende Bibliotheken hinweist, installieren Sie diese einfach. Alle diese Bibliotheken sind im XOrg-Paket enthalten:

sudo apt -y install xorg

Laden Sie die Anwendung herunter:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Entpacken Sie das heruntergeladene Archiv:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Wechseln Sie in das erstellte Verzeichnis:

cd flamenco-3.7-linux-amd64/

Und starten Sie Flamenco zum ersten Mal:

./flamenco-manager

Öffnen Sie die folgende Adresse in Ihrem Web-Browser: http://10.0.0.3:8080/. Klicken Sie auf die Schaltfläche Let's go. Geben Sie /mnt/flamenco in das entsprechende Feld ein, und klicken Sie dann auf Next:

Flamenco wird versuchen, die ausführbare Datei von Blender zu finden. Wenn Sie Blender von Snap aus installiert haben, wird der Pfad /snap/bin/blender sein. Überprüfen Sie diesen Punkt und klicken Sie auf Next:

Überprüfen Sie die Zusammenfassung und klicken Sie auf Confirm:

Kehren Sie zur SSH-Sitzung zurück und verwenden Sie die Tastenkombination Ctrl + C, um die Anwendung zu unterbrechen. Beim ersten Start wird die Konfigurationsdatei flamenco-manager.yaml erzeugt. Fügen wir einige Optionen in den Abschnitten variables und blenderArgs hinzu:

nano flamenco-manager.yaml

# Configuration file for Flamenco.
# For an explanation of the fields, refer to flamenco-manager-example.yaml
#
# NOTE: this file will be overwritten by Flamenco Manager's web-based configuration system.
#
# This file was written on 2023-10-17 12:41:28 +00:00 by Flamenco 3.7
_meta:
  version: 3
manager_name: Flamenco Manager
database: flamenco-manager.sqlite
listen: :8080
autodiscoverable: true
local_manager_storage_path: ./flamenco-manager-storage
shared_storage_path: /mnt/flamenco
shaman:
  enabled: true
  garbageCollect:
    period: 24h0m0s
    maxAge: 744h0m0s
    extraCheckoutPaths: []
task_timeout: 10m0s
worker_timeout: 1m0s
blocklist_threshold: 3
task_fail_after_softfail_count: 3
variables:
  blender:
    values:
    - platform: linux
      value: blender
    - platform: windows
      value: blender
    - platform: darwin
      value: blender
  storage:
    values:
    is_twoway: true
    values:
    - platform: linux
      value: /mnt/flamenco
    - platform: windows
      value: Z:\
    - platform: darwin
      value: /Volumes/shared/flamenco
  blenderArgs:
    values:
    - platform: all
      value: -b -y -E CYCLES -P gpurender.py

Der erste zusätzliche Block beschreibt zusätzliche Two-way-Variablen, die für Multiplattform-Farmen benötigt werden. Damit wird das Hauptproblem mit Schrägstrichen und Pfaden gelöst. Unter Linux verwenden wir das Schrägstrich-Symbol (/) als Trennzeichen, aber unter Windows verwenden wir das Backslash-Symbol (\). Hier erstellen wir die Ersetzungsregel für alle verfügbaren Alternativen: Linux, Windows und macOS (Darwin).

Wenn Sie eine Netzwerkfreigabe unter Windows einbinden, müssen Sie einen Laufwerksbuchstaben auswählen. Zum Beispiel wird unser Storage mit dem Buchstaben Z: gemountet. Die Ersetzungsregel teilt dem System mit, dass für die Windows-Plattform der Pfad /mnt/flamenco unter Z:\ zu finden sein wird. Für macOS lautet dieser Pfad /Volumes/shared/flamenco.

Sehen Sie sich den zweiten hinzugefügten Block an. Dieser weist Blender an, die Cycles-Rendering-Engine zu verwenden und ruft ein einfaches Python-Skript, gpurender.py, auf, wenn Blender ausgeführt wird. Dies ist ein einfacher Trick, um die GPU anstelle der CPU zu verwenden. Es gibt keine Standardoption, um dies direkt zu tun. Sie können nicht blender --use-gpu oder etwas Ähnliches aufrufen. Sie können jedoch jedes externe Python-Skript mit der Option -P aufrufen. Dieser Befehl weist Worker an, ein Skript im lokalen Verzeichnis zu suchen und es auszuführen, wenn der zugewiesene Job die ausführbare Datei von Blender aufruft.

Jetzt können wir die Kontrolle über die Anwendung an das systemd init-Subsystem delegieren. Informieren wir das System über den Ort des Arbeitsverzeichnisses, die ausführbare Datei und die zum Starten erforderlichen Benutzerrechte. Erstellen Sie eine neue Datei:

sudo nano /etc/systemd/system/flamenco-manager.service

Füllen Sie sie mit den folgenden Zeichenketten:

[Unit]
Description=Flamenco Manager service
[Service]
User=user
WorkingDirectory=/home/user/flamenco-3.7-linux-amd64
ExecStart=/home/user/flamenco-3.7-linux-amd64/flamenco-manager
Restart=always
[Install]
WantedBy=multi-user.target

Speichern Sie die Datei und beenden Sie den nano-Texteditor.

sudo systemctl daemon-reload

sudo systemctl start flamenco-manager.service

sudo systemctl status flamenco-manager.service

● flamenco-manager.service - Flamenco Manager service
Loaded: loaded (/etc/systemd/system/flamenco-manager.service; disabled; vendor preset: enabled)
Active: active (running) since Tue 2023-10-17 11:03:50 UTC; 7s ago
Main PID: 3059 (flamenco-manage)
 Tasks: 7 (limit: 4558)
  Memory: 28.6M
     CPU: 240ms
CGroup: /system.slice/flamenco-manager.service
        └─3059 /home/user/flamenco-3.7-linux-amd64/flamenco-manager

Aktivieren Sie den automatischen Start beim Hochfahren des Systems:

sudo systemctl enable flamenco-manager.service

Schritt 5. Arbeiterknoten

Stellen Sie eine Verbindung zum VPN-Server her, indem Sie die Anleitung aus Schritt 1 verwenden und die Freigabe aus Schritt 3 einhängen. Beenden Sie den VPN-Dienst, bevor Sie fortfahren:

sudo snap install blender --classic

Moderne *.blend-Dateien werden mit dem Zstandard-Algorithmus komprimiert. Um Fehler zu vermeiden, ist es wichtig, diesen Algorithmus zu unterstützen:

sudo apt -y install python3-zstd

Laden Sie die Anwendung herunter:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Entpacken Sie das heruntergeladene Archiv:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Navigieren Sie zu dem erstellten Verzeichnis:

cd flamenco-3.7-linux-amd64/

Erstellen Sie ein zusätzliches Skript, das das GPU-Rendering aktiviert, wenn Flamenco-Jobs ausgeführt werden:

nano gpurender.py

import bpy
def enable_gpus(device_type, use_cpus=False):
    preferences = bpy.context.preferences
    cycles_preferences = preferences.addons["cycles"].preferences
    cycles_preferences.refresh_devices()
    devices = cycles_preferences.devices
    if not devices:
        raise RuntimeError("Unsupported device type")
    activated_gpus = []
    for device in devices:
        if device.type == "CPU":
            device.use = use_cpus
        else:
            device.use = True
            activated_gpus.append(device.name)
            print('activated gpu', device.name)
    cycles_preferences.compute_device_type = device_type
    bpy.context.scene.cycles.device = "GPU"
    return activated_gpus
enable_gpus("CUDA")

Speichern Sie die Datei und beenden Sie sie. Erstellen Sie dann einen separaten Dienst, um Flamenco über systemd auszuführen:

sudo nano /etc/systemd/system/flamenco-worker.service

[Unit]
Description=Flamenco Worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu/flamenco-3.7-linux-amd64
ExecStart=/home/usergpu/flamenco-3.7-linux-amd64/flamenco-worker
Restart=always
[Install]
WantedBy=multi-user.target

Laden Sie die Konfiguration neu und starten Sie den neuen Dienst:

sudo systemctl daemon-reload

sudo systemctl start flamenco-worker.service

sudo systemctl status flamenco-worker.service

● flamenco-worker.service - Flamenco Worker service
Loaded: loaded (/etc/systemd/system/flamenco-worker.service; enabled; preset: enabled)
Active: active (running) since Tue 2023-10-17 13:56:18 EEST; 47s ago
Main PID: 636 (flamenco-worker)
 Tasks: 5 (limit: 23678)
Memory: 173.9M
   CPU: 302ms
CGroup: /system.slice/flamenco-worker.service
        └─636 /home/user/flamenco-3.7-linux-amd64/flamenco-worker

Aktivieren Sie den automatischen Start beim Hochfahren des Systems:

sudo systemctl enable flamenco-worker.service

Schritt 6. Benutzerknoten

Der Benutzerknoten kann mit jedem Betriebssystem verwaltet werden. In dieser Anleitung zeigen wir, wie man einen Knoten mit Windows 11 und 4 notwendigen Komponenten einrichtet:

VPN-Verbindung
Gemountetes Remote-Verzeichnis
Blender installiert
Flamenco-Zusatzmodul

Laden Sie Wireguard von der offiziellen Website herunter und installieren Sie es. Erstellen Sie eine neue Textdatei und fügen Sie die Konfiguration ein, die in Schritt 1 für den Client erstellt wurde. Benennen Sie die Datei in flamenco.conf um und fügen Sie sie in Wireguard über die Schaltfläche Add tunnel hinzu:

Stellen Sie eine Verbindung zu Ihrem Server her, indem Sie auf die Schaltfläche Activate klicken:

Mounten wir ein entferntes Verzeichnis. Klicken Sie mit der rechten Maustaste auf This PC und wählen Sie Map network drive…

Wählen Sie Z: als Laufwerksbuchstaben, geben Sie die Adresse der Samba-Freigabe \\10.0.0.4\private ein und vergessen Sie nicht, Connect using different credentials anzukreuzen. Klicken Sie dann auf Finish. Das System fordert Sie auf, einen Benutzernamen und ein Passwort für die Freigabe einzugeben. Daraufhin wird das Netzwerkverzeichnis als Laufwerk Z: eingebunden.

Laden Sie Blender von der offiziellen Website herunter und installieren Sie es. Öffnen Sie dann die URL http://10.0.0.3:8080/flamenco3-addon.zip und installieren Sie das Flamenco Add-on. Aktivieren Sie es in den Einstellungen: Edit > Preferences > Add-ons. Markieren Sie System: Flamenco 3, geben Sie die Manager-URL http://10.0.0.3:8080 ein und klicken Sie auf die Schaltfläche Aktualisieren. Das System wird sich mit dem Manager-Knoten verbinden und die Speichereinstellungen automatisch laden:

Öffnen Sie die Datei, die Sie rendern möchten. Wählen Sie auf der Registerkarte Scene die Option Cycles aus der Dropdown-Liste Render Engine. Vergessen Sie nicht, die Datei zu speichern, da diese Einstellungen direkt in der *.blend-Datei gespeichert werden:

Scrollen Sie nach unten und suchen Sie den Abschnitt Flamenco 3. Klicken Sie auf Fetch job types, um eine Liste der verfügbaren Typen anzuzeigen. Wählen Sie Simple Blender Render aus der Dropdown-Liste und legen Sie weitere Optionen fest, z. B. die Anzahl der Frames, die Chunk-Größe und den Ausgabeordner. Klicken Sie schließlich auf Submit to Flamenco:

Das Flamenco-Add-on erstellt einen neuen Auftrag und lädt eine Blend-Datei in den gemeinsamen Speicher hoch. Das System übergibt den Auftrag an einen verfügbaren Worker und startet den Rendering-Prozess:

Wenn Sie die Auslastung der GPUs mit nvtop oder ähnlichen Programmen überprüfen, zeigt dies, dass alle GPUs Rechenaufgaben haben:

Sie finden das Ergebnis in einem Verzeichnis, das Sie im vorherigen Schritt ausgewählt haben. Beispiel hier (Ripple Dreams von James Redmond)

Siehe auch:

Photogrammetrie mit Meshroom

Tue, 21 Jan 2025 09:38:44 +0100

Photogrammetrie ist eine Methode zur Umwandlung physischer Objekte in dreidimensionale digitale Modelle, die mit 3D-Software bearbeitet werden können. Für diesen Prozess werden in der Regel spezielle Geräte, so genannte 3D-Scanner, verwendet, die es in zwei Haupttypen gibt: optische und Laser-Scanner.

Optische Scanner verwenden häufig eine oder mehrere Digitalkameras und eine spezielle Beleuchtung, um das Objekt während des Scannens gleichmäßig zu beleuchten. Dies ermöglicht die Erstellung eines 3D-Modells. Laserscanner hingegen verwenden Laserstrahlen. Diese Geräte senden mehrere Laserstrahlen aus und messen die Zeit, die jeder Strahl braucht, um vom Objekt zurück zu prallen. Anhand dieser Daten und der Informationen von Positionssensoren berechnet der Scanner die Entfernung zu jedem Punkt des Objekts. So entsteht eine "Punktwolke", die die Grundlage für das 3D-Modell bildet.

Punktwolke

Um das zukünftige Gerüst eines Objekts zu erstellen, muss das System die Koordinaten jedes Scheitelpunkts im dreidimensionalen Raum kennen. Die Menge der Scheitelpunkte wird als Punktwolke bezeichnet. Je mehr Scheitelpunkte es gibt, desto detaillierter wird das Objekt sein. Die Erstellung einer Punktwolke ist der erste und einer der wichtigsten Schritte bei der Erstellung eines 3D-Modells aus Fotos.

Es ist wichtig zu beachten, dass jeder Scheitelpunkt in der Punktwolke zunächst nicht mit anderen Scheitelpunkten verbunden ist. Dies ermöglicht eine einfache Filterung: die notwendigen Punkte werden beibehalten und der Rest wird entfernt, bevor das Netz des Objekts neu erstellt wird.

Mesh-Objekte

Ein Mesh-Objekt ist eine Art von 3D-Modell, das aus dreieckigen geometrischen Primitiven besteht, die oft als Meshes oder Polymeshes bezeichnet werden. Sobald Objektpunkte gebildet sind, kann die Anwendung unabhängig dreieckige Primitive aus ihnen zusammensetzen. Durch Verbinden dieser Primitive lässt sich ein 3D-Modell mit nahezu beliebiger Form erstellen. In diesem Stadium hat das Modell noch keine Farbe und bleibt unbemalt.

Die anschließende Texturierungsphase behebt dieses Problem.

Texturierung

In der letzten Phase wird die aus den Fotos extrahierte Bildtextur auf das vorbereitete Netzobjekt aufgetragen. Die Qualität der aufgenommenen Fotos und ihre Auflösung spielen hier eine wichtige Rolle. Ist sie niedrig, wird das Endergebnis nicht optimal aussehen. Wenn jedoch eine ausreichende Anzahl von Fotos in guter Qualität aufgenommen wurde, erhalten Sie am Ende ein vollständig fertiges 3D-Modell eines realen Objekts. Im Folgenden geben wir einige nützliche Tipps zur Vorbereitung der Originalfotos.

Kameraeinstellungen

Um Enttäuschungen bei Ihren ersten Versuchen, ein 3D-Modell aus Fotos zu erstellen, zu vermeiden, sollten Sie diese einfachen Grundregeln beachten. Jede dieser Regeln hilft Ihnen, Probleme zu vermeiden, die normalerweise bei der Erstellung von Mesh-Objekten auftreten.

Erstens: Verlassen Sie sich nicht auf die automatischen Einstellungen Ihrer Digitalkamera. Moderne Kameras versuchen, vier wichtige Parameter unabhängig voneinander auszugleichen:

ISO,
Weißabgleich,
Belichtungszeit,
Blende.

Im Automatikmodus können selbst geringfügige Änderungen der äußeren Bedingungen dazu führen, dass diese Einstellungen von Bild zu Bild variieren. Diese Abweichungen können zu spürbaren Unstimmigkeiten während der Texturierungsphase führen.

Um die Parameter über alle Bilder hinweg konsistent zu halten, verwenden Sie den Modus Manual (M). Die Blende ist hier eine entscheidende Einstellung. Je nach Objektiv sollten Sie eine Position anstreben, in der die Blende fast geschlossen ist. So erreichen Sie eine maximale Schärfentiefe: Je weniger offen die Blende ist, desto besser. Vermeiden Sie jedoch extreme Werte. Wenn Ihr Objektiv bis auf f/22 geschlossen werden kann, erzielen Sie gute Ergebnisse mit Werten zwischen f/11 und f/20.

^{Links f/11, rechts f/22}

Wenn Sie die Blende schließen, entsteht jedoch ein weiteres Problem: zu wenig Licht. Dem kann auf zwei Arten begegnet werden: durch Erhöhung der ISO-Empfindlichkeit oder durch Verlängerung der Belichtungszeit. Beide Methoden wirken sich auf das Endergebnis aus, wenn auch auf unterschiedliche Weise. Eine Erhöhung der ISO-Empfindlichkeit auf 6400 führt zu digitalem Rauschen im Bild, daher ist es am besten, die niedrigstmöglichen Werte zu verwenden. Für nahezu optimale Ergebnisse ist es sinnvoll, den ISO-Wert auf 100 einzustellen. Allerdings bleibt das Problem der unzureichenden Beleuchtung bestehen:

^{Links ISO 100, rechts ISO 6400}

Die effektivste Methode, um die Lichtmenge zu erhöhen, die bei schlechten Lichtverhältnissen auf den Kamerasensor trifft, ist die Verlängerung der Verschlusszeit. Je länger die Blende geöffnet bleibt, desto mehr Photonen treffen auf den Sensor, was zu einer besseren Bildqualität führt. Dieser Ansatz birgt jedoch ein Problem: Ohne Stativ kann eine Verschlusszeit von 1/50 Sekunde oder länger das Bild verwackeln. Die Verwendung eines Stativs beseitigt dieses Problem.

Der Weißabgleich ist der letzte entscheidende Parameter. Es ist wichtig, die automatische Einstellung zu deaktivieren und entweder ein voreingestelltes Profil (wie "Sonnentag") oder einen benutzerdefinierten Wert in Kelvin zu wählen. Eine gängige Einstellung ist zum Beispiel 5200K. Niedrigere Werte verschieben den Farbton in Richtung Gelb, während höhere Werte in Richtung Blau tendieren. Um zeitaufwändige Farbkorrekturen in der Nachbearbeitung zu vermeiden, sollten Sie für alle Fotos einer Serie das gleiche Weißabgleichsprofil verwenden.

^{WB-Profile. Links "Sonnentag", rechts "Auto"}

Zusammenfassend lässt sich sagen, dass Sie hochwertige Fotos für die Photogrammetrie aufnehmen sollten:

Verwenden Sie ein Stativ, wenn das Licht nicht ausreicht.
Schließen Sie die Blende fast auf ihr Minimum.
Stellen Sie den ISO-Wert auf das Minimum ein.
Wählen Sie eine Verschlusszeit, die das gewünschte Ergebnis liefert (oder verwenden Sie den integrierten Belichtungsmesser Ihrer Kamera).
Verwenden Sie die gleiche Voreinstellung für den Weißabgleich.

Aufnehmen von Fotos

Wir besprechen nun, wie viele Fotos Sie aus welchen Winkeln aufnehmen sollten. Die Art des Objekts und sein Hintergrund haben einen großen Einfluss auf das Endergebnis. Objekte ohne glänzende, transparente oder reflektierende Oberflächen sind ideal für die Photogrammetrie. In der Praxis müssen Objekte wie Fenster und Glas später oft in einem 3D-Editor korrigiert werden. Die allgemeine Aufnahmetechnik bleibt jedoch dieselbe.

Bei kleinen Objekten auf einer Oberfläche stellen Sie sich eine Kugel um das Objekt herum vor. Machen Sie Fotos, als ob Ihre Kamera das Objekt dreimal umkreist: einmal von unten, einmal in der Mitte und einmal von oben.

Es ist wichtig, dass das Objekt mindestens die Hälfte, besser drei Viertel jedes Bildes einnimmt. Versuchen Sie, sich dem Objekt physisch zu nähern, anstatt es zu vergrößern. Bei der Erstellung eines Wolkenpunkts benötigt die Software so viele Pixel wie möglich.

Denken Sie bei der Aufnahme daran, dass die Software die Einzelbilder zu einem einzigen Objekt kombiniert, um eine korrekte Geometrie zu erhalten. Nehmen Sie in der Regel mindestens drei Bilder aus jedem Winkel auf. Wenn Sie das Objekt im Bild zentriert haben, teilen Sie es gedanklich vertikal in drei gleiche Teile auf. Machen Sie drei Aufnahmen, die jeweils ein Drittel des Objekts abbilden. So entsteht die notwendige Überlappung, damit die Anwendung die Position jedes Punktes im 3D-Raum genau berechnen kann. Nachdem Sie das Objekt von allen möglichen Seiten und Winkeln fotografiert haben, können Sie mit der Vorbereitung der Software beginnen.

Meshroom installieren

Meshroom ist eine kostenlose, plattformübergreifende Anwendung, die alle Verarbeitungsschritte sequentiell durchführt und dabei CPU- und GPU-Ressourcen nutzt. Es kann zwar auf einem Standard-Heimcomputer ausgeführt werden, aber jeder Schritt kann zeitaufwändig sein. Für groß angelegte Projekte, die die 3D-Rekonstruktion zahlreicher Objekte beinhalten, wie z. B. die Erstellung einer beeindruckenden 3D-Szene, könnte die Anmietung eines dedizierten GPU-Servers eine praktische Lösung sein.

Betrachten wir einen LeaderGPU-Server mit der folgenden Konfiguration: 2 x NVIDIA® RTX™ 3090, 2 x Intel® Xeon® Silver 4210 (3.20 GHz), 128GB RAM. Wir werden Windows Server 2022 als Betriebssystem verwenden. Bevor Sie Meshroom installieren, müssen Sie einige vorbereitende Schritte durchführen:

Besuchen Sie die offizielle Website des Projekts, um Meshroom herunterzuladen. Entpacken Sie das resultierende Archiv, um eine gebrauchsfertige Anwendung zu finden, die keine zusätzliche Installation erfordert. Starten Sie Meshroom.exe, um zu beginnen.

Bilder hochladen

Das Hauptfenster der Anwendung ist in zwei Bereiche unterteilt: den oberen und den unteren. Der obere Bereich enthält die Bildgalerie, den Bildbetrachter und den 3D-Betrachter. Im unteren Bereich befinden sich der Grafik-Editor und der Task-Manager. Um zu beginnen, ziehen Sie Ihre aufgenommenen Fotos in den dafür vorgesehenen Bereich und legen Sie sie dort ab. Es werden sowohl komprimierte (z. B. JPG) als auch RAW-Dateiformate unterstützt. Es wird empfohlen, RAW-Dateien zu verwenden, da sie wesentlich mehr Daten für jedes Bild enthalten.

Bitte beachten Sie, dass Sie standardmäßig bereits über eine vorgefertigte Standard-Pipeline verfügen, die im Diagrammeditor schematisch dargestellt ist. Dies ist eines der wichtigsten Steuerelemente, mit dem Sie alle Aspekte der Bildverarbeitung in jeder Phase konfigurieren können. Sie können jeden Schritt manuell ausführen, indem Sie mit der rechten Maustaste klicken und Compute aus dem Dropdown-Menü auswählen.

Aber zum ersten Mal können Sie einfach auf die grüne Schaltfläche Start klicken, und die Anwendung wird alles für Sie erledigen. Sie werden aufgefordert, das Projekt zu speichern, damit Sie die Ergebnisse der Berechnung nicht versehentlich verlieren. Klicken Sie auf Save, geben Sie einen Namen und ein Verzeichnis an und speichern Sie das Projekt:

Anschließend überträgt die Anwendung alle Verarbeitungsschritte aus dem Diagrammeditor in den Task-Manager, der sie in einer bestimmten Reihenfolge abarbeitet. Um den Status jeder Stufe zu überprüfen, wählen Sie den entsprechenden Block im Diagrammeditor aus und klicken Sie auf die Schaltfläche Log in der unteren rechten Ecke des Bildschirms. Sie können auch in Echtzeit sehen, welche Stufe gerade bearbeitet wird:

Auf der rechten Seite sehen Sie die Punktwolke, die Sie erstellt haben. Das Endergebnis, das mit der Standard-Pipeline erstellt wurde, ist im Verzeichnis verfügbar:

[Your_Project_Path]\MeshroomCache\Texturing\[Random_Symbols]\texturedMesh.obj

Wenn Sie den Ausgabepfad im letzten Knoten der Pipeline vorher festlegen, wird das Objekt natürlich auf dem von Ihnen angegebenen Pfad landen. Anschließend können Sie es in einen beliebigen Texteditor importieren, um vor dem Rendern Oberflächen zu korrigieren, Lichtquellen hinzuzufügen und andere Effekte zu erzielen.

Integration

Auch wenn das ursprüngliche Ergebnis beeindruckend aussieht, muss es oft in einem 3D-Editor verfeinert werden. Meshroom vereinfacht diesen Prozess, indem es Ihnen ermöglicht, nicht nur das Modell, sondern auch die Punktewolke und die Kamerapositionen in Drittanbieter-Editoren wie Houdini oder Blender zu importieren. Im folgenden Abschnitt zeigen wir Ihnen, wie das geht.

Houdini

Eigentlich ist Meshroom eine benutzerfreundliche Schnittstelle für die AliceVision-Engine, die alle rechenrelevanten Operationen übernimmt. Diese Schnittstelle implementiert die entsprechende Pipeline und den Taskmanager. Wenn Sie Houdini verwenden, können Sie Ihre eigene Pipeline direkt in der Anwendung erstellen und sie zusammen mit anderen Tools verwenden, ohne Meshroom separat starten zu müssen.

Um loszulegen, ist es am besten, einen speziellen Launcher herunterzuladen und zu installieren, der Houdini-Updates und Plugins verwaltet. Als Nächstes fügen Sie das SideFX Labs-Plugin hinzu, das zahlreiche zusätzliche Tools bietet, darunter auch spezielle Nodes für AliceVision. Klicken Sie dazu auf die Schaltfläche + und wählen Sie dann Shelves:

Blättern Sie in der Liste nach unten und wählen Sie SideFX Labs, dann klicken Sie auf die Schaltfläche Update Toolset:

Um ein Plugin zu installieren, gehen Sie folgendermaßen vor: Klicken Sie auf die Schaltfläche Start Launcher, navigieren Sie zum Abschnitt Labs/Packages im linken Menü und wählen Sie Install packages. Daraufhin wird ein Fenster geöffnet, in dem Sie die zu installierenden Pakete auswählen können:

Wählen Sie das Production Build für Ihre Version von Houdini und klicken Sie auf Install. Starten Sie anschließend die Anwendung neu, um sicherzustellen, dass die neuen Effektsymbole am oberen Rand angezeigt werden:

Es ist wichtig zu beachten, dass Sie hier keine Erwähnung von AliceVision oder Meshlab finden werden. Das liegt daran, dass das entsprechende Plugin nur innerhalb der Geometriekontext-Pipeline funktioniert. Um dies zu überprüfen, klicken Sie auf das Symbol +, dann auf New Pane Tab Type und wählen Sie Network View:

Drücken Sie die Taste Tab und fügen Sie einen Knoten Geometry hinzu:

Doppelklicken Sie, um den erstellten Knoten zu öffnen, und geben Sie av auf Ihrer Tastatur ein. Das System zeigt sofort eine Liste der verfügbaren Knoten an, die mit den Symbolen Labs AV beginnen. Mit diesen Knoten können Sie die AliceVision-Engine steuern und sie in Ihre eigenen Pipelines integrieren:

Um eine geeignete Pipeline zu erstellen, lesen Sie die offizielle Dokumentation für das Plugin. Außerdem sollten Sie das AliceVision-Verzeichnis in die Liste der Umgebungsvariablen in der Datei houdini.env aufnehmen. Bei einer Standardinstallation mit dem Launcher befindet sich diese Datei normalerweise im Verzeichnis C:\Users\Administrator\Documents\houdini20.5\

Öffnen Sie die Datei houdini.env mit einem beliebigen Texteditor und fügen Sie die folgende Zeile ein:

ALICEVISION_PATH = [path to alicevision directory in Meshroom folder]

Wenn Sie zum Beispiel Meshroom im Stammverzeichnis des Laufwerks D: installiert haben, könnte Ihr Pfad wie folgt aussehen:

ALICEVISION_PATH = D:\Meshroom\aliceVision

Speichern Sie die Datei und starten Sie dann die Houdini-Anwendung neu.

Blender

Für Blender-Benutzer empfehlen wir das Plugin Meshroom2Blender. Es funktioniert zwar anders als das Houdini-Plugin, ermöglicht aber den Export der von Meshroom berechneten Punktwolken und Kamerapositionen nach Blender. Um auf den Plugin-Code zuzugreifen, öffnen Sie den Link in Ihrem Browser:

https://raw.githubusercontent.com/tibicen/meshroom2blender/master/view3d_point_cloud_visualizer.py

Speichern Sie den Code als view3d_point_cloud_visualizer.py in einem geeigneten Verzeichnis. Öffnen Sie dann Blender und navigieren Sie zu Edit - Preferences. Wählen Sie von dort aus die Registerkarte Add-ons:

Klicken Sie auf den Pfeil nach unten und wählen Sie Install from Disk:

In dem neu geöffneten Fenster navigieren Sie zu dem Verzeichnis, in dem Sie das Plugin gespeichert haben. Wählen Sie die Plugin-Datei aus und klicken Sie auf die Schaltfläche Install from Disk button:

Das Plugin ist nun installiert. Es wird empfohlen, die Anwendung neu zu starten. Nach dem Neustart sehen Sie das Element Point Cloud Visualizer im Anzeigemodus. Für das Plugin müssen Sie den Pfad zu einer Datei mit der Erweiterung .ply angeben:

Standardmäßig generiert Meshroom diese Art von Datei nicht. Um sie zu erstellen, öffnen Sie die Pipeline und fügen Sie den Knoten ConvertSfMFormat hinzu. Verwenden Sie die SfMData des Knotens StructureFromMotion als Eingabe. Geben Sie für die Ausgabe die Images Folder des Knotens Texturing an.

Der letzte Schritt besteht darin, das Format anzugeben. Klicken Sie auf SfM File Format im Knoten ConvertSfMFormat und wählen Sie ply aus der Dropdown-Liste:

Klicken Sie mit der rechten Maustaste auf den erstellten Knoten und wählen Sie Compute:

Sobald der Vorgang abgeschlossen ist, finden Sie die gewünschte Datei im Verzeichnis:

[Your_Project_Path]\MeshroomCache\ConvertSfMFormat\[Random_Symbols]\sfm.ply

Du kannst sie auf zwei Arten in Blender laden: über das oben erwähnte Plugin oder über den Standard-Importprozess File - Import - Stanford PLY (.ply):

Für weitere Informationen zur Verwendung dieses Plugins empfehlen wir, das Projekt-Repository oder eine spezialisierte Web-Ressource zu konsultieren.

Schlussfolgerung

Photogrammetrie ist ein großes Wissensgebiet, in dem wir versucht haben, nur einige grundlegende Techniken zur Umwandlung von 2D-Bildern in ein 3D-Modell zu vermitteln. Dies wird in vielen Branchen eingesetzt, von der Architektur bis zur Erstellung von Computerspielen.

Nachdem Sie die ersten Erfahrungen mit der Aufnahme eines Datensatzes und seiner konsistenten Umwandlung in ein 3D-Modell gesammelt haben, können Sie Ihre Fähigkeiten verbessern und physische Objekte in einen virtuellen 3D-Raum übertragen. Nun, LeaderGPU wird Ihnen mit Rechenleistung helfen, die Berechnungszeit zu reduzieren und Ihre Workstation für andere, oft höher priorisierte Aufgaben freizugeben.

Siehe auch:

Open WebUI: Alles in einem

Mon, 20 Jan 2025 15:21:46 +0100

Open WebUI wurde ursprünglich für Ollama entwickelt, über das wir in einem unserer Artikel berichtet haben. Zuvor hieß es Ollama WebUI, aber mit der Zeit verlagerte sich der Schwerpunkt auf die Universalität der Anwendung, und der Name wurde in Open WebUI geändert. Diese Software löst das Hauptproblem der bequemen Arbeit mit großen neuronalen Netzmodellen, die lokal oder auf benutzergesteuerten Servern platziert sind.

Installation

Die wichtigste und am meisten bevorzugte Installationsmethode ist die Bereitstellung eines Docker-Containers. Dadurch müssen Sie sich keine Gedanken über das Vorhandensein von Abhängigkeiten oder anderen Komponenten machen, die den korrekten Betrieb der Software gewährleisten. Sie können Open WebUI jedoch auch installieren, indem Sie das Projekt-Repository von GitHub klonen und es aus dem Quellcode erstellen. In diesem Artikel werden wir beide Optionen betrachten.

Bevor Sie beginnen, stellen Sie sicher, dass die GPU-Treiber auf dem Server installiert sind. Unsere Anleitung Nvidia-Treiber unter Linux installieren wird Ihnen dabei helfen.

Docker verwenden

Wenn Sie gerade einen Server bestellt haben, fehlen die Docker-Engine selbst und die notwendigen Tools, um GPUs an den Container zu übergeben. Wir raten davon ab, Docker aus dem Standard-Ubuntu-Repository zu installieren, da es möglicherweise veraltet ist und nicht alle modernen Optionen unterstützt. Es wäre besser, das Installationsskript zu verwenden, das auf der offiziellen Website bereitgestellt wird:

curl -sSL https://get.docker.com/ | sh

Zusätzlich zu Docker müssen Sie das NVIDIA® Container Toolkit installieren, also aktivieren Sie das Nvidia-Repository:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aktualisieren Sie Ihren Paket-Cache und installieren Sie NVIDIA® Container Toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Damit die Toolchain funktioniert, müssen Sie den Docker-Daemon neu starten:

sudo systemctl restart docker

Nun können Sie den gewünschten Container starten. Beachten Sie, dass der folgende Befehl die Container nicht vom Host-Netzwerk isoliert, da Sie später zusätzliche Optionen aktivieren können, z. B. die Erstellung von Images über die Stable Diffusion WebUI. Mit diesem Befehl werden automatisch alle Schichten des Images heruntergeladen und ausgeführt:

sudo docker run -d --network=host --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Git verwenden

Ubuntu 22.04

Zuerst müssen Sie den Inhalt des Repositorys klonen:

git clone https://github.com/open-webui/open-webui.git

Öffnen Sie das heruntergeladene Verzeichnis:

cd open-webui/

Kopieren Sie die Beispielkonfiguration (Sie können sie bei Bedarf ändern), die die Umgebungsvariablen für den Build setzt:

cp -RPp .env.example .env

Installieren Sie das NVM-Installationsprogramm, mit dem Sie die erforderliche Version von Node.js auf dem Server installieren können:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Danach müssen Sie die SSH-Sitzung schließen und erneut öffnen, damit der nächste Befehl korrekt funktioniert.

Installieren Sie den Node Package Manager:

sudo apt -y install npm

Installieren Sie Node.js Version 22 (zum Zeitpunkt der Erstellung dieses Artikels aktuell):

npm install 22

Installieren Sie die für die weitere Montage erforderlichen Abhängigkeiten:

npm install

Starten wir den Build. Bitte beachten Sie, dass mehr als 4 GB freier Arbeitsspeicher erforderlich sind:

npm run build

Das Frontend ist fertig; jetzt ist es an der Zeit, das Backend vorzubereiten. Wechseln Sie in das Verzeichnis mit dem gleichen Namen:

cd ./backend

Installieren Sie die Pakete pip und ffmpeg:

sudo apt -y install python3-pip ffmpeg

Vor der Installation müssen Sie der Umgebungsvariablen einen neuen Pfad hinzufügen:

sudo nano ~/.bashrc

Fügen Sie die folgende Zeile am Ende der Datei ein:

export PATH="/home/usergpu/.local/bin:$PATH"

Aktualisieren wir sie auf die neueste Version:

python3 -m pip install --upgrade pip

Jetzt können Sie die Abhängigkeiten installieren:

pip install -r requirements.txt -U

Installieren Sie Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Alles ist bereit, um die Anwendung zu starten:

bash start.sh

Ubuntu 24.04 / 24.10

Bei der Installation von OpenWebUI auf Ubuntu 24.04/24.10 stehen Sie vor einer wichtigen Herausforderung: Das Betriebssystem verwendet standardmäßig Python 3.12, während OpenWebUI nur Version 3.11 unterstützt. Sie können Python nicht einfach downgraden, das würde das Betriebssystem zerstören. Da das Paket python3.11 nicht in den Standard-Repositories verfügbar ist, müssen Sie eine virtuelle Umgebung erstellen, um die richtige Python-Version zu verwenden.

Die beste Lösung ist die Verwendung des Paketverwaltungssystems Conda. Conda funktioniert wie pip, unterstützt aber zusätzlich virtuelle Umgebungen, ähnlich wie venv. Da Sie nur grundlegende Funktionen benötigen, werden Sie Miniconda verwenden, eine leichtgewichtige Distribution. Laden Sie die neueste Version von GitHub herunter:

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

Führen Sie das Skript aus:

bash Miniforge3-$(uname)-$(uname -m).sh

Erstellen wir eine virtuelle Umgebung namens pyenv und geben wir die Python-Version 3.11 an:

conda create -n pyenv python=3.11

Aktivieren Sie die erstellte Umgebung:

conda activate pyenv

Nun können Sie mit den Standard-Installationsschritten für OpenWebUI unter Ubuntu 22.04 fortfahren. Die virtuelle Umgebung stellt sicher, dass alle Installationsskripte reibungslos und ohne Paketversionskonflikte ausgeführt werden.

Modelle

Ollama-Bibliothek

Mit Open WebUI können Sie Modelle direkt von der Weboberfläche hochladen, wobei Sie nur den Namen im Format model:size angeben müssen. Navigieren Sie dazu zu http://192.168.88.20:8080/admin/settings und klicken Sie auf Connections. Klicken Sie dann auf das Schraubenschlüssel-Symbol gegenüber der Zeichenfolge http://localhost:11434. Nachdem Sie sich die Namen der Modelle in der Bibliothek angesehen haben, geben Sie den Namen ein und klicken auf das Symbol zum Hochladen:

Daraufhin lädt das System das gewünschte Modell automatisch herunter, und es steht sofort zur Verfügung. Je nach ausgewählter Größe kann der Download unterschiedlich lange dauern. Vergewissern Sie sich vor dem Herunterladen, dass genügend Speicherplatz auf der Festplatte vorhanden ist. Weitere Informationen finden Sie im Artikel Festplattenpartitionierung in Linux.

Benutzerdefinierte Modelle

Wenn Sie ein neuronales Netzwerkmodell integrieren möchten, das nicht in der Ollama-Bibliothek enthalten ist, können Sie die experimentelle Funktion verwenden und ein beliebiges Modell im GGUF-Format laden. Gehen Sie dazu auf Settings - Admin Settings - Connections und klicken Sie auf das Schraubenschlüssel-Symbol gegenüber von http://localhost:11434. Klicken Sie auf Show im Bereich Experimental. Standardmäßig ist der Dateimodus aktiviert, der es Ihnen erlaubt, eine Datei von Ihrem lokalen Computer zu laden. Wenn Sie auf File Mode klicken, wechselt der Modus zu URL Mode, wo Sie die URL der Modelldatei angeben können, die dann automatisch vom Server heruntergeladen wird:

RAG

Zusätzlich zu einer bequemen und funktionalen Webschnittstelle hilft Open WebUI, die Möglichkeiten verschiedener Modelle zu erweitern und ihre gemeinsame Nutzung zu gewährleisten. Zum Beispiel ist es einfach, Dokumente hochzuladen, um eine RAG (Retrieval-augmented generation) Vektordatenbank zu bilden. Bei der Generierung einer Antwort an den Benutzer kann sich LLM nicht nur auf Daten stützen, die direkt aus dem Training stammen, sondern auch auf Daten, die in einer ähnlichen Vektordatenbank gespeichert sind.

Dokumente

Standardmäßig durchsucht Open WebUI das Verzeichnis /data/docs nach Dateien, die im Vektorraum der Datenbank platziert werden können, und führt die Transformation mit dem eingebauten Modell all-MiniLM-L6-v2 durch. Dies ist nicht das einzige Modell, das für diese Aufgabe geeignet ist, daher ist es sinnvoll, andere Optionen auszuprobieren, zum Beispiel aus dieser Liste.

Textdokumente, die von Tags und anderen Sonderzeichen befreit sind, sind am besten für RAG geeignet. Natürlich können Sie Dokumente auch unverändert hochladen, doch kann dies die Genauigkeit der generierten Antworten stark beeinträchtigen. Wenn Sie z. B. eine Wissensdatenbank im Markdown-Format haben, können Sie diese zunächst von Formatierungen befreien und erst dann in /data/docs hochladen.

Web-Suche

Zusätzlich zu lokalen Dokumenten kann das neuronale Netzmodell angewiesen werden, beliebige Websites als Datenquelle zu verwenden. Auf diese Weise kann es Fragen nicht nur anhand der Daten beantworten, auf denen es trainiert wurde, sondern auch anhand von Daten, die sich auf vom Benutzer angegebenen Websites befinden.

Es handelt sich dabei um eine Art RAG, das HTML-Seiten als Input erhält und diese dann auf besondere Weise umwandelt, indem es sie in eine Vektordatenbank aufnimmt. Die Suche in einer solchen Datenbank ist sehr schnell, so dass das neuronale Netzmodell in der Lage ist, auf der Grundlage seiner Ergebnisse schnell eine Antwort zu generieren. Open WebUI unterstützt verschiedene Suchmaschinen, kann aber jeweils nur mit einer arbeiten, die in den Einstellungen festgelegt ist.

Um Websuchergebnisse in die Antworten des neuronalen Netzes einzubeziehen, klicken Sie auf + (Plussymbol) und schieben Sie den Schalter Websuche:

Bilderzeugung

Das Besondere an Open WebUI ist, dass diese Software es Ihnen ermöglicht, mehrere neuronale Netze mit unterschiedlichen Aufgaben zu kombinieren, um ein einziges Problem zu lösen. Zum Beispiel führt Llama 3.1 perfekt einen Dialog mit dem Benutzer in mehreren Sprachen, aber seine Antworten sind ausschließlich Text. Es kann keine Bilder erzeugen, so dass es keine Möglichkeit gibt, seine Antworten zu illustrieren.

Stable Diffusion, über das wir schon oft geschrieben haben, ist das Gegenteil: Dieses neuronale Netz erzeugt perfekt Bilder, kann aber überhaupt nicht mit Texten arbeiten. Die Entwickler von Open WebUI haben versucht, die Stärken beider neuronaler Netze in einem Dialog zu vereinen und haben das folgende Arbeitsschema implementiert.

Wenn Sie einen Dialog in Open WebUI führen, erscheint neben jeder Antwort des neuronalen Netzes eine spezielle Schaltfläche. Wenn Sie darauf klicken, erhalten Sie eine Illustration dieser Antwort direkt im Chat:

Dies wird durch den Aufruf der Stable Diffusion WebUI API erreicht, und derzeit ist eine Verbindung mit Versionen von Automatic1111 und eine Verbindung zu ComfyUI verfügbar. Sie können auch Bilder über das neuronale Netzwerk Dall-E generieren, aber es kann nicht lokal eingesetzt werden - dies ist ein kostenpflichtiger Bilderzeugungsdienst mit geschlossenem Quellcode.

Diese Funktion funktioniert nur, wenn zusätzlich zu Open WebUI mit Ollama auch Stable Diffusion WebUI auf dem Server installiert ist. Die Installationsanweisungen finden Sie hier. Erwähnenswert ist lediglich, dass Sie beim Ausführen des Skripts ./webui.sh einen zusätzlichen Schlüssel angeben müssen, um die API zu aktivieren:

./webui.sh --listen --api --gradio-auth user:password

Ein weiterer Fallstrick kann durch einen Mangel an Videospeicher entstehen. In diesem Fall können Sie zwei nützliche Schlüssel verwenden: --medvram und --lowvram. Dadurch wird der Fehler "Out-of-memory" beim Starten der Generierung vermieden.

Siehe auch:

Wie funktioniert Ollama?

Mon, 20 Jan 2025 15:16:02 +0100

Ollama ist ein Werkzeug für die lokale Ausführung großer neuronaler Netzmodelle. Die Nutzung öffentlicher Dienste wird von Unternehmen oft als potenzielles Risiko für den Verlust vertraulicher und sensibler Daten wahrgenommen. Der Einsatz von LLM auf einem kontrollierten Server ermöglicht es Ihnen daher, die darauf abgelegten Daten unabhängig zu verwalten und gleichzeitig die Stärken von LLM zu nutzen.

Dies hilft auch, die unangenehme Situation der Anbieterbindung zu vermeiden, bei der jeder öffentliche Dienst einseitig die Bereitstellung von Diensten einstellen kann. Natürlich besteht das ursprüngliche Ziel darin, die Nutzung generativer neuronaler Netze an Orten zu ermöglichen, an denen kein oder nur ein eingeschränkter Internetzugang besteht (z. B. in einem Flugzeug).

Die Idee war, den Start, die Steuerung und die Feinabstimmung von LLMs zu vereinfachen. Anstelle komplexer mehrstufiger Anweisungen ermöglicht Ollama die Ausführung eines einfachen Befehls, und nach einiger Zeit erhält man das fertige Ergebnis. Es wird gleichzeitig in Form eines lokalen neuronalen Netzmodells präsentiert, mit dem Sie über eine Webschnittstelle und eine API zur einfachen Integration in andere Anwendungen kommunizieren können.

Für viele Entwickler wurde dies zu einem sehr nützlichen Werkzeug, da es in den meisten Fällen möglich war, Ollama in die verwendete IDE zu integrieren und Empfehlungen oder vorgefertigten Code direkt während der Arbeit an der Anwendung zu erhalten.

Ollama war ursprünglich nur für Computer mit dem Betriebssystem macOS gedacht, wurde aber später auf Linux und Windows portiert. Es wurde auch eine spezielle Version für die Arbeit in containerisierten Umgebungen wie Docker veröffentlicht. Derzeit funktioniert es sowohl auf Desktops als auch auf jedem dedizierten Server mit einer GPU gleichermaßen gut. Ollama unterstützt die Fähigkeit, zwischen verschiedenen Modellen umzuschalten, und maximiert alle verfügbaren Ressourcen. Natürlich sind diese Modelle auf einem normalen Desktop nicht ganz so leistungsfähig, aber sie funktionieren durchaus angemessen.

Wie installiert man Ollama?

Ollama kann auf zwei Arten installiert werden: ohne Containerisierung, mit einem Installationsskript, und als fertiger Docker-Container. Die erste Methode macht es einfacher, die Komponenten des installierten Systems und der Modelle zu verwalten, ist aber weniger fehlertolerant. Die zweite Methode ist fehlertoleranter, aber bei ihrer Verwendung müssen Sie alle Aspekte berücksichtigen, die mit Containern verbunden sind: eine etwas komplexere Verwaltung und ein anderer Ansatz für die Datenspeicherung.

Unabhängig von der gewählten Methode sind mehrere zusätzliche Schritte zur Vorbereitung des Betriebssystems erforderlich.

Voraussetzungen

Aktualisieren Sie das Paket-Cache-Repository und die installierten Pakete:

sudo apt update && sudo apt -y upgrade

Installieren Sie alle erforderlichen GPU-Treiber mit der automatischen Installationsfunktion:

sudo ubuntu-drivers autoinstall

Starten Sie den Server neu:

sudo shutdown -r now

Installation über Skript

Das folgende Skript erkennt die aktuelle Architektur des Betriebssystems und installiert die entsprechende Version von Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Während des Betriebs legt das Skript einen eigenen Benutzer ollama an, unter dem der entsprechende Daemon gestartet wird. Das gleiche Skript funktioniert übrigens auch in WSL2 und ermöglicht die Installation der Linux-Version von Ollama auf Windows Server.

Installation über Docker

Es gibt verschiedene Methoden, die Docker-Engine auf einem Server zu installieren. Der einfachste Weg ist die Verwendung eines speziellen Skripts, das die aktuelle Docker-Version installiert. Dieser Ansatz ist für Ubuntu Linux ab Version 20.04 (LTS) bis zur neuesten Version, Ubuntu 24.04 (LTS), wirksam:

curl -sSL https://get.docker.com/ | sh

Damit Docker-Container richtig mit der GPU interagieren können, muss ein zusätzliches Toolkit installiert werden. Da es nicht in den grundlegenden Ubuntu-Repositories verfügbar ist, müssen Sie zunächst ein Drittanbieter-Repository mit dem folgenden Befehl hinzufügen:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Aktualisieren Sie das Paket-Cache-Repository:

sudo apt update

Und installieren Sie das Paket nvidia-container-toolkit:

sudo apt install nvidia-container-toolkit

Vergessen Sie nicht, den Docker-Daemon über systemctl neu zu starten:

sudo systemctl restart docker

Es ist an der Zeit, Ollama herunterzuladen und mit der Open-WebUI-Weboberfläche zu starten:

sudo docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Öffnen Sie den Webbrowser und navigieren Sie zu http://[server-ip]:3000:

Herunterladen und Ausführen der Modelle

Über die Befehlszeile

Führen Sie einfach den folgenden Befehl aus:

ollama run llama3

Über die WebUI

Öffnen Sie Settings > Models, geben Sie den gewünschten Modellnamen ein, z. B. llama3 und klicken Sie auf die Schaltfläche mit dem Download-Symbol:

Das Modell wird automatisch heruntergeladen und installiert. Sobald die Installation abgeschlossen ist, schließen Sie das Einstellungsfenster und wählen das heruntergeladene Modell aus. Danach können Sie einen Dialog mit dem Modell beginnen:

VSCode-Integration

Wenn Sie Ollama mit Hilfe des Installationsskripts installiert haben, können Sie jedes der unterstützten Modelle fast sofort starten. Im nächsten Beispiel werden wir das Standardmodell ausführen, das von der Ollama Autocoder-Erweiterung erwartet wird (openhermes2.5-mistral:7b-q4_K_M):

ollama run openhermes2.5-mistral:7b-q4_K_M

Standardmäßig erlaubt Ollama die Arbeit über eine API, die nur Verbindungen vom lokalen Host zulässt. Daher ist vor der Installation und Verwendung der Erweiterung für Visual Studio Code eine Portweiterleitung erforderlich. Insbesondere müssen Sie den Remote-Port 11434 an Ihren lokalen Computer weiterleiten. Ein Beispiel für die Weiterleitung finden Sie in unserem Artikel über Easy Diffusion WebUI.

Geben Sie Ollama Autocoder in ein Suchfeld ein, und klicken Sie dann auf Install:

Nach der Installation der Erweiterung steht in der Befehlspalette ein neues Element mit dem Namen Autocomplete with Ollama zur Verfügung. Beginnen Sie mit der Codierung und initiieren Sie diesen Befehl.

Die Erweiterung stellt eine Verbindung zum LeaderGPU-Server über Portweiterleitung her, und innerhalb weniger Sekunden wird der generierte Code auf Ihrem Bildschirm angezeigt:

Sie können diesen Befehl einem Hotkey zuweisen. Verwenden Sie ihn immer dann, wenn Sie Ihren Code durch ein generiertes Fragment ergänzen wollen. Dies ist nur ein Beispiel für die verfügbaren VSCode-Erweiterungen. Das Prinzip der Portweiterleitung von einem entfernten Server zu einem lokalen Computer ermöglicht es Ihnen, einen einzigen Server mit einem laufenden LLM für ein ganzes Entwicklerteam einzurichten. Diese Sicherheit verhindert, dass Drittfirmen oder Hacker den gesendeten Code verwenden.

Siehe auch:

PrivateGPT: AI für Dokumente

Mon, 20 Jan 2025 12:01:00 +0100

Große Sprachmodelle haben sich in den letzten Jahren stark weiterentwickelt und sind zu effektiven Werkzeugen für viele Aufgaben geworden. Das einzige Problem bei ihrer Verwendung ist, dass die meisten Produkte, die auf diesen Modellen basieren, vorgefertigte Dienste von Drittanbietern nutzen. Diese Nutzung birgt das Potenzial, sensible Daten preiszugeben, weshalb viele Unternehmen es vermeiden, interne Dokumente in öffentliche LLM-Dienste hochzuladen.

Ein Projekt wie PrivateGPT könnte eine Lösung sein. Es ist zunächst ausschließlich für die lokale Nutzung konzipiert. Seine Stärke liegt darin, dass Sie verschiedene Dokumente als Input einreichen können, und das neuronale Netz wird sie für Sie lesen und seine eigenen Kommentare als Antwort auf Ihre Anfragen liefern. Sie können es z. B. mit umfangreichen Texten "füttern" und es auffordern, auf der Grundlage der Anfrage des Benutzers bestimmte Schlussfolgerungen zu ziehen. Auf diese Weise können Sie viel Zeit beim Korrekturlesen sparen.

Dies gilt insbesondere für Fachgebiete wie die Medizin. Ein Arzt kann zum Beispiel eine Diagnose stellen und das neuronale Netz bitten, diese auf der Grundlage der hochgeladenen Dokumente zu bestätigen. Auf diese Weise kann eine zusätzliche unabhängige Meinung eingeholt werden, wodurch die Zahl der medizinischen Fehler verringert wird. Da die Anfragen und Dokumente den Server nicht verlassen, kann man sicher sein, dass die empfangenen Daten nicht in der Öffentlichkeit erscheinen.

Heute zeigen wir Ihnen, wie Sie ein neuronales Netzwerk auf dedizierten LeaderGPU-Servern mit dem Betriebssystem Ubuntu 22.04 LTS in nur 20 Minuten einrichten können.

System vorbereiten

Beginnen Sie damit, Ihre Pakete auf die neueste Version zu aktualisieren:

sudo apt update && sudo apt -y upgrade

Installieren Sie nun zusätzliche Pakete, Bibliotheken und den Nvidia-Grafiktreiber. All dies wird benötigt, um die Software erfolgreich zu erstellen und auf dem Grafikprozessor auszuführen:

sudo apt -y install build-essential git gcc cmake make openssl libssl-dev libbz2-dev libreadline-dev libsqlite3-dev zlib1g-dev libncursesw5-dev libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev libssl-dev openssl libffi-dev lzma liblzma-dev libbz2-dev

CUDA® 12.4 installieren

Neben dem Treiber müssen Sie auch das NVIDIA® CUDA® Toolkit installieren. Diese Anleitung wurde mit CUDA® 12.4 getestet, aber alles sollte auch mit CUDA® 12.2 funktionieren. Denken Sie jedoch daran, dass Sie die installierte Version angeben müssen, wenn Sie den Pfad zu den ausführbaren Dateien angeben.

Führen Sie den folgenden Befehl sequentiell aus:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo dpkg -i cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo cp /var/cuda-repo-ubuntu2204-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/

sudo apt-get update && sudo apt-get -y install cuda-toolkit-12-4

Weitere Informationen zur Installation von CUDA® finden Sie in unserer Knowledge Base. Starten Sie nun den Server neu:

sudo shutdown -r now

PyEnv installieren

Es ist an der Zeit, ein einfaches Python-Versionskontrollprogramm namens PyEnv zu installieren. Es handelt sich dabei um einen deutlich verbesserten Fork des ähnlichen Projekts für Ruby (rbenv), der so konfiguriert wurde, dass er mit Python funktioniert. Es kann mit einem einzeiligen Skript installiert werden:

curl https://pyenv.run | bash

Nun müssen Sie am Ende der Skriptdatei, die bei der Anmeldung ausgeführt wird, einige Variablen hinzufügen. Die ersten drei Zeilen sind für den korrekten Betrieb von PyEnv verantwortlich, und die vierte wird für Poetry benötigt, das später installiert wird:

nano .bashrc

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
export PATH="/home/usergpu/.local/bin:$PATH"

Übernehmen Sie die Einstellungen, die Sie vorgenommen haben:

source .bashrc

Installieren Sie Python Version 3.11:

pyenv install 3.11

Erstellen Sie eine virtuelle Umgebung für Python 3.11:

pyenv local 3.11

Poesie installieren

Das nächste Teil des Puzzles ist Poetry. Dies ist ein Analogon von pip für die Verwaltung von Abhängigkeiten in Python-Projekten. Der Autor von Poetry war es leid, sich ständig mit verschiedenen Konfigurationsmethoden wie setup.cfg, requirements.txt, MANIFEST.ini und anderen auseinanderzusetzen. Dies war der Auslöser für die Entwicklung eines neuen Werkzeugs, das eine pyproject.toml Datei verwendet, die alle grundlegenden Informationen über ein Projekt speichert, nicht nur eine Liste von Abhängigkeiten.

Poesie installieren:

curl -sSL https://install.python-poetry.org | python3 -

PrivateGPT installieren

Nun, da alles bereit ist, können Sie das PrivateGPT-Repository klonen:

git clone https://github.com/imartinez/privateGPT

Rufen Sie das heruntergeladene Repository auf:

cd privateGPT

Führen Sie die Installation der Abhängigkeiten mit Poetry aus und aktivieren Sie dabei zusätzliche Komponenten:

ui - fügt der Backend-Anwendung eine Gradio-basierte Verwaltungsweboberfläche hinzu;
embedding-huggingface - Unterstützung für die Einbettung von Modellen, die von HuggingFace heruntergeladen wurden;
llms-llama-cpp - Unterstützung für die direkte Inferenz von Modellen im GGUF-Format hinzugefügt;
vector-stores-qdrant - Hinzufügen der qdrant-Vektordatenbank.

poetry install --extras "ui embeddings-huggingface llms-llama-cpp vector-stores-qdrant"

Setzen Sie Ihr HuggingFace-Zugangs-Token. Für zusätzliche Informationen lesen Sie bitte diesen Artikel:

export HF_TOKEN="YOUR_HUGGING_FACE_ACCESS_TOKEN"

Führen Sie nun das Installationsskript aus, das automatisch das Modell und die Gewichte herunterlädt (Meta Llama 3.1 8B Instruct als Standard):

poetry run python scripts/setup

Mit dem folgenden Befehl wird llms-llama-cpp separat neu kompiliert, um die Unterstützung für NVIDIA® CUDA® zu aktivieren, damit die Arbeitslasten auf den Grafikprozessor verlagert werden können:

CUDACXX=/usr/local/cuda-12/bin/nvcc CMAKE_ARGS="-DGGML_CUDA=on -DCMAKE_CUDA_ARCHITECTURES=native" FORCE_CMAKE=1 pip install llama-cpp-python --no-cache-dir --force-reinstall --upgrade

Wenn Sie eine Fehlermeldung wie nvcc fatal : Unsupported gpu architecture 'compute_' erhalten, geben Sie einfach die genaue Architektur der GPU an, die Sie verwenden. Zum Beispiel: DCMAKE_CUDA_ARCHITECTURES=86 für NVIDIA® RTX™ 3090.

Der letzte Schritt vor dem Start ist die Installation der Unterstützung für asynchrone Aufrufe (async/await):

pip install asyncio

PrivateGPT ausführen

Starten Sie PrivateGPT mit einem einzigen Befehl:

make run

Öffnen Sie Ihren Webbrowser und gehen Sie auf die Seite http://[LeaderGPU_server_IP_address]:8001

Siehe auch:

Qwen 2 gegen Llama 3

Mon, 20 Jan 2025 11:27:11 +0100

Große Sprachmodelle (Large Language Models, LLMs) haben unser Leben erheblich beeinflusst. Trotz des Verständnisses ihrer internen Struktur bleiben diese Modelle ein Brennpunkt für Wissenschaftler, die sie oft mit einer "Black Box" vergleichen. Das Endergebnis hängt nicht nur vom Design des LLM ab, sondern auch von seinem Training und den für das Training verwendeten Daten.

Während Wissenschaftler nach Forschungsmöglichkeiten suchen, sind die Endnutzer vor allem an zwei Dingen interessiert: Geschwindigkeit und Qualität. Diese Kriterien spielen im Auswahlprozess eine entscheidende Rolle. Um zwei LLMs genau vergleichen zu können, müssen viele scheinbar unzusammenhängende Faktoren standardisiert werden.

Den größten Einfluss haben die zur Störung verwendeten Geräte und die Softwareumgebung, einschließlich des Betriebssystems, der Treiberversionen und der Softwarepakete. Es ist wichtig, eine LLM-Version auszuwählen, die auf verschiedenen Geräten funktioniert, und eine Geschwindigkeitsmetrik zu wählen, die leicht zu verstehen ist.

Wir haben uns für "Token pro Sekunde" (Token/s) als diese Metrik entschieden. Es ist wichtig zu wissen, dass ein Token ≠ ein Wort ist. Das LLM zerlegt Wörter in einfachere, für eine bestimmte Sprache typische Komponenten, die als Token bezeichnet werden.

Die statistische Vorhersagbarkeit des nächsten Zeichens variiert von Sprache zu Sprache, so dass die Tokenisierung unterschiedlich ausfällt. Im Englischen zum Beispiel werden aus 75 Wörtern etwa 100 Token abgeleitet. In Sprachen, die das kyrillische Alphabet verwenden, kann die Anzahl der Token pro Wort höher sein. So könnten 75 Wörter in einer kyrillischen Sprache wie Russisch 120-150 Token entsprechen.

Sie können dies mit dem Tokenizer-Tool von OpenAI überprüfen. Es zeigt, in wie viele Token ein Textfragment zerlegt wird, so dass "Token pro Sekunde" ein guter Indikator für die Geschwindigkeit und Leistung eines LLM bei der Verarbeitung natürlicher Sprache ist.

Jeder Test wurde auf dem Betriebssystem Ubuntu 22.04 LTS mit den Nvidia-Treibern Version 535.183.01 und dem NVIDIA® CUDA® 12.5 Toolkit durchgeführt. Es wurden Fragen formuliert, um die Qualität und Geschwindigkeit des LLM zu bewerten. Die Verarbeitungsgeschwindigkeit jeder Antwort wurde aufgezeichnet und wird zum Durchschnittswert für jede getestete Konfiguration beitragen.

Wir begannen mit dem Test verschiedener GPUs, von den neuesten Modellen bis hin zu den älteren. Eine entscheidende Bedingung für den Test war, dass wir die Leistung nur eines Grafikprozessors gemessen haben, auch wenn mehrere in der Serverkonfiguration vorhanden waren. Dies liegt daran, dass die Leistung einer Konfiguration mit mehreren Grafikprozessoren von zusätzlichen Faktoren wie dem Vorhandensein eines Hochgeschwindigkeits-Interconnects zwischen ihnen (NVLink) abhängt.

Neben der Geschwindigkeit haben wir auch versucht, die Qualität der Antworten auf einer 5-Punkte-Skala zu bewerten, wobei 5 das beste Ergebnis darstellt. Diese Informationen werden hier nur zum allgemeinen Verständnis bereitgestellt. Wir werden dem neuronalen Netz jedes Mal dieselben Fragen stellen und versuchen zu erkennen, wie genau es versteht, was der Benutzer von ihm will.

Qwen 2

Vor kurzem hat ein Entwicklerteam der Alibaba Group die zweite Version ihres generativen neuronalen Netzes Qwen vorgestellt. Es versteht 27 Sprachen und ist für diese Sprachen gut optimiert. Qwen 2 gibt es in verschiedenen Größen, damit es auf jedem Gerät eingesetzt werden kann (von stark ressourcenbeschränkten eingebetteten Systemen bis hin zu einem dedizierten Server mit GPUs):

0.5B: geeignet für IoT und eingebettete Systeme;
1.5B: eine erweiterte Version für eingebettete Systeme, die eingesetzt wird, wenn die Fähigkeiten von 0.5B nicht ausreichen;
7B: mittelgroßes Modell, gut geeignet für die Verarbeitung natürlicher Sprache;
57B: leistungsstarkes großes Modell, das für anspruchsvolle Anwendungen geeignet ist;
72B: das ultimative Qwen-2-Modell, das für die Lösung der komplexesten Probleme und die Verarbeitung großer Datenmengen konzipiert ist.

Die Versionen 0.5B und 1.5B wurden auf Datensätzen mit einer Kontextlänge von 32K trainiert. Die Versionen 7B und 72B wurden bereits auf den 128K-Kontext trainiert. Das Kompromissmodell 57B wurde auf Datensätzen mit einer Kontextlänge von 64K trainiert. Die Entwickler sehen Qwen 2 als Analogon zu Llama 3, das die gleichen Probleme lösen kann, aber viel schneller ist.

Llama 3

Die dritte Version des generativen neuronalen Netzes aus der MetaAI Llama-Familie wurde im April 2024 vorgestellt. Es wurde, anders als Qwen 2, in nur zwei Versionen veröffentlicht: 8B und 70B. Diese Modelle wurden als universelles Werkzeug für die Lösung vieler Probleme in verschiedenen Fällen positioniert. Es setzte den Trend zur Mehrsprachigkeit und Multimodalität fort und wurde gleichzeitig schneller als die Vorgängerversionen und unterstützt eine größere Kontextlänge.

Die Entwickler von Llama 3 haben versucht, die Modelle zu verfeinern, um den Anteil der statistischen Halluzinationen zu verringern und die Vielfalt der Antworten zu erhöhen. So ist Llama 3 durchaus in der Lage, praktische Ratschläge zu geben, beim Verfassen eines Geschäftsbriefs zu helfen oder über ein vom Benutzer vorgegebenes Thema zu spekulieren. Die Datensätze, auf denen die Llama 3-Modelle trainiert wurden, hatten eine Kontextlänge von 128K und mehr als 5% enthielten Daten in 30 Sprachen. Wie es in der Pressemitteilung heißt, wird die Generierungsleistung in Englisch jedoch deutlich höher sein als in allen anderen Sprachen.

Vergleich

NVIDIA® RTX™ A6000

Beginnen wir unsere Geschwindigkeitsmessungen mit der NVIDIA® RTX™ A6000 GPU, die auf der Ampere-Architektur basiert (nicht zu verwechseln mit der NVIDIA® RTX™ A6000 Ada). Diese Karte hat sehr bescheidene Eigenschaften, aber gleichzeitig verfügt sie über 48 GB VRAM, was es ihr ermöglicht, mit ziemlich großen neuronalen Netzwerkmodellen zu arbeiten. Leider sind die niedrige Taktrate und Bandbreite die Gründe für die geringe Inferenzgeschwindigkeit von Text-LLMs.

Unmittelbar nach dem Start begann das neuronale Netz Qwen 2, Llama 3 zu übertreffen. Bei der Beantwortung der gleichen Fragen betrug der durchschnittliche Geschwindigkeitsunterschied 24 % zugunsten von Qwen 2. Die Geschwindigkeit bei der Generierung von Antworten lag im Bereich von 11-16 Token pro Sekunde. Das ist 2-3 mal schneller als der Versuch, die Generierung selbst auf einer leistungsstarken CPU laufen zu lassen, aber in unserer Bewertung ist dies das bescheidenste Ergebnis.

NVIDIA® RTX™ 3090

Die nächste GPU basiert ebenfalls auf der Ampere-Architektur, hat 2 Mal weniger Videospeicher, arbeitet aber gleichzeitig mit einer höheren Frequenz (19500 MHz gegenüber 16000 Mhz). Auch die Bandbreite des Videospeichers ist höher (936,2 GB/s gegenüber 768 GB/s). Diese beiden Faktoren erhöhen die Leistung der RTX™ 3090 erheblich, selbst wenn man die Tatsache berücksichtigt, dass sie 256 CUDA-Kerne weniger hat.

Hier kann man deutlich sehen, dass Qwen 2 bei der Ausführung der gleichen Aufgaben viel schneller ist (bis zu 23 %) als Llama 3. Was die Qualität der Generierung angeht, so ist die Mehrsprachenunterstützung von Qwen 3 wirklich lobenswert, und das Modell antwortet immer in der gleichen Sprache, in der die Frage gestellt wurde. Bei Llama 3 kommt es in dieser Hinsicht oft vor, dass das Modell zwar die Frage selbst versteht, es aber vorzieht, die Antworten auf Englisch zu formulieren.

NVIDIA® RTX™ 4090

Nun das Interessanteste: Schauen wir uns an, wie der NVIDIA® RTX™ 4090, der auf der Ada Lovelace Architektur basiert, benannt nach der englischen Mathematikerin Augusta Ada King, Countess of Lovelace, die gleiche Aufgabe bewältigt. Sie wurde berühmt, weil sie die erste Programmiererin in der Geschichte der Menschheit war, und als sie ihr erstes Programm schrieb, gab es noch keinen zusammengebauten Computer, der es ausführen konnte. Es wurde jedoch anerkannt, dass der von Ada beschriebene Algorithmus zur Berechnung der Bernoulli-Zahlen das erste Programm der Welt war, das für die Ausführung auf einem Computer geschrieben wurde.

Die Grafik zeigt deutlich, dass der RTX™ 4090 die Inferenz beider Modelle fast doppelt so schnell bewältigte. Interessant ist, dass Llama 3 in einer der Iterationen die Leistung von Qwen 2 um 1,2 % übertreffen konnte. Berücksichtigt man jedoch die anderen Iterationen, so behielt Qwen 2 seine Führungsposition und blieb 7% schneller als Llama 3. In allen Iterationen war die Qualität der Antworten beider neuronaler Netze hoch, mit einer minimalen Anzahl von Halluzinationen. Der einzige Mangel ist, dass in seltenen Fällen ein oder zwei chinesische Zeichen in die Antworten gemischt wurden, was die Gesamtbedeutung in keiner Weise beeinträchtigte.

NVIDIA® RTX™ A40

Die nächste NVIDIA® RTX™ A40 Karte, mit der wir ähnliche Tests durchgeführt haben, basiert ebenfalls auf der Ampere-Architektur und verfügt über 48 GB Videospeicher auf dem Motherboard. Im Vergleich zur RTX™ 3090 ist dieser Speicher etwas schneller (20000 MHz vs. 19500 MHz), hat aber eine geringere Bandbreite (695,8 GB/s vs. 936,2 GB/s). Diese Situation wird durch die größere Anzahl an CUDA-Kernen (10752 gegenüber 10496) kompensiert, wodurch die RTX™ A40 insgesamt etwas schneller als die RTX™ 3090 arbeiten kann.

Was den Vergleich der Geschwindigkeit der Modelle angeht, so liegt Qwen 2 auch hier in allen Iterationen vor Llama 3. Wenn es auf der RTX™ A40 läuft, beträgt der Geschwindigkeitsunterschied bei den gleichen Antworten etwa 15 %. Bei einigen Aufgaben gab Qwen 2 etwas mehr wichtige Informationen, während Llama 3 so spezifisch wie möglich war und Beispiele gab. Trotzdem muss alles doppelt geprüft werden, da beide Modelle manchmal zu widersprüchlichen Antworten kommen.

NVIDIA® L20

Der letzte Teilnehmer in unserem Test war die NVIDIA® L20. Diese GPU ist wie die RTX™ 4090 auf der Ada Lovelace Architektur aufgebaut. Es handelt sich um ein relativ neues Modell, das im Herbst 2023 vorgestellt wurde. Es hat 48 GB Videospeicher und 11776 CUDA-Kerne an Bord. Die Speicherbandbreite ist geringer als bei der RTX™ 4090 (864 GB/s gegenüber 936,2 GB/s), ebenso die effektive Frequenz. Die NVIDIA® L20-Inferenzergebnisse beider Modelle werden also näher an 3090 als an 4090 liegen.

Der letzte Test brachte keine Überraschungen mehr. Qwen 2 erwies sich in allen Iterationen als schneller als Llama 3.

Fazit

Fassen wir alle gesammelten Ergebnisse in einem Diagramm zusammen. Qwen 2 war zwischen 7% und 24% schneller als Llama 3, abhängig von der verwendeten GPU. Daraus können wir eindeutig schließen, dass die RTX™ 3090 der unbestrittene Spitzenreiter ist, wenn es darum geht, Hochgeschwindigkeits-Inferenzen aus Modellen wie Qwen 2 oder Llama 3 auf Single-GPU-Konfigurationen zu erhalten. Eine mögliche Alternative könnte die A40 oder L20 sein. Aber es lohnt sich nicht, die Inferenz dieser Modelle auf Ampere-Karten der A6000-Generation laufen zu lassen.

Karten mit einem kleineren Videospeicher, wie z.B. NVIDIA® RTX™ 2080Ti, haben wir absichtlich nicht in den Tests erwähnt, da es nicht möglich ist, die oben erwähnten 7B- oder 8B-Modelle dort ohne Quantisierung unterzubringen. Nun, das 1.5B-Modell Qwen 2 hat leider keine hochwertigen Antworten und kann nicht als vollständiger Ersatz für 7B dienen.

Siehe auch:

Ihr eigenes Qwen mit HF

Mon, 20 Jan 2025 09:43:46 +0100

Große neuronale Netzwerkmodelle mit ihren außergewöhnlichen Fähigkeiten sind fest in unserem Leben verankert. Große Unternehmen erkannten dies als Chance für die zukünftige Entwicklung und begannen, ihre eigenen Versionen dieser Modelle zu entwickeln. Der chinesische Gigant Alibaba hat nicht tatenlos zugesehen. Er entwickelte sein eigenes Modell, QWen (Tongyi Qianwen), das zur Grundlage für viele andere neuronale Netzwerkmodelle wurde.

Voraussetzungen

Cache und Pakete aktualisieren

Bevor Sie mit der Einrichtung von Qwen beginnen, sollten Sie den Paket-Cache aktualisieren und Ihr Betriebssystem aufrüsten. Außerdem müssen wir Python Installer Packages (PIP) hinzufügen, falls es nicht bereits im System vorhanden ist. Bitte beachten Sie, dass wir für diese Anleitung Ubuntu 22.04 LTS als Betriebssystem verwenden:

sudo apt update && sudo apt -y upgrade && sudo apt install python3-pip

Nvidia-Treiber installieren

Sie können das automatische Dienstprogramm verwenden, das in Ubuntu-Distributionen standardmäßig enthalten ist:

sudo ubuntu-drivers autoinstall

Alternativ können Sie die Nvidia-Treiber auch manuell mit Hilfe unserer Schritt-für-Schritt-Anleitung installieren. Vergessen Sie nicht, den Server neu zu starten:

sudo shutdown -r now

Texterstellung Web UI

Klonen Sie das Repository

Öffnen Sie das Arbeitsverzeichnis auf der SSD:

cd /mnt/fastdisk

Klonen Sie das Repository des Projekts:

git clone https://github.com/oobabooga/text-generation-webui.git

Anforderungen installieren

Öffnen Sie das heruntergeladene Verzeichnis:

cd text-generation-webui

Überprüfen und installieren Sie alle fehlenden Komponenten:

pip install -r requirements.txt

SSH-Schlüssel zu HF hinzufügen

Bevor Sie beginnen, müssen Sie in Ihrem SSH-Client eine Portweiterleitung einrichten (Remote-Port 7860 auf 127.0.0.1:7860). Weitere Informationen finden Sie im folgenden Artikel: Verbindung zum Linux-Server herstellen.

Aktualisieren Sie das Paket-Cache-Repository und die installierten Pakete:

sudo apt update && sudo apt -y upgrade

Erzeugen Sie einen SSH-Schlüssel, den Sie in Hugging Face verwenden können, und fügen Sie ihn hinzu:

cd ~/.ssh && ssh-keygen

Wenn das Schlüsselpaar generiert ist, können Sie den öffentlichen Schlüssel im Terminalemulator anzeigen:

cat id_rsa.pub

Kopieren Sie alle Informationen, die mit ssh-rsa beginnen und mit usergpu@gpuserver enden, wie im folgenden Screenshot gezeigt:

Öffnen Sie einen Webbrowser, geben Sie https://huggingface.co/ in die Adresszeile ein und drücken Sie Enter. Loggen Sie sich in Ihren HF-Account ein und öffnen Sie die Profileinstellungen. Wählen Sie dann SSH and GPG Keys und klicken Sie auf die Schaltfläche Add SSH Key:

Füllen Sie Key name aus und fügen Sie den kopierten SSH Public key aus dem Terminal ein. Speichern Sie den Schlüssel, indem Sie Add key drücken:

Jetzt ist Ihr HF-Konto mit dem öffentlichen SSH-Schlüssel verknüpft. Der zweite Teil (privater Schlüssel) ist auf dem Server gespeichert. Der nächste Schritt ist die Installation einer speziellen Git LFS-Erweiterung (Large File Storage), die für das Herunterladen großer Dateien wie z. B. Modelle neuronaler Netze verwendet wird. Öffnen Sie Ihr Home-Verzeichnis:

cd ~/

Laden Sie das Shell-Skript herunter und führen Sie es aus. Dieses Skript installiert ein neues Drittanbieter-Repository mit git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Nun können Sie es mit dem Standard-Paketmanager installieren:

sudo apt-get install git-lfs

Lassen Sie uns git so konfigurieren, dass es unseren HF-Nickname verwendet:

git config --global user.name "John"

Und mit dem HF-E-Mail-Konto verknüpft:

git config --global user.email "john.doe@example.com"

Das Modell herunterladen

Der nächste Schritt ist das Herunterladen des Modells mit der von Softwareentwicklern häufig verwendeten Technik des Klonens von Repositorys. Der einzige Unterschied besteht darin, dass das zuvor installierte Git-LFS die markierten Zeigerdateien automatisch verarbeiten und den gesamten Inhalt herunterladen wird. Öffnen Sie das erforderliche Verzeichnis (in unserem Beispiel /mnt/fastdisk):

cd /mnt/fastdisk

Dieser Befehl kann einige Zeit in Anspruch nehmen:

git clone git@hf.co:Qwen/Qwen1.5-32B-Chat-GGUF

Ausführen des Modells

Führen Sie ein Skript aus, das den Webserver startet und /mnt/fastdisk als das Arbeitsverzeichnis mit den Modellen angibt. Dieses Skript kann beim ersten Start einige zusätzliche Komponenten herunterladen.

./start_linux.sh --model-dir /mnt/fastdisk

Öffnen Sie Ihren Webbrowser und wählen Sie llama.cpp aus der Dropdown-Liste Model loader:

Stellen Sie sicher, dass Sie den Parameter n-gpu-layers setzen. Er ist dafür verantwortlich, wie viel Prozent der Berechnungen auf den Grafikprozessor verlagert werden. Wenn Sie die Zahl auf 0 belassen, werden alle Berechnungen auf der CPU durchgeführt, was ziemlich langsam ist. Sobald alle Parameter eingestellt sind, klicken Sie auf die Schaltfläche Load. Wechseln Sie dann zur Registerkarte Chat und wählen Sie Instruct mode. Nun können Sie eine beliebige Eingabeaufforderung eingeben und eine Antwort erhalten:

Die Verarbeitung wird standardmäßig auf allen verfügbaren GPUs durchgeführt, wobei die zuvor festgelegten Parameter berücksichtigt werden:

Siehe auch:

Ihr eigenes Vicuna unter Linux

Mon, 20 Jan 2025 09:25:01 +0100

Dieser Artikel führt Sie durch den Prozess der Bereitstellung einer einfachen LLaMA-Alternative auf einem LeaderGPU-Server. Zu diesem Zweck werden wir das FastChat-Projekt und das frei verfügbare Vicuna-Modell verwenden.

Das Modell, das wir verwenden werden, basiert auf der LLaMA-Architektur von Meta, wurde aber für den effizienten Einsatz auf Consumer-Hardware optimiert. Dieses Setup bietet ein gutes Gleichgewicht zwischen Leistung und Ressourcenanforderungen und eignet sich daher sowohl für Test- als auch für Produktionsumgebungen.

Vorinstallation

Wir bereiten die Installation von FastChat vor, indem wir das Paket-Cache-Repository aktualisieren:

sudo apt update && sudo apt -y upgrade

Installieren Sie die Nvidia-Treiber automatisch mit dem folgenden Befehl:

sudo ubuntu-drivers autoinstall

Sie können diese Treiber auch manuell mit unserer Schritt-für-Schritt-Anleitung installieren. Starten Sie dann den Server neu:

sudo shutdown -r now

Der nächste Schritt ist die Installation von PIP (Package Installer for Python):

sudo apt install python3-pip

FastChat installieren

Von PyPi

Es gibt zwei Möglichkeiten, FastChat zu installieren. Sie können es direkt von PyPi aus installieren:

pip3 install "fschat[model_worker,webui]"

Von GitHub

Alternativ können Sie das FastChat-Repository von GitHub klonen und es installieren:

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

Vergessen Sie nicht, PIP zu aktualisieren, bevor Sie fortfahren:

pip3 install --upgrade pip

pip3 install -e ".[model_worker,webui]"

FastChat ausführen

Erster Start

Um einen erfolgreichen ersten Start zu gewährleisten, empfiehlt es sich, FastChat manuell direkt von der Kommandozeile aus aufzurufen:

python3 -m fastchat.serve.cli --model-path lmsys/vicuna-7b-v1.5

Dabei wird automatisch das gewünschte Modell, das mit dem Parameter --model-path angegeben werden muss, abgerufen und heruntergeladen. Die 7b steht für ein Modell mit 7 Milliarden Parametern. Dies ist das leichteste Modell, das für GPUs mit 16 GB Videospeicher geeignet ist. Links zu Modellen mit einer größeren Anzahl von Parametern finden Sie in der Readme-Datei des Projekts.

Nun haben Sie die Möglichkeit, direkt in der Befehlszeilenschnittstelle mit dem Chatbot zu kommunizieren oder eine Webschnittstelle einzurichten. Es enthält drei Komponenten:

Controller
Arbeiter
Gradio-Webserver

Dienste einrichten

Lassen Sie uns jede Komponente in einen separaten systemd-Dienst umwandeln. Erstellen Sie 3 separate Dateien mit dem folgenden Inhalt:

sudo nano /etc/systemd/system/vicuna-controller.service

[Unit]
Description=Vicuna controller service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.controller
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-worker.service

[Unit]
Description=Vicuna worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.model_worker --model-path lmsys/vicuna-7b-v1.5
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-webserver.service

[Unit]
Description=Vicuna web server
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.gradio_web_server
Restart=always
[Install]
WantedBy=multi-user.target

Systemd aktualisiert seine Daemon-Datenbank normalerweise während des Systemstarts. Sie können dies jedoch auch manuell mit dem folgenden Befehl tun:

sudo systemctl daemon-reload

Fügen wir nun drei neue Dienste zum Startvorgang hinzu und starten sie sofort mit der Option --now:

sudo systemctl enable vicuna-controller.service --now && sudo systemctl enable vicuna-worker.service --now && sudo systemctl enable vicuna-webserver.service --now

Wenn Sie jedoch versuchen, eine Weboberfläche unter http://[IP_ADDRESS]:7860 zu öffnen, wird eine völlig unbrauchbare Oberfläche ohne verfügbare Modelle angezeigt. Um dieses Problem zu beheben, beenden Sie den Webinterface-Dienst:

sudo systemctl stop vicuna-webserver.service

Führen Sie den Webdienst manuell aus:

python3 -m fastchat.serve.gradio_web_server

Hinzufügen einer Authentifizierung

Diese Aktion ruft ein weiteres Skript auf, das das zuvor heruntergeladene Modell in einer Gradio-internen Datenbank registrieren wird. Warten Sie ein paar Sekunden und unterbrechen Sie den Prozess mit der Abkürzung Ctrl + C. Wir werden uns auch um die Sicherheit kümmern und einen einfachen Authentifizierungsmechanismus für den Zugriff auf das Webinterface aktivieren. Öffnen Sie die folgende Datei, wenn Sie FastChat von PyPI installiert haben:

sudo nano /home/usergpu/.local/lib/python3.10/site-packages/fastchat/serve/gradio_web_server.py

oder

sudo nano /home/usergpu/FastChat/fastchat/serve/gradio_web_server.py

Blättern Sie bis zum Ende. Finden Sie diese Zeile:

auth=auth,

Ändern Sie sie, indem Sie einen beliebigen Benutzernamen oder ein beliebiges Passwort eingeben:

auth=(“username”,”password”),

Speichern Sie die Datei und beenden Sie sie mit Ctrl + X. Starten Sie schließlich die Webschnittstelle:

sudo systemctl start vicuna-webserver.service

Öffnen Sie http://[IP_ADDRESS]:7860 in Ihrem Browser und genießen Sie FastChat mit Vicuna:

Siehe auch:

Ihr eigener LLaMa 2 unter Linux

Mon, 20 Jan 2025 09:13:25 +0100

Schritt 1. Betriebssystem vorbereiten

Cache und Pakete aktualisieren

Bevor Sie mit der Einrichtung von LLaMa 2 beginnen, sollten Sie den Paket-Cache aktualisieren und Ihr Betriebssystem aufrüsten. Bitte beachten Sie, dass wir für diese Anleitung Ubuntu 22.04 LTS als Betriebssystem verwenden:

sudo apt update && sudo apt -y upgrade

Außerdem müssen wir Python Installer Packages (PIP) hinzufügen, falls es nicht bereits im System vorhanden ist:

sudo apt install python3-pip

Nvidia-Treiber installieren

Sie können das automatische Dienstprogramm verwenden, das in Ubuntu-Distributionen standardmäßig enthalten ist:

sudo ubuntu-drivers autoinstall

Alternativ können Sie die Nvidia-Treiber auch manuell mit Hilfe unserer Schritt-für-Schritt-Anleitung installieren. Vergessen Sie nicht, den Server neu zu starten:

sudo shutdown -r now

Schritt 2. Modelle von MetaAI abrufen

Offizielle Anfrage

Öffnen Sie die folgende Adresse in Ihrem Browser: https://ai.meta.com/resources/models-and-libraries/llama-downloads/

Füllen Sie alle erforderlichen Felder aus, lesen Sie die Benutzervereinbarung und klicken Sie auf die Schaltfläche Agree and Continue. Nach ein paar Minuten (Stunden, Tagen) erhalten Sie eine spezielle Download-URL, die Ihnen die Erlaubnis erteilt, Modelle für einen Zeitraum von 24 Stunden herunterzuladen.

Klonen Sie das Repository

Bitte überprüfen Sie vor dem Download den verfügbaren Speicherplatz:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs            38G  3.3M   38G   1% /run
/dev/sda2        99G   24G   70G  26% /
tmpfs           189G     0  189G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/nvme0n1    1.8T   26G  1.7T   2% /mnt/fastdisk
tmpfs            38G  8.0K   38G   1% /run/user/1000

Wenn Sie nicht gemountete lokale Festplatten haben, befolgen Sie bitte die Anweisungen unter Festplattenpartitionierung in Linux. Dies ist wichtig, da die heruntergeladenen Modelle sehr groß sein können und Sie deren Speicherort im Voraus planen müssen. In diesem Beispiel haben wir eine lokale SSD im Verzeichnis /mnt/fastdisk eingehängt. Öffnen wir es:

cd /mnt/fastdisk

Erstellen Sie eine Kopie des ursprünglichen LLaMa-Repositorys:

git clone https://github.com/facebookresearch/llama

Wenn Sie auf einen Berechtigungsfehler stoßen, erteilen Sie einfach dem Benutzerergpu die Berechtigungen:

sudo chown -R usergpu:usergpu /mnt/fastdisk/

Herunterladen per Skript

Öffnen Sie das heruntergeladene Verzeichnis:

cd llama

Führen Sie das Skript aus:

./download.sh

Geben Sie die von MetaAI bereitgestellte URL ein und wählen Sie alle erforderlichen Modelle aus. Wir empfehlen, alle verfügbaren Modelle herunterzuladen, damit Sie nicht erneut um Erlaubnis bitten müssen. Wenn Sie jedoch ein bestimmtes Modell benötigen, laden Sie nur dieses herunter.

Schnelltest über Beispiel-App

Zu Beginn können wir prüfen, ob Komponenten fehlen. Wenn Bibliotheken oder Anwendungen fehlen, werden sie vom Paketmanager automatisch installiert:

pip install -e .

Der nächste Schritt besteht darin, neue Binärdateien zu PATH hinzuzufügen:

export PATH=/home/usergpu/.local/bin:$PATH

Führen Sie das Demo-Beispiel aus:

torchrun --nproc_per_node 1 /mnt/fastdisk/llama/example_chat_completion.py --ckpt_dir /mnt/fastdisk/llama-2-7b-chat/ --tokenizer_path /mnt/fastdisk/llama/tokenizer.model --max_seq_len 512 --max_batch_size 6

Die Anwendung erstellt einen Rechenprozess auf der ersten GPU und simuliert einen einfachen Dialog mit typischen Anfragen, wobei die Antworten mit LLaMa 2 generiert werden.

Schritt 3. llama.cpp holen

LLaMa C++ ist ein Projekt des bulgarischen Physikers und Softwareentwicklers Georgi Gerganov. Es enthält viele nützliche Hilfsprogramme, die die Arbeit mit diesem neuronalen Netzwerkmodell erleichtern. Alle Teile von llama.cpp sind Open-Source-Software und werden unter der MIT-Lizenz vertrieben.

Klonen Sie das Repository

Öffnen Sie das Arbeitsverzeichnis auf der SSD:

cd /mnt/fastdisk

Klonen Sie das Repository des Projekts:

git clone https://github.com/ggerganov/llama.cpp.git

Anwendungen kompilieren

Öffnen Sie das geklonte Verzeichnis:

cd llama.cpp

Starten Sie den Kompilierungsprozess mit dem folgenden Befehl:

make

Schritt 4. Holen Sie text-generation-webui

Klonen Sie das Repository

Öffnen Sie das Arbeitsverzeichnis auf der SSD:

cd /mnt/fastdisk

Klonen Sie das Repository des Projekts:

git clone https://github.com/oobabooga/text-generation-webui.git

Anforderungen installieren

Öffnen Sie das heruntergeladene Verzeichnis:

cd text-generation-webui

Überprüfen und installieren Sie alle fehlenden Komponenten:

pip install -r requirements.txt

Schritt 5. PTH in GGUF umwandeln

Gängige Formate

PTH (Python TorcH) - Ein konsolidiertes Format. Im Wesentlichen handelt es sich um ein Standard-ZIP-Archiv mit einem serialisierten PyTorch-Zustandswörterbuch. Für dieses Format gibt es jedoch schnellere Alternativen wie GGML und GGUF.

GGML (Georgi Gerganov’s Machine Learning) - Dies ist ein Dateiformat, das von Georgi Gerganov, dem Autor von llama.cpp, entwickelt wurde. Es basiert auf einer gleichnamigen, in C++ geschriebenen Bibliothek, die die Leistung von großen Sprachmodellen erheblich gesteigert hat. Es wurde nun durch das moderne GGUF-Format ersetzt.

GGUF (Georgi Gerganov’s Unified Format) - Ein weit verbreitetes Dateiformat für LLMs, das von verschiedenen Anwendungen unterstützt wird. Es bietet verbesserte Flexibilität, Skalierbarkeit und Kompatibilität für die meisten Anwendungsfälle.

llama.cpp convert.py Skript

Bearbeiten Sie die Parameter des Modells vor der Konvertierung:

nano /mnt/fastdisk/llama-2-7b-chat/params.json

Korrigieren Sie "vocab_size": -1 auf "vocab_size": 32000. Speichern Sie die Datei und beenden Sie sie. Öffnen Sie dann das Verzeichnis llama.cpp:

cd /mnt/fastdisk/llama.cpp

Führen Sie das Skript aus, das das Modell in das GGUF-Format konvertiert:

python3 convert.py /mnt/fastdisk/llama-2-7b-chat/ --vocab-dir /mnt/fastdisk/llama

Wenn alle vorherigen Schritte korrekt ausgeführt wurden, erhalten Sie eine Meldung wie diese:

Wrote /mnt/fastdisk/llama-2-7b-chat/ggml-model-f16.gguf

Schritt 6. WebUI

So starten Sie WebUI

Öffnen Sie das Verzeichnis:

cd /mnt/fastdisk/text-generation-webui/

Führen Sie das Startskript mit einigen nützlichen Parametern aus:

--model-dir gibt den korrekten Pfad zu den Modellen an
--share erstellt einen temporären öffentlichen Link (wenn Sie keinen Port über SSH weiterleiten wollen)
--gradio-auth fügt eine Autorisierung mit Login und Passwort hinzu (ersetzen Sie user:password durch Ihr eigenes)

./start_linux.sh --model-dir /mnt/fastdisk/llama-2-7b-chat/ --share --gradio-auth user:password

Nach erfolgreichem Start erhalten Sie einen lokalen und einen temporären Freigabelink für den Zugriff:

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://e9a61c21593a7b251f.gradio.live

Dieser Freigabelink läuft in 72 Stunden ab.

Laden Sie das Modell

Autorisieren Sie sich in der WebUI mit dem gewählten Benutzernamen und Passwort und folgen Sie diesen 5 einfachen Schritten:

Navigieren Sie zur Registerkarte Model.
Wählen Sie ggml-model-f16.gguf aus dem Dropdown-Menü.
Wählen Sie, wie viele Schichten Sie auf dem Grafikprozessor berechnen möchten (n-gpu-layers).
Wählen Sie, wie viele Threads Sie starten möchten (threads).
Klicken Sie auf die Schaltfläche Load.

Starten Sie den Dialog

Ändern Sie die Registerkarte auf Chat, geben Sie Ihre Eingabeaufforderung ein und klicken Sie auf Generate:

Siehe auch:

Llama 3 mit Hugging Face

Mon, 20 Jan 2025 09:05:10 +0100

Am 18. April 2024 wurde das neueste große Sprachmodell von MetaAI, Llama 3, veröffentlicht. Zwei Versionen wurden den Benutzern vorgestellt: 8B und 70B. Die erste Version enthält mehr als 15K Token und wurde mit Daten trainiert, die bis März 2023 gültig waren. Die zweite, größere Version wurde mit Daten trainiert, die bis Dezember 2023 gültig sind.

Schritt 1. Vorbereiten des Betriebssystems

Cache und Pakete aktualisieren

Bevor Sie mit der Einrichtung von LLaMa 3 beginnen, sollten Sie den Paket-Cache aktualisieren und Ihr Betriebssystem aufrüsten. Bitte beachten Sie, dass wir für diese Anleitung Ubuntu 22.04 LTS als Betriebssystem verwenden:

sudo apt update && sudo apt -y upgrade

Außerdem müssen wir Python Installer Packages (PIP) hinzufügen, falls es nicht bereits im System vorhanden ist:

sudo apt install python3-pip

Nvidia-Treiber installieren

Sie können das automatische Dienstprogramm verwenden, das in Ubuntu-Distributionen standardmäßig enthalten ist:

sudo ubuntu-drivers autoinstall

Alternativ können Sie die Nvidia-Treiber auch manuell installieren. Vergessen Sie nicht, den Server neu zu starten:

sudo shutdown -r now

Schritt 2. Holen Sie sich das Modell

Melden Sie sich bei Hugging Face mit Ihrem Benutzernamen und Passwort an. Gehen Sie auf die Seite, die der gewünschten LLM-Version entspricht: Meta-Llama-3-8B oder Meta-Llama-3-70B. Zum Zeitpunkt der Veröffentlichung dieses Artikels wird der Zugang zum Modell auf individueller Basis gewährt. Füllen Sie ein kurzes Formular aus und klicken Sie auf die Schaltfläche Submit:

Zugang bei HF beantragen

Sie erhalten dann eine Nachricht, dass Ihr Antrag eingereicht wurde:

Sie erhalten nach 30-40 Minuten Zugang und werden darüber per E-Mail benachrichtigt.

SSH-Schlüssel zu HF hinzufügen

Erzeugen und fügen Sie einen SSH-Schlüssel hinzu, den Sie in Hugging Face verwenden können:

cd ~/.ssh && ssh-keygen

Wenn das Schlüsselpaar generiert ist, können Sie den öffentlichen Schlüssel im Terminalemulator anzeigen:

cat id_rsa.pub

Kopieren Sie alle Informationen, beginnend mit ssh-rsa und endend mit usergpu@gpuserver, wie im folgenden Screenshot gezeigt:

Öffnen Sie die Profileinstellungen von Hugging Face. Wählen Sie dann SSH and GPG Keys und klicken Sie auf die Schaltfläche SSH-Schlüssel hinzufügen:

Füllen Sie Key name aus und fügen Sie den kopierten SSH Public key aus dem Terminal ein. Speichern Sie den Schlüssel durch Drücken von Add key:

Nun ist Ihr HF-Konto mit dem öffentlichen SSH-Schlüssel verknüpft. Der zweite Teil (privater Schlüssel) ist auf dem Server gespeichert. Der nächste Schritt ist die Installation einer speziellen Git LFS-Erweiterung (Large File Storage), die für das Herunterladen großer Dateien wie z. B. Modelle neuronaler Netze verwendet wird. Öffnen Sie Ihr Home-Verzeichnis:

cd ~/

Laden Sie das Shell-Skript herunter und führen Sie es aus. Dieses Skript installiert ein neues Drittanbieter-Repository mit git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Nun können Sie es mit dem Standard-Paketmanager installieren:

sudo apt-get install git-lfs

Lassen Sie uns git so konfigurieren, dass es unseren HF-Nickname verwendet:

git config --global user.name "John"

Und mit dem HF-E-Mail-Konto verknüpft:

git config --global user.email "john.doe@example.com"

Das Modell herunterladen

Öffnen Sie das Zielverzeichnis:

cd /mnt/fastdisk

Und beginnen Sie mit dem Download des Repositorys. Für dieses Beispiel haben wir die Version 8B gewählt:

git clone git@hf.co:meta-llama/Meta-Llama-3-8B

Dieser Vorgang dauert bis zu 5 Minuten und kann durch Ausführen des folgenden Befehls in einer anderen SSH-Konsole überwacht werden:

watch -n 0.5 df -h

Hier sehen Sie, wie der freie Speicherplatz auf dem gemounteten Datenträger verringert wird, um sicherzustellen, dass der Download fortschreitet und die Daten gespeichert werden. Der Status wird jede halbe Sekunde aktualisiert. Um die Anzeige manuell zu beenden, drücken Sie die Tastenkombination Strg + C.

Alternativ können Sie auch btop installieren und den Prozess mit diesem Dienstprogramm überwachen:

sudo apt -y install btop && btop

Um das Dienstprogramm btop zu beenden, drücken Sie die Taste Esc und wählen Sie Quit.

Schritt 3. Ausführen des Modells

Öffnen Sie das Verzeichnis:

cd /mnt/fastdisk

Laden Sie das Llama 3 Repository herunter:

git clone https://github.com/meta-llama/llama3

Wechseln Sie das Verzeichnis:

cd llama3

Führen Sie das Beispiel aus:

torchrun --nproc_per_node 1 example_text_completion.py \
--ckpt_dir /mnt/fastdisk/Meta-Llama-3-8B/original \
--tokenizer_path /mnt/fastdisk/Meta-Llama-3-8B/original/tokenizer.model \
--max_seq_len 128 \
--max_batch_size 4

Jetzt können Sie Llama 3 in Ihren Anwendungen verwenden.

Siehe auch:

StarCoder: Ihr lokaler Assistent für die Programmierung

Fri, 17 Jan 2025 14:52:58 +0100

Microsoft CoPilot hat eine Revolution im Bereich der Softwareentwicklung ausgelöst. Dieser KI-Assistent hilft Entwicklern bei verschiedenen Codierungsaufgaben und macht ihnen das Leben leichter. Ein Nachteil ist jedoch, dass es sich nicht um eine eigenständige Anwendung, sondern um einen cloudbasierten Dienst handelt. Das bedeutet, dass die Nutzer den Nutzungsbedingungen zustimmen und für ein Abonnement bezahlen müssen.

Zum Glück gibt es in der Welt der Open-Source-Software zahlreiche Alternativen. Zum Zeitpunkt der Erstellung dieses Artikels ist die bemerkenswerteste Alternative zu CoPilot StarCoder, das vom BigCode-Projekt entwickelt wurde. StarCoder ist ein umfangreiches neuronales Netzmodell mit 15,5 B Parametern, das auf über 80 Programmiersprachen trainiert wurde.

Dieses Modell wird auf Hugging Face (HF) unter Verwendung eines Gated Models unter der BigCode OpenRAIL-M v1 Lizenzvereinbarung vertrieben. Sie können dieses Modell kostenlos herunterladen und verwenden, benötigen aber ein HF-Konto mit einem verknüpften SSH-Schlüssel. Bevor Sie das Modell herunterladen können, müssen Sie einige zusätzliche Schritte unternehmen.

SSH-Schlüssel zu HF hinzufügen

Bevor Sie beginnen, müssen Sie in Ihrem SSH-Client eine Portweiterleitung einrichten (Remote-Port 7860 auf 127.0.0.1:7860). Weitere Informationen finden Sie in den folgenden Artikeln:

Aktualisieren Sie das Paket-Cache-Repository und die installierten Pakete:

sudo apt update && sudo apt -y upgrade

Installieren Sie den System-Paketmanager von Python (PIP):

sudo apt install python3-pip

Erzeugen und fügen Sie einen SSH-Schlüssel hinzu, den Sie in Hugging Face verwenden können:

cd ~/.ssh && ssh-keygen

Wenn das Schlüsselpaar generiert ist, können Sie den öffentlichen Schlüssel im Terminalemulator anzeigen:

cat id_rsa.pub

Kopieren Sie alle Informationen, die mit ssh-rsa beginnen und mit usergpu@gpuserver enden, wie im folgenden Screenshot gezeigt:

Füllen Sie Key name aus und fügen Sie den kopierten SSH Public key aus dem Terminal ein. Speichern Sie den Schlüssel, indem Sie Add key drücken:

Jetzt ist Ihr HF-Konto mit dem öffentlichen SSH-Schlüssel verknüpft. Der zweite Teil (privater Schlüssel) ist auf dem Server gespeichert. Der nächste Schritt ist die Installation einer speziellen Git LFS-Erweiterung (Large File Storage), die für das Herunterladen großer Dateien wie z. B. Modelle neuronaler Netze verwendet wird. Öffnen Sie Ihr Home-Verzeichnis:

cd ~/

Laden Sie das Shell-Skript herunter und führen Sie es aus. Dieses Skript installiert ein neues Drittanbieter-Repository mit git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Nun können Sie es mit dem Standard-Paketmanager installieren:

sudo apt-get install git-lfs

Lassen Sie uns git so konfigurieren, dass es unseren HF-Nickname verwendet:

git config --global user.name "John"

Und mit dem HF-E-Mail-Konto verknüpft:

git config --global user.email "john.doe@example.com"

Das Modell herunterladen

Bitte beachten Sie, dass StarCoder im Binärformat eine beträchtliche Menge an Festplattenspeicher beanspruchen kann (>75 GB). Vergessen Sie nicht, diesen Artikel zu lesen, um sicherzustellen, dass Sie die richtige gemountete Partition verwenden.

Alles ist bereit für den Download des Modells. Öffnen Sie das Zielverzeichnis:

cd /mnt/fastdisk

Und starten Sie den Download des Repositorys:

git clone git@hf.co:bigcode/starcoder

Dieser Vorgang dauert bis zu 15 Minuten. Bitte haben Sie Geduld. Sie können dies überwachen, indem Sie den folgenden Befehl in einer anderen SSH-Konsole ausführen:

watch -n 0.5 df -h

Ausführen des vollständigen Modells mit WebUI

Klonen Sie das Repository des Projekts:

git clone https://github.com/oobabooga/text-generation-webui.git

Öffnen Sie das heruntergeladene Verzeichnis:

cd text-generation-webui

Führen Sie das Startskript aus:

./start_linux.sh --model-dir /mnt/fastdisk

Das Skript prüft, ob die notwendigen Abhängigkeiten auf dem Server vorhanden sind. Eventuell fehlende Abhängigkeiten werden automatisch installiert. Wenn die Anwendung startet, öffnen Sie Ihren Webbrowser und geben Sie die folgende Adresse ein:

http://127.0.0.1:7860

Öffnen Sie die Registerkarte Model und wählen Sie in der Dropdown-Liste das heruntergeladene Modell starcoder aus. Klicken Sie auf die Liste Model loader und wählen Sie Transformers. Stellen Sie den Schieberegler für den maximalen GPU-Speicher für jede installierte GPU ein. Dies ist sehr wichtig, da ein Wert von 0 die Verwendung von VRAM einschränkt und verhindert, dass das Modell korrekt geladen wird. Sie müssen auch die maximale RAM-Nutzung einstellen. Klicken Sie nun auf die Schaltfläche Load und warten Sie, bis der Ladevorgang abgeschlossen ist:

Wechseln Sie auf die Registerkarte Chat und testen Sie die Konversation mit dem Modell. Bitte beachte, dass Starcoder nicht für Dialoge wie ChatGPT gedacht ist. Es kann jedoch nützlich sein, um den Code auf Fehler zu überprüfen und Lösungen vorzuschlagen.

Wenn du ein vollwertiges Dialogmodell haben möchtest, kannst du zwei andere Modelle ausprobieren: starchat-alpha und starchat-beta. Diese Modelle wurden so angepasst, dass sie genau wie ChatGPT einen Dialog führen. Die folgenden Befehle helfen, diese Modelle herunterzuladen und auszuführen:

Für starchat-alpha:

git clone git@hf.co:HuggingFaceH4/starchat-alpha

Für starchat-beta:

git clone git@hf.co:HuggingFaceH4/starchat-beta

Das Ladeverfahren ist das gleiche wie oben beschrieben. Außerdem können Sie eine C++-Implementierung von starcoder finden, die für die CPU-Inferenz effektiv sein wird.

Siehe auch:

Stable Diffusion modelle: Anpassungen und Optionen

Mon, 25 Nov 2024 13:30:16 +0100

Tuning ist eine hervorragende Möglichkeit, jedes Auto oder Gerät zu verbessern. Auch generative neuronale Netze können getunt werden. Heute wollen wir nicht tief in die Struktur von Stable Diffusion eindringen, aber wir wollen bessere Ergebnisse erzielen als ein Standard-Setup.

Dazu gibt es zwei einfache Möglichkeiten: die Installation von benutzerdefinierten Modellen und die Nutzung von Standard-Optimierungsoptionen. In diesem Artikel erfahren wir, wie wir neue Modelle in Stable Diffusion installieren und mit welchen Optionen wir die Hardware effektiver nutzen können.

Wenn Sie lustige Bilder von niedlichen Katzen oder toll aussehendem Essen teilen möchten, posten Sie diese normalerweise auf Instagram. Wenn Sie Anwendungen entwickeln und den Code für alle zugänglich machen wollen, stellen Sie ihn auf GitHub ein. Wenn Sie jedoch ein grafisches KI-Modell trainieren und es mit anderen teilen möchten, sollten Sie sich CivitAI ansehen. Dies ist eine riesige Plattform, um Wissen und Ergebnisse mit Community-Mitgliedern zu teilen.

Bevor Sie mit dem Herunterladen beginnen, müssen Sie das Arbeitsverzeichnis ändern. Alle KI-Modelle in Stable Diffusion befinden sich im Verzeichnis "models": Bevor Sie mit dem Herunterladen beginnen, müssen Sie das Arbeitsverzeichnis ändern. Alle KI-Modelle in Stable Diffusion befinden sich im Verzeichnis "models":

cd stable-diffusion-webui/models/Stable-diffusion

Prüfen wir, welche Modelle standardmäßig bereitgestellt werden:

ls -a

'Put Stable Diffusion checkpoints here.txt'
v1-5-pruned-emaonly.safetensors

Es gibt nur ein Modell mit dem Namen "v1-5-pruned-emaonly" und der Erweiterung "safetensors". Dieses Modell ist ein guter Ausgangspunkt, aber wir haben fünf weitere interessante Modelle. Lassen Sie uns diese herunterladen und mit dem Standardmodell vergleichen.

Stabile Diffusionsaufforderungen

Um den Unterschied zwischen den Modellen visuell zu verdeutlichen, haben wir uns einfache Aufforderungen ausgedacht:

princess, magic, fairy tales, portrait, 85mm, colorful

Bei vielen Modellen kann die genaue Darstellung von Geometrie und Gesichtszügen eine große Herausforderung darstellen. Fügen Sie daher negative Eingabeaufforderungen hinzu, um sicherzustellen, dass Bilder ohne diese Merkmale erzeugt werden:

poorly rendered face, poorly drawn face, poor facial details, poorly drawn hands, poorly rendered hands, low resolution, bad composition, mutated body parts, blurry image, disfigured, oversaturated, bad anatomy, deformed body features

Stellen Sie den maximalen Wert der Abtastschritte (150) ein, um mehr Details im Ergebnis zu erhalten.

Standardmodell

Das Standardmodell ist für solche Aufgaben gut geeignet. Allerdings sind einige Details nicht ganz genau. Zum Beispiel gibt es ein Problem mit den Augen: Sie sind eindeutig unproportional:

Wenn man sich das Diadem ansieht, ist es ebenfalls schief und asymmetrisch. Der Rest der Details ist gut ausgeführt und entspricht den Vorgaben. Der Hintergrund ist unscharf, weil wir die Vorgabe "85mm" eingestellt haben. Dies ist eine in der professionellen Fotografie sehr häufig verwendete Brennweite für Porträts.

Realistische Vision

Dieses Modell ist hervorragend für Porträts geeignet. Das Bild sieht aus, als wäre es mit einem Qualitätsobjektiv mit der angegebenen Brennweite aufgenommen worden. Die Proportionen von Gesicht und Körper sind genau, das Kleid sitzt perfekt und das Diadem auf dem Kopf sieht ästhetisch ansprechend aus:

Übrigens empfiehlt der Autor, die folgende Vorlage für negative Prompts zu verwenden:

deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck

Aber auch mit unseren recht einfachen Aufforderungen ist das Ergebnis hervorragend.

Laden Sie die Vorlage hier herunter: Realistische Vision

Bewusst

Ein weiteres erstaunliches Modell für solche Zwecke. Die Details sind auch hier gut ausgearbeitet, aber seien Sie vorsichtig und überwachen Sie die Anzahl der Finger. Dies ist ein sehr häufiges Problem bei neuronalen Netzen: Sie können oft zusätzliche Finger oder sogar ganze Gliedmaßen zeichnen.

Das Erstellen visueller Linien ist eine der beliebtesten Filmtechniken. So hat sich dieses Modell auch dafür entschieden, eine Person vor dem Hintergrund eines Waldweges zu zeichnen.

Laden Sie das Modell hier herunter: Bewusst

OpenJourney

Unter den generativen neuronalen Netzen hat Midjourney (MJ) besondere Aufmerksamkeit erhalten. MJ war ein Pionier auf diesem Gebiet und wird oft als Beispiel für andere herangezogen. Die Bilder, die es erzeugt, haben einen einzigartigen Stil. OpenJourney ist vom MJ-Stil inspiriert und ist eine entsprechend abgestimmte Stable Diffusion.

Es werden Bilder erzeugt, die wie ein Cartoon aussehen. Sie sind lebendig und hell. Um bessere Ergebnisse zu erzielen, fügen Sie die Stil-Eingabeaufforderung mdjrny-v4 hinzu.

Laden Sie das Modell hier herunter: OpenJourney

Alles

Dieses Modell erzeugt Bilder, die denen eines professionellen Manga-Künstlers (einer Person, die Comics zeichnet) ähneln. Wir haben also eine Prinzessin im Anime-Stil.

Dieses Modell wird auf Bilder mit einer Auflösung von 768x768 trainiert. Sie können diese Auflösung einstellen, um bessere Ergebnisse als die Standardauflösung 512x512 zu erzielen.

Laden Sie das Modell hier herunter: Irgendetwas

Unternehmen Memphis

Dieser Bildstil erlangte in den frühen 2020er Jahren große Popularität und wurde in verschiedenen High-Tech-Unternehmen als Unternehmensstil verwendet. Trotz der Kritik ist er häufig in Präsentationen und Websites zu finden.

Die Prinzessin erwies sich als minimalistisch, aber recht hübsch. Besonders amüsant waren die Details, die das Modell auf dem Hintergrund platzierte.

Laden Sie das Modell hier herunter: Unternehmen Memphis

Stabile Diffusionsoptionen

Stabile Diffusion verbraucht viele Ressourcen, so dass viele Optionen für sie entwickelt worden sind. Die beliebteste von ihnen ist --xformers. Diese Option ermöglicht zwei Optimierungsmechanismen. Der erste reduziert den Speicherverbrauch und der zweite dient zur Erhöhung der Geschwindigkeit.

Wenn Sie versuchen, --xformers ohne zusätzliche Schritte hinzuzufügen, erhalten Sie eine Fehlermeldung, die besagt, dass die Pakete(torch und torchvision) für unterschiedliche Versionen von CUDA® kompiliert wurden. Um dies zu beheben, müssen wir die virtuelle Python-Umgebung (venv) aufrufen, die für Stable Diffusion verwendet wird. Danach installieren Sie die Pakete für die gewünschte CUDA-Version (v1.18).

Zunächst müssen wir den apt-Paket-Cache aktualisieren und den Paketinstaller für Python (pip) installieren. Der nächste Schritt besteht darin, Python venv mit dem Skript activate zu aktivieren:

source stable-diffusion-webui/venv/bin/activate

Danach ändert sich die Eingabeaufforderung zu (venv) username@hostname:~$. Installieren wir nun die Pakete torch und torchvision mit CUDA® 11.8:

pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --index-url https://download.pytorch.org/whl/cu118

Dieser Vorgang kann einige Minuten dauern, da die Pakete recht groß sind. Sie werden gerade genug Zeit haben, um sich einen Kaffee einzuschenken. Schließlich können Sie die virtuelle Umgebung deaktivieren und Stable Diffusion mit der Option --xformers starten (ersetzen Sie [user] und [password] durch Ihre eigenen Werte):

deactivate

./webui --xformers --listen --gradio-auth [user]:[password]

Die schnellere Alternative zu --xformers ist --opt-sdp-no-mem-attention. Sie verbraucht mehr Speicher, arbeitet aber etwas schneller. Sie können diese Option ohne zusätzliche Schritte verwenden.

Schlussfolgerung

Heute haben wir die Möglichkeiten von Stable Diffusion in Kombination mit anderen Modellen und Optimierungsoptionen untersucht. Denken Sie daran, dass Sie durch Erhöhen oder Verringern der Anzahl der Abtastschritte den Detailgrad des endgültigen Bildes anpassen können.

Natürlich ist dies nur ein kleiner Teil dessen, was Sie mit einem solchen generativen neuronalen Netz tun können. Bestellen Sie also gleich einen GPU-Server und fangen Sie an zu experimentieren. Viele weitere Entdeckungen und Möglichkeiten warten auf Sie. Schnelle und leistungsstarke Grafikkarten werden Ihnen helfen, Zeit zu sparen und tolle Bilder zu erzeugen.

Siehe auch:

Stable Diffusion WebUI

Mon, 25 Nov 2024 13:24:45 +0100

Generative neuronale Netze scheinen magisch zu sein. Sie beantworten Fragen, erstellen Bilder und schreiben sogar Code in verschiedenen Programmiersprachen. Der Erfolg dieser Netze beruht auf zwei Komponenten: vortrainierte Modelle und Hardwarebeschleuniger. Sicherlich ist es möglich, CPU-Kerne für dieses Arbeitspensum zu verwenden, aber das wäre wie ein Schneckenrennen. Die Erstellung eines kleinen Bildes kann sehr viel Zeit in Anspruch nehmen - mehrere Dutzend Minuten. Die Generierung desselben Bildes auf einem Grafikprozessor würde Hunderte Male weniger Zeit in Anspruch nehmen.

Das erste Geheimnis liegt in der Anzahl der Kerne. CPU-Kerne sind universell einsetzbar und können komplexe Befehle verarbeiten. Herkömmliche Serverprozessoren haben jedoch höchstens 64 Kerne. Selbst in Multiprozessorsystemen übersteigt die Anzahl der Kerne selten 256. GPU-Kerne sind einfacher, aber dafür passen viel mehr davon auf den Chip. Eine NVIDIA® RTX™ 4090 hat zum Beispiel 16.384 Kerne.

Das zweite Geheimnis ist, dass die Arbeitslast in viele einfache Aufgaben aufgeteilt werden kann, die in parallelen Threads auf dedizierten GPU-Kernen ausgeführt werden können. Dieser Trick beschleunigt die Datenverarbeitung erheblich. Heute werden wir sehen, wie es funktioniert und ein generatives neuronales Netzwerk Stable Diffusion Web UI auf der LeaderGPU-Infrastruktur einsetzen. Nehmen wir zum Beispiel einen Server mit einer NVIDIA® RTX™ 4090, die 16.384 GPU-Kerne hat. Als Betriebssystem haben wir das aktuelle LTS-Release Ubuntu 22.04 ausgewählt und die Option "Nvidia-Treiber und CUDA® 11.8 installieren" gewählt.

System vorbereiten

Bevor wir beginnen, sollten wir den Speicher berücksichtigen. Stable Diffusion ist ein großes System, das bis zu 13G auf Ihrer Festplatte belegen kann. Die virtuelle Standardfestplatte in einer LeaderGPU-Installation ist 100 GB groß. Das Betriebssystem beansprucht 25 GB. Wenn wir Stable Diffusion einsetzen, ohne die Home-Partition zu erweitern, wird der gesamte freie Speicher aufgebraucht sein und die Fehlermeldung "No space left on device" erscheinen. Es ist eine gute Idee, unser Home-Verzeichnis zu erweitern.

Erweitern des Home-Verzeichnisses

Zunächst müssen wir alle verfügbaren Festplatten überprüfen.

sudo fdisk -l

Disk /dev/sda: 447.13 GiB, 480103981056 bytes, 937703088 sectors
Disk model: INTEL SSDSC2KB48
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Disk model: VIRTUAL-DISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 9D4C1F0C-D4A7-406E-AECB-BF57E4726437

Dann müssen wir eine neue Linux-Partition auf unserem physischen SSD-Laufwerk, /dev/sda, erstellen:

sudo fdisk /dev/sda

Drücken Sie die folgenden Tasten, eine nach der anderen: g → n → Enter → Enter → Enter → w. Das Ergebnis ist eine neue Partition /dev/sda1 ohne Dateisystem. Erstellen Sie nun ein ext4-Dateisystem auf dieser Partition:

sudo mkfs.ext4 /dev/sda1

Wenn der Vorgang abgeschlossen ist, gehen wir zum nächsten Schritt über.

Achtung! Bitte führen Sie den folgenden Vorgang mit großer Vorsicht durch. Jeder Fehler, der beim Ändern der fstab-Datei gemacht wird, kann dazu führen, dass Ihr Server nicht mehr normal booten kann und ein komplettes Zurücksetzen des Betriebssystems erforderlich sein kann.

sudo blkid

/dev/sdb2: UUID="6b17e542-0934-4dba-99ca-a00bd260c247" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="70030755-75d8-4339-a4e0-26a97f1d1c5d"
/dev/loop1: TYPE="squashfs"
/dev/sdb1: PARTUUID="63ff1714-bd29-4062-be04-21af32423c0a"
/dev/loop4: TYPE="squashfs"
/dev/loop0: TYPE="squashfs"
/dev/sda1: UUID="fb2ba455-2b8d-4da0-8719-ce327d0026bc" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="6e0108df-b000-5848-8328-b187daf37a4f"
/dev/loop5: TYPE="squashfs"
/dev/loop3: TYPE="squashfs"

Kopieren Sie UUID (im Beispiel fb2ba455-2b8d-4da0-8719-ce327d0026bc) der Partition /dev/sda1. Als Nächstes werden wir das System anweisen, dieses Laufwerk beim Booten automatisch über seine UUID einzubinden:

sudo nano /etc/fstab

Geben Sie diese Zeile vor /swap.img... string ein:

/dev/disk/by-uuid/ /home/usergpu ext4 defaults defaults

Beispiel:

# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
#                
# / was on /dev/sdb2 during curtin installation
/dev/disk/by-uuid/6b17e542-0934-4dba-99ca-a00bd260c247 / ext4 defaults,_netdev 0 1
/dev/disk/by-uuid/fb2ba455-2b8d-4da0-8719-ce327d0026bc /home/usergpu ext4 defaults defaults
/swap.img       none    swap    sw      0       0

Beenden Sie das Programm mit dem Tastaturkürzel Ctrl + X und bestätigen Sie das Speichern der Datei mit Enter. Die neuen Einstellungen werden beim nächsten Systemstart übernommen. Lassen Sie uns den Server neu starten:

sudo shutdown -r now

Nach dem Neustart können wir alle eingehängten Verzeichnisse mit dem folgenden Befehl überprüfen:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs           6.3G  1.7M  6.3G   1% /run
/dev/sdb2        49G   23G   24G  50% /
tmpfs            32G     0   32G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/sda1       440G   28K  417G   1% /home/usergpu
tmpfs           6.3G  4.0K  6.3G   1% /run/user/1000

Superb! Aber jetzt haben wir keinen Zugriff mehr auf unser Home-Verzeichnis, weil es durch die Konfigurationsdatei fstab geändert wurde. Es ist an der Zeit, den Besitz des Verzeichnisses zurückzugewinnen:

sudo chown -R usergpu /home/usergpu

Gut gemacht! Gehen wir zum nächsten Schritt über.

Grundlegende Pakete installieren

Aktualisieren Sie den Software-Cache aus den offiziellen Ubuntu-Repositories und aktualisieren Sie einige Pakete:

sudo apt update && sudo apt -y upgrade

Das System hat mitgeteilt, dass ein neuer Kernel installiert wurde und nach dem Neustart des Systems betriebsbereit sein wird. Wählen Sie zweimal OK.

Als Nächstes müssen wir die Abhängigkeiten auflösen, für die Stable Diffusion erforderlich ist. Das erste Paket fügt die Funktionalität der virtuellen Python-Umgebung hinzu:

sudo apt install python3-venv

Das zweite Paket fügt eine Implementierung der Funktion malloc() der Programmiersprache C hinzu, die von Google angepasst wurde. Sie verhindert “Cannot locate TCMalloc” Fehler und verbessert die CPU-Speicherauslastung.

sudo apt install -y --no-install-recommends google-perftools

Starten Sie schließlich den Server neu:

sudo shutdown -r now

Stabile Diffusion automatisch 1111: Skript installieren

Der einfachste Weg, Stable Diffusion mit WebUI zu installieren, ist die Verwendung des vorgefertigten Skripts, das vom GitHub-Benutzer AUTOMATIC1111 geschrieben wurde. Dieses Skript lädt diese beiden Teile herunter und richtet sie ein, während es alle notwendigen Abhängigkeiten auflöst.

Lassen Sie uns das Skript herunterladen:

wget https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh

Geben Sie ihm dann Zugriff auf die Änderungsdaten und führen Sie es als Programm aus:

chmod a+x webui.sh

Führen Sie das heruntergeladene Skript aus:

./webui.sh

Dieser Vorgang kann ein paar Minuten dauern. Alles ist bereit, um perfekte Bilder mit Stable Diffusion zu erstellen.

Fehlersuche

Wenn Sie die Fehlermeldung "Torch is not able to use GPU" erhalten, können Sie das Problem durch eine Neuinstallation via apt beheben:

sudo apt -y install nvidia-driver-535

Sie müssen das Betriebssystem neu starten, um den Treiber zu aktivieren:

sudo shutdown -r now

Erzeugen Sie

Das Installationsskript ./webui.sh hat eine weitere Funktion. Es bedient gleichzeitig den Serverteil von Stable Diffusion und WebUI. Wenn Sie es jedoch ohne Argumente verwenden, ist der Server als lokaler Daemon unter http://127.0.0.1:7860 verfügbar. Dies kann auf zwei Arten gelöst werden: Portweiterleitung durch einen SSH-Tunnel oder Zulassen von Verbindungen von externen IPs.

Der zweite Weg ist einfacher: Fügen Sie einfach die Option --listen hinzu, und Sie können sich mit der Weboberfläche unter http://[YOUR_LEADERGPU_SERVER_IP_ADDRESS]:7860 verbinden. Dies ist jedoch völlig unsicher, da jeder Internetnutzer Zugang hat. Um eine unbefugte Nutzung zu verhindern, fügen Sie die Option --gradio-auth zusammen mit dem Benutzernamen und dem Passwort ein, getrennt durch einen Doppelpunkt:

./webui.sh --listen --gradio-auth user:password

Dies fügt Ihrer WebUI-Instanz eine Anmeldeseite hinzu, und das Skript lädt zum ersten Mal die Grundmodelle und die erforderlichen Abhängigkeiten herunter:

Sie können das Ergebnis genießen. Geben Sie einfach einige Eingabeaufforderungen ein, trennen Sie sie durch Kommata und klicken Sie auf die Schaltfläche Generieren. Nach ein paar Sekunden wird ein vom neuronalen Netz generiertes Bild angezeigt.

Fazit

Wir haben den ganzen Weg von einem leeren LeaderGPU-Server mit einem vorinstallierten Betriebssystem bis zu einer fertigen Instanz mit Stable Diffusion und einer WebUI-Schnittstelle zurückgelegt. Nächstes Mal werden wir mehr über Software-Performance-Tuning erfahren und wie Sie Ihre Stable Diffusion-Instanz mit neuen Versionen von Treibern und Paketen erweitern können.

Siehe auch: