Solucionar dependencias faltantes - Script de detección AMD alternativo

[Charly-bite]

Solucionar dependencias faltantes para detección de hardware AMD

Error Encontrado

ModuleNotFoundError: No module named 'psutil'

Soluciones

Opción 1: Instalar psutil

# Instalar psutil en el entorno virtual
pip install psutil

# O si usas el sistema global
sudo apt install python3-psutil  # Ubuntu/Debian
sudo pacman -S python-psutil     # Arch/Manjaro
sudo dnf install python3-psutil  # Fedora

Opción 2: Versión sin dependencias externas

Script alternativo que usa solo comandos del sistema Linux:

#!/usr/bin/env python3
"""
Detección de hardware AMD sin dependencias externas
Solo usa comandos nativos de Linux
"""

import subprocess
import re
import os
from pathlib import Path

def run_command(cmd):
    """Ejecutar comando del sistema de forma segura"""
    try:
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        return result.stdout.strip() if result.returncode == 0 else ""
    except Exception:
        return ""

def detect_cpu_info():
    """Detectar información del CPU AMD"""
    print("🔍 Detectando CPU AMD...")
    
    cpu_info = {}
    
    # Leer /proc/cpuinfo
    try:
        with open('/proc/cpuinfo', 'r') as f:
            cpuinfo = f.read()
        
        # Extraer modelo del CPU
        model_match = re.search(r'model name\s*:\s*(.+)', cpuinfo)
        if model_match:
            cpu_info["model_name"] = model_match.group(1).strip()
            print(f"✅ CPU: {cpu_info['model_name']}")
        
        # Contar núcleos físicos
        physical_cores = len(re.findall(r'^processor\s*:', cpuinfo, re.MULTILINE))
        cpu_info["logical_cores"] = physical_cores
        
        # Estimar núcleos físicos (aproximación)
        siblings = re.search(r'siblings\s*:\s*(\d+)', cpuinfo)
        cpu_cores = re.search(r'cpu cores\s*:\s*(\d+)', cpuinfo)
        
        if siblings and cpu_cores:
            cpu_info["physical_cores"] = int(cpu_cores.group(1))
        else:
            cpu_info["physical_cores"] = physical_cores // 2  # Aproximación para SMT
        
        print(f"🔢 Núcleos: {cpu_info['physical_cores']} físicos / {cpu_info['logical_cores']} lógicos")
        
        # Detectar arquitectura Zen
        model_name = cpu_info.get("model_name", "").lower()
        if "ryzen" in model_name:
            if any(x in model_name for x in ["7000", "8000"]):
                cpu_info["architecture"] = "Zen4"
                print("🏗️  Arquitectura: Zen 4 (Última generación)")
            elif any(x in model_name for x in ["5000", "6000"]):
                cpu_info["architecture"] = "Zen3"
                print("🏗️  Arquitectura: Zen 3 (Excelente)")
            elif "4000" in model_name:
                cpu_info["architecture"] = "Zen2"
                print("🏗️  Arquitectura: Zen 2 (Muy bueno)")
            elif "3000" in model_name:
                cpu_info["architecture"] = "Zen2"
                print("🏗️  Arquitectura: Zen 2 (Muy bueno)")
            elif "2000" in model_name:
                cpu_info["architecture"] = "Zen+"
                print("🏗️  Arquitectura: Zen+ (Bueno)")
            else:
                cpu_info["architecture"] = "Zen"
                print("🏗️  Arquitectura: Zen (Básico)")
        
    except Exception as e:
        print(f"❌ Error leyendo CPU info: {e}")
    
    return cpu_info

def detect_memory_info():
    """Detectar información de memoria"""
    print("🔍 Detectando memoria...")
    
    memory_info = {}
    
    try:
        with open('/proc/meminfo', 'r') as f:
            meminfo = f.read()
        
        # Extraer memoria total
        total_match = re.search(r'MemTotal:\s*(\d+)\s*kB', meminfo)
        if total_match:
            total_kb = int(total_match.group(1))
            total_gb = round(total_kb / (1024 * 1024), 1)
            memory_info["total_gb"] = total_gb
            print(f"💾 RAM Total: {total_gb} GB")
        
        # Extraer memoria disponible
        available_match = re.search(r'MemAvailable:\s*(\d+)\s*kB', meminfo)
        if available_match:
            available_kb = int(available_match.group(1))
            available_gb = round(available_kb / (1024 * 1024), 1)
            memory_info["available_gb"] = available_gb
            print(f"💾 RAM Disponible: {available_gb} GB")
    
    except Exception as e:
        print(f"❌ Error leyendo memoria: {e}")
    
    return memory_info

