Configuración optimizada específica para AMD A4-9125 con Radeon R3

[Charly-bite]

Configuración optimizada para AMD A4-9125 con Radeon R3

Hardware Detectado

• CPU: AMD A4-9125 RADEON R3, 4 COMPUTE CORES 2C+2G
• Núcleos: 2 físicos / 2 lógicos
• RAM: 14.6 GB (excelente para un sistema de gama media)
• GPU: AMD Stoney [Radeon R2/R3/R4/R5 Graphics] integrada
• Arquitectura: Excavator (anterior a Zen, pero funcional)

Análisis del Sistema

Fortalezas

✅ RAM abundante: 14.6 GB permite usar modelos más grandes
✅ GPU AMD integrada: Puede acelerar transcripción con OpenCL
✅ Sistema balanceado: Configuración estable para transcripción

Limitaciones

⚠️ CPU de 2 núcleos: Limitará paralelización
⚠️ Arquitectura anterior: Pre-Zen, menos eficiente que generaciones nuevas
⚠️ GPU integrada: Compartida con sistema, rendimiento limitado

Configuración Optimizada Específica

1. Configuración para whisper.cpp

# config/whisper_amd_a4_9125.yaml
whisper_cpp_optimized:
  # Configuración específica para AMD A4-9125
  model_size: "small"  # Aprovechamos los 14.6 GB de RAM
  threads: 2           # Máximo para 2 núcleos físicos
  processors: 1        # Un proceso principal
  
  # GPU integrada Radeon R3
  use_gpu: true
  gpu_acceleration: "opencl"
  gpu_memory_fraction: 0.3  # Conservador para GPU integrada
  
  # Optimizaciones específicas
  batch_size: 1
  beam_size: 1         # Reducir para CPU de 2 núcleos
  best_of: 1          # Simplificar decodificación
  temperature: 0.0    # Determinístico
  
  # Configuración de memoria
  memory_optimization: true
  chunk_length: 30    # Chunks más cortos para CPU limitado
  
  # Idioma
  language: "es"
  task: "transcribe"

2. Script de instalación optimizada

#!/bin/bash
# install_whisper_amd_a4_9125.sh

echo "🔧 Instalación optimizada para AMD A4-9125"
echo "=========================================="

# Verificar distribución
if [ -f /etc/os-release ]; then
    . /etc/os-release
    OS_NAME=$NAME
fi

echo "🐧 Sistema: $OS_NAME"

# Instalar dependencias OpenCL para Radeon R3
echo "📦 Instalando soporte OpenCL para Radeon R3..."

if [[ "$OS_NAME" == *"Ubuntu"* ]] || [[ "$OS_NAME" == *"Debian"* ]]; then
    sudo apt update
    sudo apt install -y mesa-opencl-icd opencl-headers clinfo
    sudo apt install -y build-essential cmake git pkg-config
    sudo apt install -y libopenblas-dev
    
elif [[ "$OS_NAME" == *"Arch"* ]] || [[ "$OS_NAME" == *"Manjaro"* ]]; then
    sudo pacman -S --noconfirm opencl-mesa opencl-headers clinfo
    sudo pacman -S --noconfirm base-devel cmake git pkg-config
    sudo pacman -S --noconfirm openblas
    
elif [[ "$OS_NAME" == *"Fedora"* ]]; then
    sudo dnf install -y mesa-libOpenCL opencl-headers clinfo
    sudo dnf install -y gcc-c++ cmake git pkg-config
    sudo dnf install -y openblas-devel
fi

# Verificar OpenCL
echo "🔍 Verificando soporte OpenCL..."
if command -v clinfo &> /dev/null; then
    clinfo -l
else
    echo "⚠️ clinfo no disponible, instalando..."
fi

# Compilar whisper.cpp con optimizaciones específicas
echo "🔨 Compilando whisper.cpp para AMD A4-9125..."

# Clonar si no existe
if [ ! -d "whisper.cpp" ]; then
    git clone https://github.com/ggerganov/whisper.cpp.git
