Skip to Content
DocumentationIAImage et parole IA

Image et parole IA

La technologie de l’IA peut faire plus que traiter du texte : elle peut générer des images de haute qualité et traiter la parole. Cet article explique comment installer et utiliser les outils traditionnels de génération d’images d’IA et de reconnaissance vocale sur Ubuntu 26.04.

Interface utilisateur Web à diffusion stable (AUTOMATIC1111)

L’interface Web à diffusion stable d’AUTOMATIC1111 est l’outil de génération d’images IA le plus populaire, fournissant une interface Web riche en fonctionnalités qui prend en charge le texte en image (txt2img), l’image en image (img2img), l’inpainting, etc.

Configuration système requise

  • GPU NVIDIA avec plus de 8 Go de VRAM recommandé
  • Python 3.10+
  • Au moins 15 Go d’espace disque (les modèles de base font 4 à 7 Go chacun)

Installer les dépendances

# 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

Installer l’interface Web de diffusion stable

# 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)

Télécharger des modèles

Le cœur de Stable Diffusion est le fichier de modèle de point de contrôle, qui doit être téléchargé manuellement et placé dans le répertoire spécifié.

# 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"

Télécharger des modèles communautaires populaires

La communauté propose de nombreux modèles peaufinés sur Civitai et Hugging Face :

# 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"

Utilisation de l’interface Web

Après le lancement, visitez http://localhost:7860 dans votre navigateur :

  1. txt2img — Entrez une invite pour générer des images
  2. img2img — Téléchargez une image de référence et modifiez-la en fonction d’une invite
  3. Inpaint - Sélectionnez une zone d’une image pour un redessin local
  4. Extensions – Installez des plugins pour étendre les fonctionnalités

Exemples d’invites :

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

Créer un script de lancement

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

Si votre GPU dispose de 8 Go de VRAM, nous vous recommandons de lancer avec --medvram --xformers. Pour les modèles SDXL, au moins 10 Go de VRAM sont recommandés pour une expérience optimale. Les modèles de la série SD 1.5 fonctionnent correctement avec seulement 4 Go de VRAM.

Interface utilisateur confortable

ComfyUI est un outil de génération d’images d’IA de flux de travail basé sur des nœuds qui crée des pipelines de génération d’images via des connexions de nœuds visuels, offrant une flexibilité extrême.

Installer 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

Lancez 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

Installer des modèles

Structure du répertoire modèle de ComfyUI :

# 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/

Flux de travail des nœuds

ComfyUI utilise des nœuds et des connexions pour créer des pipelines de génération d’images :

  1. Ouvrez votre navigateur sur http://localhost:8188
  2. Le flux de travail par défaut inclut les nœuds txt2img de base
  3. Cliquez avec le bouton droit sur le canevas pour ajouter de nouveaux nœuds
  4. Cliquez sur “Invite de file d’attente” pour commencer à générer

Installez ComfyUI Manager (recommandé) :

# 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

Nœuds personnalisés populaires

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 a une courbe d’apprentissage plus abrupte que AUTOMATIC1111 WebUI, mais offre une plus grande flexibilité et reproductibilité. Commencez avec le flux de travail par défaut et ajoutez progressivement des nœuds complexes. Vous pouvez télécharger des flux de travail partagés par la communauté depuis https://comfyworkflows.com  ou https://openart.ai/workflows ..

Murmure OpenAI

OpenAI Whisper est un puissant modèle de reconnaissance vocale prenant en charge la synthèse vocale dans plusieurs langues avec une précision extrêmement élevée.

Installer 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

Parole en texte

# 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/

Tailles des modèles Whisper

ModèleParamètresVRAM requiseVitesse relativePrécision
tiny39M~1 GoLe plus rapideÉquitable
base74M~1 GoTrès rapideBien
small244M~2 GoRapideMieux
medium769M~5 GoMoyenTrès bien
large-v31,5 milliards~10 GoRalentissezMeilleur
turbo809M~6 GoRapideTrès bien
# 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

Utilisation de Python

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']}")

Utiliser Fast-Whisper (recommandé)

quick-whisper utilise le moteur CTranslate2 et est 4 fois plus rapide que le Whisper d’origine avec une utilisation inférieure de la VRAM.

# 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

Traitement audio par lots

# 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

Pour la transcription générale, le modèle medium offre le meilleur équilibre entre précision et rapidité. Pour une précision maximale, utilisez large-v3. Pour la transcription en temps réel ou le traitement de gros volumes de fichiers, utilisez faster-whisper : il offre une vitesse environ 4 fois supérieure pour le même niveau de précision.

Comparaison d’outils

OutilTaperGPU requisIdéal pour
Interface utilisateur Web AUTOMATIQUE 1111Génération d’images4 Go+Complet, adapté aux débutants
Interface utilisateur confortableGénération d’images4 Go+Flux de travail avancés, reproductibilité
ChuchoterParole en texteFacultatifTranscription audio, sous-titres
murmurer plus viteParole en texteRecommandéTraitement audio à grand volume
LLM locauxDictée locale avec Myna