Imagem e fala de IA

A tecnologia de IA pode fazer mais do que processar texto – ela pode gerar imagens de alta qualidade e processar fala. Este artigo aborda como instalar e usar ferramentas convencionais de geração de imagens de IA e reconhecimento de fala no Ubuntu 26.04.

WebUI de difusão estável (AUTOMATIC1111)

O Stable Diffusion WebUI do AUTOMATIC1111 é a ferramenta de geração de imagens de IA mais popular, fornecendo uma interface da web rica em recursos que suporta texto para imagem (txt2img), imagem para imagem (img2img), pintura interna e muito mais.

Requisitos do sistema

GPU NVIDIA com 8 GB + VRAM recomendado
Python 3.10+
Pelo menos 15 GB de espaço em disco (os modelos básicos têm de 4 a 7 GB cada)

Instalar dependências


# 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

Instale WebUI de difusão estável


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

Baixar modelos

O núcleo do Stable Diffusion é o arquivo do modelo do ponto de verificação, que deve ser baixado manualmente e colocado no diretório 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"

Baixe modelos de comunidade populares

A comunidade oferece muitos modelos ajustados no Civitai e no 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 a WebUI

Após o lançamento, visite http://localhost:7860 em seu navegador:

txt2img — Insira um prompt para gerar imagens
img2img — Faça upload de uma imagem de referência e modifique-a com base em um prompt
Inpaint — Selecione uma área de uma imagem para redesenho local
Extensões – Instale plug-ins para ampliar a funcionalidade

Exemplos de solicitações:


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

Crie um script de lançamento


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

Se sua GPU tiver 8 GB de VRAM, recomendamos iniciar com --medvram --xformers. Para modelos SDXL, recomenda-se pelo menos 10 GB de VRAM para a melhor experiência. Os modelos da série SD 1.5 funcionam perfeitamente com apenas 4 GB de VRAM.

UI confortável

ComfyUI é uma ferramenta de geração de imagens de IA de fluxo de trabalho baseada em nós que cria pipelines de geração de imagens por meio de conexões de nós visuais, oferecendo extrema flexibilidade.

Instale o 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

Inicie o 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

Instalar modelos

Estrutura de diretório do modelo do 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/

Fluxos de trabalho de nós

ComfyUI usa nós e conexões para construir pipelines de geração de imagens:

Abra seu navegador em http://localhost:8188
O fluxo de trabalho padrão inclui nós txt2img básicos
Clique com o botão direito na tela para adicionar novos nós
Clique em “Prompt de fila” para começar a gerar

Instale o 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

Nós 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

O ComfyUI tem uma curva de aprendizado mais acentuada que o AUTOMATIC1111 WebUI, mas oferece maior flexibilidade e reprodutibilidade. Comece com o fluxo de trabalho padrão e adicione gradualmente nós complexos. Você pode baixar fluxos de trabalho compartilhados pela comunidade em https://comfyworkflows.com ou https://openart.ai/workflows .

Sussurro OpenAI

OpenAI Whisper é um poderoso modelo de reconhecimento de fala que oferece suporte à conversão de fala em texto em vários idiomas com precisão extremamente alta.

Instalar o sussurro


# 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

Fala para 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/

Tamanhos de modelo Whisper

Modelo	Parâmetros	VRAM necessária	Velocidade relativa	Precisão
`tiny`	39 milhões	~1 GB	Mais rápido	Justo
`base`	74 milhões	~1 GB	Muito rápido	Bom
`small`	244 milhões	~2GB	Rápido	Melhorar
`medium`	769 milhões	~5GB	Médio	Muito bom
`large-v3`	1,5B	~10GB	Mais devagar	Melhor
`turbo`	809M	~6 GB	Rápido	Muito bom


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

Usando sussurro mais rápido (recomendado)

Fast-Whisper usa o mecanismo CTranslate2 e é 4x mais rápido que o Whisper original com 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

Processamento em lote de áudio


# 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 transcrição geral, o modelo medium oferece o melhor equilíbrio entre precisão e velocidade. Para máxima precisão, use large-v3. Para transcrição em tempo real ou processamento de grandes volumes de arquivos, use faster-whisper - ele fornece melhoria de velocidade de aproximadamente 4x com o mesmo nível de precisão.

Comparação de ferramentas

Ferramenta	Tipo	GPU necessária	Melhor para
UI AUTOMÁTICA1111	Geração de imagem	4 GB ou mais	Completo, adequado para iniciantes
UI confortável	Geração de imagem	4 GB ou mais	Fluxos de trabalho avançados, reprodutibilidade
Sussurrar	Fala para texto	Opcional	Transcrição de áudio, legendas
sussurro mais rápido	Fala para texto	Recomendado	Processamento de áudio de alto volume