KI-Bild und Sprache

KI-Technologie kann mehr als nur Text verarbeiten – sie kann hochwertige Bilder erzeugen und Sprache verarbeiten. In diesem Artikel erfahren Sie, wie Sie gängige KI-Bilderzeugungs- und Spracherkennungstools unter Ubuntu 26.04 installieren und verwenden.

Stabile Diffusion WebUI (AUTOMATIC1111)

Die Stable Diffusion WebUI von AUTOMATIC1111 ist das beliebteste Tool zur KI-Bildgenerierung und bietet eine funktionsreiche Weboberfläche, die Text-zu-Bild (txt2img), Bild-zu-Bild (img2img), Inpainting und mehr unterstützt.

Systemanforderungen

NVIDIA-GPU mit 8 GB+ VRAM empfohlen
Python 3.10+
Mindestens 15 GB Festplattenspeicher (Basismodelle sind jeweils 4–7 GB groß)

Abhängigkeiten installieren


# Install system dependencies
sudo apt update
sudo apt install -y git python3 python3-venv python3-pip \
  libgl1 libglib2.0-0 libsm6 libxext6 libxrender1 \
  wget curl
 
# Ensure NVIDIA drivers and CUDA are installed (see GPU Setup section)
nvidia-smi

Installieren Sie die Stable Diffusion WebUI


# Clone the repository
cd ~
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
 
# First launch (automatically installs Python dependencies and downloads base models)
# This may take 10-30 minutes depending on network speed
./webui.sh


# Custom launch parameters
./webui.sh --listen --port 7860 --enable-insecure-extension-access
 
# Common launch parameters:
# --listen          Allow remote access (default is local only)
# --port 7860       Specify port
# --xformers        Enable xformers acceleration (recommended)
# --medvram         Medium VRAM optimization (recommended for 8GB GPUs)
# --lowvram         Low VRAM optimization (for 4-6GB GPUs)
# --no-half         Disable half precision (needed for some AMD GPUs)

Modelle herunterladen

Der Kern von Stable Diffusion ist die Checkpoint-Modelldatei, die manuell heruntergeladen und im angegebenen Verzeichnis abgelegt werden muss.


# Model storage directory
mkdir -p ~/stable-diffusion-webui/models/Stable-diffusion
 
# Download Stable Diffusion XL base model
wget -O ~/stable-diffusion-webui/models/Stable-diffusion/sd_xl_base_1.0.safetensors \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"
 
# Download SDXL Refiner (optional, for image refinement)
wget -O ~/stable-diffusion-webui/models/Stable-diffusion/sd_xl_refiner_1.0.safetensors \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors"


# Download VAE model (improves image colors)
mkdir -p ~/stable-diffusion-webui/models/VAE
wget -O ~/stable-diffusion-webui/models/VAE/sdxl_vae.safetensors \
  "https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors"

Laden Sie beliebte Community-Modelle herunter

Die Community stellt viele fein abgestimmte Modelle für Civitai und Hugging Face bereit:


# Place models in the corresponding directories
# Checkpoint models -> models/Stable-diffusion/
# LoRA models       -> models/Lora/
# VAE models        -> models/VAE/
# Embeddings        -> embeddings/
 
mkdir -p ~/stable-diffusion-webui/models/Lora
mkdir -p ~/stable-diffusion-webui/embeddings
 
# Example: download a model from Hugging Face
# wget -O ~/stable-diffusion-webui/models/Stable-diffusion/model_name.safetensors "download-link"

Verwendung der WebUI

Besuchen Sie nach dem Start http://localhost:7860 in Ihrem Browser:

txt2img – Geben Sie eine Eingabeaufforderung zum Generieren von Bildern ein
img2img – Laden Sie ein Referenzbild hoch und ändern Sie es basierend auf einer Eingabeaufforderung
Inpaint – Wählen Sie einen Bereich eines Bildes zum lokalen Neuzeichnen aus
Erweiterungen – Installieren Sie Plugins, um die Funktionalität zu erweitern

Beispielaufforderungen:


Positive prompt: a beautiful mountain landscape, sunset, golden hour,
  photorealistic, 8k, masterpiece, best quality
Negative prompt: blurry, low quality, distorted, watermark, text

Erstellen Sie ein Startskript


cat > ~/stable-diffusion-webui/start.sh << 'EOF'
#!/bin/bash
cd ~/stable-diffusion-webui
./webui.sh --listen --xformers --enable-insecure-extension-access
EOF
chmod +x ~/stable-diffusion-webui/start.sh