def detect_gpu_info():
    """Detectar GPU AMD"""
    print("🔍 Detectando GPU AMD...")
    
    gpu_info = {}
    
    # Usar lspci para detectar GPU
    lspci_output = run_command("lspci | grep -i 'vga\\|3d\\|display'")
    
    if lspci_output:
        for line in lspci_output.split('\n'):
            if 'amd' in line.lower() or 'ati' in line.lower() or 'radeon' in line.lower():
                gpu_info["detected_gpu"] = line.strip()
                print(f"✅ GPU AMD: {line.split(':')[-1].strip()}")
                
                # Detectar serie RX
                if "rx" in line.lower():
                    rx_match = re.search(r'rx\s*(\d+)', line, re.IGNORECASE)
                    if rx_match:
                        gpu_info["series"] = f"RX {rx_match.group(1)}"
                        print(f"🎮 Serie: {gpu_info['series']}")
                break
    else:
        print("⚠️ No se detectó GPU AMD discreta")
    
    # Verificar drivers cargados
    lsmod_output = run_command("lsmod | grep -E 'amdgpu|radeon'")
    if lsmod_output:
        gpu_info["drivers_loaded"] = lsmod_output.split('\n')
        print("✅ Drivers AMD cargados")
    else:
        print("⚠️ No se detectaron drivers AMD activos")
    
    return gpu_info

def generate_optimizations(cpu_info, memory_info, gpu_info):
    """Generar configuraciones optimizadas"""
    print("⚙️ Generando optimizaciones...")
    
    # Configuración base
    config = {
        "whisper_cpp": {
            "model_size": "base",
            "threads": 4,
            "use_gpu": False
        }
    }
    
    # Optimizar según CPU
    physical_cores = cpu_info.get("physical_cores", 4)
    architecture = cpu_info.get("architecture", "")
    
    if "Zen4" in architecture or "Zen3" in architecture:
        config["whisper_cpp"]["threads"] = min(physical_cores, 8)
        config["whisper_cpp"]["model_size"] = "small"
        print(f"🚀 Optimización Zen3/4: {config['whisper_cpp']['threads']} threads, modelo {config['whisper_cpp']['model_size']}")
    elif "Zen2" in architecture:
        config["whisper_cpp"]["threads"] = max(4, physical_cores - 2)
        config["whisper_cpp"]["model_size"] = "base"
        print(f"⚡ Optimización Zen2: {config['whisper_cpp']['threads']} threads, modelo {config['whisper_cpp']['model_size']}")
    else:
        config["whisper_cpp"]["threads"] = min(physical_cores, 4)
        print(f"📊 Configuración conservadora: {config['whisper_cpp']['threads']} threads")
    
    # Optimizar según memoria
    total_memory = memory_info.get("total_gb", 8)
    if total_memory >= 32:
        config["whisper_cpp"]["model_size"] = "medium"
        print("💾 Memoria alta: usando modelo medium")
    elif total_memory >= 16:
        if config["whisper_cpp"]["model_size"] == "base":
            config["whisper_cpp"]["model_size"] = "small"
        print("💾 Memoria suficiente: usando modelo small")
    
    # GPU
    if gpu_info.get("detected_gpu") and gpu_info.get("drivers_loaded"):
        config["whisper_cpp"]["use_gpu"] = True
        print("🎮 GPU habilitada para aceleración")
    
    return config