fi

cd whisper.cpp
mkdir -p build
cd build

# Configuración CMake optimizada para A4-9125
cmake -DCMAKE_BUILD_TYPE=Release \
      -DWHISPER_OPENBLAS=ON \
      -DWHISPER_OPENCL=ON \
      -DCMAKE_C_FLAGS="-O2 -march=btver2 -mtune=btver2" \
      -DCMAKE_CXX_FLAGS="-O2 -march=btver2 -mtune=btver2" \
      ..

# Compilar con 2 threads (máximo para el A4-9125)
make -j2

echo "✅ whisper.cpp compilado con optimizaciones para AMD A4-9125"

# Instalar
sudo cp bin/whisper /usr/local/bin/whisper-amd
sudo cp bin/main /usr/local/bin/whisper-main-amd

echo "🎉 Instalación completada!"
echo "📍 Binario: /usr/local/bin/whisper-amd"

3. Script de descarga optimizada de modelos

#!/usr/bin/env python3
"""
Descarga y configuración de modelos optimizada para AMD A4-9125
"""

import subprocess
import requests
import os
from pathlib import Path

def download_optimal_models():
    """Descargar modelos óptimos para A4-9125"""
    
    print("📥 Descargando modelos optimizados para AMD A4-9125...")
    
    # Crear directorio de modelos
    models_dir = Path.home() / ".cache" / "whisper"
    models_dir.mkdir(parents=True, exist_ok=True)
    
    # Modelos recomendados para A4-9125
    recommended_models = [
        {
            "name": "base",
            "size": "~142MB",
            "description": "Modelo principal recomendado",
            "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin",
            "priority": 1
        },
        {
            "name": "small", 
            "size": "~466MB",
            "description": "Mejor calidad (aprovecha la RAM abundante)",
            "url": "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin",
            "priority": 2
        }
    ]
    
    for model in recommended_models:
        model_file = models_dir / f"ggml-{model['name']}.bin"
        
        if model_file.exists():
            print(f"✅ Modelo {model['name']} ya existe")
            continue
            
        print(f"\n📦 Descargando modelo {model['name']} ({model['size']})...")
        print(f"📝 {model['description']}")
        
        try:
            response = requests.get(model['url'], stream=True)
            response.raise_for_status()
            
            total_size = int(response.headers.get('content-length', 0))
            downloaded = 0
            
            with open(model_file, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    if chunk:
                        f.write(chunk)
                        downloaded += len(chunk)
                        
                        if total_size > 0:
                            progress = (downloaded / total_size) * 100
                            print(f"\r[{'='*int(progress//5)}{' '*(20-int(progress//5))}] {progress:.1f}%", end='', flush=True)
            
            print(f"\n✅ Modelo {model['name']} descargado exitosamente")
            
        except Exception as e:
            print(f"\n❌ Error descargando {model['name']}: {e}")
            if model_file.exists():
                model_file.unlink()
    
    print("\n🎯 MODELOS INSTALADOS:")
    for model_file in models_dir.glob("ggml-*.bin"):
        size_mb = model_file.stat().st_size / (1024 * 1024)
        print(f"   📁 {model_file.name}: {size_mb:.1f} MB")

def test_transcription():
    """Probar transcripción con configuración optimizada"""
    
    print("\n🧪 PROBANDO TRANSCRIPCIÓN...")
    
    # Crear audio de prueba específico para español
    test_audio = "test_amd_a4.wav"
    
    if not Path(test_audio).exists():
        print("🎵 Creando audio de prueba...")
        try:
            subprocess.run([
                "espeak-ng", "-s", "140", "-v", "es-es",
                "-w", test_audio,
                "Hola, esta es una prueba de transcripción optimizada para procesador AMD A4-9125 con gráficos Radeon R3"
            ], check=True)
            print("✅ Audio de prueba creado")
        except (subprocess.CalledProcessError, FileNotFoundError):
            print("⚠️ espeak-ng no disponible. Instalar con: sudo apt install espeak-ng")
            return
    
    # Probar con modelo base
    print("\n🔍 Probando modelo base...")
    try:
        result = subprocess.run([
            "whisper-amd", test_audio,
            "--model", "base",
            "--language", "es", 
            "--threads", "2",
            "--output_format", "txt"
        ], capture_output=True, text=True, timeout=60)
        
        if result.returncode == 0:
            print("✅ Transcripción base exitosa")
        else:
            print(f"❌ Error en transcripción base: {result.stderr}")
            
    except subprocess.TimeoutExpired:
        print("⏰ Timeout en transcripción base")
    except FileNotFoundError:
        print("❌ whisper-amd no encontrado. Ejecutar instalación primero.")

if __name__ == "__main__":
    download_optimal_models()
    test_transcription()

4. Configuración del ProcessingAgent optimizada

# Modificación para agents/processing_agent.py
class OptimizedAMDProcessingAgent(ProcessingAgent):
    """ProcessingAgent optimizado para AMD A4-9125"""
    
    def __init__(self):
        super().__init__()
        
        # Configuración específica para A4-9125
        self.amd_config = {
            "binary_path": "whisper-amd",
            "optimal_threads": 2,
            "optimal_model": "base",  # Cambiable a "small" si funciona bien
            "chunk_duration": 30,     # Chunks más cortos
            "use_opencl": True,
            "memory_limit": 0.7       # Usar máximo 70% de RAM para whisper
        }
    
    def transcribe_audio_amd_optimized(self, audio_filepath: Path, language: str = "es"):
        """Transcripción optimizada para AMD A4-9125"""
        
        print(f"[{self.agent_name}] Iniciando transcripción AMD optimizada...")
        
        # Comando optimizado para A4-9125
        cmd = [
            self.amd_config["binary_path"],
            str(audio_filepath),
            "--model", self.amd_config["optimal_model"],
            "--language", language,
            "--threads", str(self.amd_config["optimal_threads"]),
            "--output_format", "json",
            "--word_timestamps"
        ]
        
        # Añadir OpenCL si está disponible
        if self.amd_config["use_opencl"]:
            cmd.extend(["--use_gpu"])
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
            
            if result.returncode == 0:
                print(f"[{self.agent_name}] Transcripción AMD completada exitosamente")
                return {
                    "text": result.stdout,
                    "engine": "whisper-amd-optimized",
                    "model": self.amd_config["optimal_model"],
                    "threads_used": self.amd_config["optimal_threads"]
                }
            else:
                print(f"[{self.agent_name}] Error en transcripción: {result.stderr}")
                return None
                
        except subprocess.TimeoutExpired:
            print(f"[{self.agent_name}] Timeout en transcripción AMD")
            return None

Pasos de Implementación

Fase 1: Instalación Base

1. Ejecutar: bash install_whisper_amd_a4_9125.sh
2. Verificar OpenCL: clinfo -l
3. Probar binario: whisper-amd --help

Fase 2: Descarga de Modelos

1. Ejecutar: python download_models_amd.py
2. Verificar modelos: ls -la ~/.cache/whisper/

Fase 3: Integración

1. Modificar ProcessingAgent con configuración AMD
2. Probar pipeline completo
3. Hacer benchmark de rendimiento

Rendimiento Esperado

Con modelo base:

• Velocidad: ~3-5x tiempo real (audio de 1 min = 3-5 min procesamiento)
• Calidad: Buena para español
• Uso RAM: ~2-3 GB durante transcripción

Con modelo small:

• Velocidad: ~5-8x tiempo real
• Calidad: Muy buena para español
• Uso RAM: ~4-5 GB durante transcripción

Optimizaciones Adicionales

1. Swap: Configurar swap file si no existe
2. CPU Governor: Cambiar a "performance" durante transcripción
3. Memoria: Cerrar aplicaciones innecesarias durante transcripción
4. OpenCL: Verificar que los drivers AMD están actualizados