Tip

Wenn Ihre GPU über 8 GB VRAM verfügt, empfehlen wir den Start mit --medvram --xformers. Für SDXL-Modelle werden für das beste Erlebnis mindestens 10 GB VRAM empfohlen. Modelle der SD 1.5-Serie laufen reibungslos mit nur 4 GB VRAM.

ComfyUI

ComfyUI ist ein knotenbasiertes Workflow-KI-Bildgenerierungstool, das Bildgenerierungspipelines durch visuelle Knotenverbindungen aufbaut und so extreme Flexibilität bietet.

Installieren Sie ComfyUI


# Install system dependencies
sudo apt install -y git python3 python3-venv python3-pip
 
# Clone ComfyUI
cd ~
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
 
# Create a Python virtual environment
python3 -m venv venv
source venv/bin/activate
 
# Install PyTorch (CUDA version)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
 
# Install ComfyUI dependencies
pip install -r requirements.txt

Starten Sie ComfyUI


cd ~/ComfyUI
source venv/bin/activate
 
# Launch (default port 8188)
python main.py
 
# Allow remote access
python main.py --listen 0.0.0.0 --port 8188
 
# Low VRAM mode
python main.py --lowvram

Modelle installieren

ComfyUIs Modellverzeichnisstruktur:


# Model directories
ls ~/ComfyUI/models/
# checkpoints/    -- Checkpoint models
# clip/           -- CLIP models
# loras/          -- LoRA models
# vae/            -- VAE models
# controlnet/     -- ControlNet models
# upscale_models/ -- Upscaling models
 
# You can reuse AUTOMATIC1111 models via symlinks
ln -s ~/stable-diffusion-webui/models/Stable-diffusion/* ~/ComfyUI/models/checkpoints/
ln -s ~/stable-diffusion-webui/models/Lora/* ~/ComfyUI/models/loras/
ln -s ~/stable-diffusion-webui/models/VAE/* ~/ComfyUI/models/vae/

Knoten-Workflows

ComfyUI verwendet Knoten und Verbindungen, um Pipelines zur Bildgenerierung zu erstellen:

Öffnen Sie Ihren Browser für http://localhost:8188
Der Standardworkflow umfasst grundlegende txt2img-Knoten
Klicken Sie mit der rechten Maustaste auf die Leinwand, um neue Knoten hinzuzufügen
Klicken Sie auf „Warteschlangen-Eingabeaufforderung“, um mit der Generierung zu beginnen

ComfyUI Manager installieren (empfohlen):


# ComfyUI Manager makes it easy to manage custom nodes
cd ~/ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
 
# After restarting ComfyUI, a Manager button will appear in the interface

Beliebte benutzerdefinierte Knoten


cd ~/ComfyUI/custom_nodes
 
# Advanced ControlNet nodes
git clone https://github.com/Fannovel16/comfyui_controlnet_aux.git
 
# IP-Adapter nodes (style transfer)
git clone https://github.com/cubiq/ComfyUI_IPAdapter_plus.git
 
# Image upscaling nodes
git clone https://github.com/ssitu/ComfyUI_UltimateSDUpscale.git
 
# Install dependencies for each node
cd ~/ComfyUI
source venv/bin/activate
for dir in custom_nodes/*/; do
  if [ -f "$dir/requirements.txt" ]; then
    pip install -r "$dir/requirements.txt"
  fi
done

Note

ComfyUI hat eine steilere Lernkurve als AUTOMATIC1111 WebUI, bietet aber eine größere Flexibilität und Reproduzierbarkeit. Beginnen Sie mit dem Standard-Workflow und fügen Sie nach und nach komplexe Knoten hinzu. Sie können von der Community freigegebene Workflows von https://comfyworkflows.com oder https://openart.ai/workflows . herunterladen

OpenAI Whisper

OpenAI Whisper ist ein leistungsstarkes Spracherkennungsmodell, das Sprache in Text in mehreren Sprachen mit extrem hoher Genauigkeit unterstützt.

Installieren Sie Whisper


# Install system dependencies
sudo apt install -y python3 python3-pip python3-venv ffmpeg
 
# Create a virtual environment (recommended)
python3 -m venv ~/whisper-env
source ~/whisper-env/bin/activate
 
# Install Whisper
pip install openai-whisper
 
# Or install with GPU acceleration (requires CUDA)
pip install openai-whisper torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

Sprache zum Text


# Activate virtual environment
source ~/whisper-env/bin/activate
 