def save_config(cpu_info, memory_info, gpu_info, optimizations):
    """Guardar configuración en archivos"""
    
    # Crear perfil del sistema
    system_profile = {
        "detection_date": "2025-06-14",
        "cpu": cpu_info,
        "memory": memory_info,
        "gpu": gpu_info,
        "optimizations": optimizations
    }
    
    # Guardar JSON
    import json
    with open("system_profile_amd.json", "w") as f:
        json.dump(system_profile, f, indent=2)
    print("💾 Perfil guardado: system_profile_amd.json")
    
    # Crear configuración YAML para whisper
    whisper_config = optimizations["whisper_cpp"]
    yaml_content = f"""# Configuración optimizada para AMD detectada automáticamente
whisper_cpp_amd:
  model_size: "{whisper_config['model_size']}"
  threads: {whisper_config['threads']}
  use_gpu: {str(whisper_config['use_gpu']).lower()}
  
  # Información del sistema
  system_info:
    cpu: "{cpu_info.get('model_name', 'AMD CPU')}"
    architecture: "{cpu_info.get('architecture', 'Unknown')}"
    physical_cores: {cpu_info.get('physical_cores', 4)}
    total_memory_gb: {memory_info.get('total_gb', 8)}
    gpu_detected: {bool(gpu_info.get('detected_gpu'))}
"""
    
    # Crear directorio config si no existe
    Path("config").mkdir(exist_ok=True)
    
    with open("config/whisper_amd_auto.yaml", "w") as f:
        f.write(yaml_content)
    print("📄 Configuración guardada: config/whisper_amd_auto.yaml")

def main():
    """Función principal de detección"""
    print("🔧 DETECCIÓN DE HARDWARE AMD (Sin dependencias externas)")
    print("=" * 60)
    
    # Detectar componentes
    cpu_info = detect_cpu_info()
    memory_info = detect_memory_info()
    gpu_info = detect_gpu_info()
    
    # Generar optimizaciones
    optimizations = generate_optimizations(cpu_info, memory_info, gpu_info)
    
    # Guardar configuraciones
    save_config(cpu_info, memory_info, gpu_info, optimizations)
    
    # Mostrar resumen
    print("\n" + "=" * 60)
    print("📊 RESUMEN DEL SISTEMA AMD")
    print("=" * 60)
    
    print(f"🖥️  CPU: {cpu_info.get('model_name', 'No detectado')}")
    print(f"🏗️  Arquitectura: {cpu_info.get('architecture', 'Desconocida')}")
    print(f"🔢 Núcleos: {cpu_info.get('physical_cores', 'N/A')} físicos")
    print(f"💾 RAM: {memory_info.get('total_gb', 'N/A')} GB")
    print(f"🎮 GPU: {gpu_info.get('series', 'No detectada')}")
    
    print(f"\n⚡ CONFIGURACIÓN OPTIMIZADA:")
    whisper_opt = optimizations["whisper_cpp"]
    print(f"   📊 Modelo: {whisper_opt['model_size']}")
    print(f"   🧵 Threads: {whisper_opt['threads']}")
    print(f"   🎮 GPU: {'Habilitada' if whisper_opt['use_gpu'] else 'Deshabilitada'}")
    
    print(f"\n🎯 PRÓXIMOS PASOS:")
    print("1. Instalar whisper.cpp: bash install_whisper_amd.sh")
    print("2. Descargar modelos: whisper --model base --language es /dev/null")
    print("3. Probar transcripción: python benchmark_amd_whisper.py")

if __name__ == "__main__":
    main()

Opción 3: Script de instalación completa

#!/bin/bash
# setup_amd_environment.sh

echo "🔧 Configurando entorno completo para AMD"
echo "========================================"

# Instalar dependencias Python
echo "📦 Instalando dependencias Python..."
pip install psutil requests

# Instalar herramientas del sistema
echo "📦 Instalando herramientas del sistema..."

if command -v apt &> /dev/null; then
    sudo apt update
    sudo apt install -y lspci-utils mesa-utils espeak-ng
elif command -v pacman &> /dev/null; then
    sudo pacman -S --noconfirm pciutils mesa-utils espeak-ng
elif command -v dnf &> /dev/null; then
    sudo dnf install -y pciutils mesa-utils espeak-ng
fi

echo "✅ Entorno configurado"
echo "Ahora ejecuta: python detect_amd_hardware.py"

Recomendación

Opción más rápida: Usar la versión sin dependencias externas que funciona solo con comandos nativos de Linux.