Imagen y voz de IA

La tecnología de IA puede hacer más que procesar texto: puede generar imágenes de alta calidad y procesar voz. Este artículo cubre cómo instalar y utilizar las principales herramientas de reconocimiento de voz y generación de imágenes de IA en Ubuntu 26.04.

WebUI de difusión estable (AUTOMATIC1111)

La Stable Diffusion WebUI de AUTOMATIC1111 es la herramienta de generación de imágenes de IA más popular y proporciona una interfaz web rica en funciones que admite conversión de texto a imagen (txt2img), imagen a imagen (img2img), inpainting y más.

Requisitos del sistema

Se recomienda GPU NVIDIA con 8 GB+ de VRAM
Python 3.10+
Al menos 15 GB de espacio en disco (los modelos básicos tienen entre 4 y 7 GB cada uno)

Instalar dependencias


# 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

Instalar la interfaz de usuario web de difusión estable


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

Descargar Modelos

El núcleo de Stable Diffusion es el archivo del modelo de punto de control, que debe descargarse manualmente y colocarse en el directorio especificado.


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

Descargar modelos comunitarios populares

La comunidad proporciona muchos modelos perfeccionados en Civitai y 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"

Usando la interfaz de usuario web

Después del inicio, visite http://localhost:7860 en su navegador:

txt2img — Ingrese un mensaje para generar imágenes
img2img — Cargue una imagen de referencia y modifíquela según se le solicite
Inpaint: seleccione un área de una imagen para volver a dibujarla localmente
Extensiones: instale complementos para ampliar la funcionalidad

Indicaciones de ejemplo:


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

Crear un script de lanzamiento


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 su GPU tiene 8 GB de VRAM, le recomendamos iniciar con --medvram --xformers. Para los modelos SDXL, se recomiendan al menos 10 GB de VRAM para disfrutar de la mejor experiencia. Los modelos de la serie SD 1.5 funcionan sin problemas con solo 4 GB de VRAM.

Cómoda interfaz de usuario

ComfyUI es una herramienta de generación de imágenes de IA de flujo de trabajo basada en nodos que crea canales de generación de imágenes a través de conexiones de nodos visuales, ofreciendo una flexibilidad extrema.

Instalar cómoda UI


# 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

Inicie la interfaz de usuario cómoda


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

Instalar modelos

Estructura de directorio modelo 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/

Flujos de trabajo de nodo

ComfyUI utiliza nodos y conexiones para crear canales de generación de imágenes:

Abra su navegador en http://localhost:8188
El flujo de trabajo predeterminado incluye nodos txt2img básicos
Haga clic derecho en el lienzo para agregar nuevos nodos
Haga clic en “Mensaje de cola” para comenzar a generar

Instale ComfyUI Manager (recomendado):


# 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

Nodos personalizados populares


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 tiene una curva de aprendizaje más pronunciada que AUTOMATIC1111 WebUI, pero ofrece mayor flexibilidad y reproducibilidad. Comience con el flujo de trabajo predeterminado y agregue gradualmente nodos complejos. Puede descargar flujos de trabajo compartidos por la comunidad desde https://comfyworkflows.com o https://openart.ai/workflows .

Susurro de OpenAI

OpenAI Whisper es un potente modelo de reconocimiento de voz que admite conversión de voz a texto en varios idiomas con una precisión extremadamente alta.

Instalar susurro


# 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

Voz a texto


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

Tamaños de los modelos Whisper

Modelo	Parámetros	VRAM requerida	Velocidad relativa	Exactitud
`tiny`	39M	~1GB	Lo más rápido	Justo
`base`	74M	~1GB	muy rapido	Bien
`small`	244M	~2GB	Rápido	Mejor
`medium`	769M	~5GB	Medio	Muy bien
`large-v3`	1,5 mil millones	~10GB	Más lento	Mejor
`turbo`	809M	~6GB	Rápido	Muy 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

Python Uso


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

Usar un susurro más rápido (recomendado)

Fast-Whisper utiliza el motor CTranslate2 y es 4 veces más rápido que el Whisper original con un menor uso de 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

Audio de procesamiento por lotes


# 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

Para la transcripción general, el modelo medium ofrece el mejor equilibrio entre precisión y velocidad. Para obtener la máxima precisión, utilice large-v3. Para transcripción en tiempo real o procesamiento de grandes volúmenes de archivos, utilice faster-whisper: proporciona una mejora de velocidad de aproximadamente 4 veces con el mismo nivel de precisión.

Comparación de herramientas

Herramienta	Tipo	Se requiere GPU	Mejor para
AUTOMÁTICO1111 WebUI	Generación de imágenes	4GB+	Completamente funcional y apto para principiantes
Cómoda interfaz de usuario	Generación de imágenes	4GB+	Flujos de trabajo avanzados, reproducibilidad
Susurro	Voz a texto	Opcional	Transcripción de audio, subtítulos.
susurro más rápido	Voz a texto	Recomendado	Procesamiento de audio de alto volumen