# Basic usage: transcribe an audio file
whisper audio.mp3 --language en --model medium
 
# Specify output format
whisper audio.mp3 --language en --model medium --output_format txt
whisper audio.mp3 --language en --model medium --output_format srt  # Subtitle format
whisper audio.mp3 --language en --model medium --output_format vtt  # WebVTT format
whisper audio.mp3 --language en --model medium --output_format json
 
# Auto-detect language
whisper audio.mp3 --model medium
 
# Specify output directory
whisper audio.mp3 --language en --model medium --output_dir ~/transcripts/

Whisper-Modellgrößen

Modell	Parameter	VRAM erforderlich	Relative Geschwindigkeit	Genauigkeit
`tiny`	39M	~1 GB	Am schnellsten	Fair
`base`	74M	~1 GB	Sehr schnell	Gut
`small`	244M	~2 GB	Schnell	Besser
`medium`	769M	~5 GB	Mittel	Sehr gut
`large-v3`	1,5B	~10 GB	Langsamer	Am besten
`turbo`	809M	~6 GB	Schnell	Sehr gut


# Use different model sizes
whisper audio.mp3 --model tiny      # Fast but lower accuracy
whisper audio.mp3 --model small     # Balance of speed and accuracy
whisper audio.mp3 --model large-v3  # Highest accuracy
whisper audio.mp3 --model turbo     # Balance of speed and large model accuracy

Python-Nutzung


import whisper
 
# Load model
model = whisper.load_model("medium")
 
# Transcribe audio
result = model.transcribe("audio.mp3", language="en")
 
# Output text
print(result["text"])
 
# Output segments with timestamps
for segment in result["segments"]:
    print(f"[{segment['start']:.1f}s - {segment['end']:.1f}s] {segment['text']}")

Verwendung von Faster-Whisper (empfohlen)

schneller-flüstern nutzt die CTranslate2-Engine und ist 4x schneller als das ursprüngliche Whisper bei geringerer VRAM-Nutzung.


# Install faster-whisper
pip install faster-whisper


from faster_whisper import WhisperModel
 
# Load model (auto-downloads)
model = WhisperModel("medium", device="cuda", compute_type="float16")
 
# Transcribe
segments, info = model.transcribe("audio.mp3", language="en")
 
print(f"Detected language: {info.language}, confidence: {info.language_probability:.2f}")
 
for segment in segments:
    print(f"[{segment.start:.1f}s -> {segment.end:.1f}s] {segment.text}")


# faster-whisper command line usage
pip install faster-whisper-cli
faster-whisper audio.mp3 --language en --model medium --output_format srt

Stapelverarbeitung von Audio


# Create a batch transcription script
cat > ~/transcribe.sh << 'SCRIPT'
#!/bin/bash
# Batch transcribe all audio files in a directory
 
INPUT_DIR="${1:-.}"
OUTPUT_DIR="${2:-./transcripts}"
MODEL="${3:-medium}"
 
source ~/whisper-env/bin/activate
mkdir -p "$OUTPUT_DIR"
 
for file in "$INPUT_DIR"/*.{mp3,wav,m4a,flac,ogg}; do
  [ -f "$file" ] || continue
  echo "Transcribing: $file"
  whisper "$file" --language en --model "$MODEL" \
    --output_format srt --output_dir "$OUTPUT_DIR"
done
 
echo "Transcription complete! Results saved to $OUTPUT_DIR"
SCRIPT
chmod +x ~/transcribe.sh
 
# Use the script
# ~/transcribe.sh ~/audio_files ~/output medium

Tip

Für die allgemeine Transkription bietet das Modell medium das beste Gleichgewicht zwischen Genauigkeit und Geschwindigkeit. Für maximale Genauigkeit verwenden Sie large-v3. Für die Transkription in Echtzeit oder die Verarbeitung großer Dateimengen verwenden Sie faster-whisper – es bietet eine etwa vierfache Geschwindigkeitsverbesserung bei gleicher Genauigkeit.

Werkzeugvergleich

Werkzeug	Typ	GPU erforderlich	Am besten für
AUTOMATIC1111 WebUI	Bilderzeugung	4GB+	Voll ausgestattet, einsteigerfreundlich
ComfyUI	Bilderzeugung	4GB+	Erweiterte Arbeitsabläufe, Reproduzierbarkeit
Flüstern	Speech-to-Text	Optional	Audiotranskription, Untertitel
schneller-flüstern	Speech-to-Text	Empfohlen	Audioverarbeitung mit hoher Lautstärke