SurriorTec

Etiqueta: GPU AMD

  • ComfyUI en CachyOS Linux con GPU AMD: cómo generar imágenes en local

    ComfyUI permite generar imágenes con I.A en tu propio PC usando un sistema visual por nodos. En CachyOS/Linux, con una GPU AMD compatible y suficiente VRAM, puede convertirse en una herramienta muy potente para crear fondos, conceptos visuales, recursos para miniaturas y pruebas reales de I.A local.

    Respuesta rápida SurriorTec: ComfyUI es una interfaz avanzada para generación de imágenes por I.A. No es tan simple como escribir un prompt y pulsar un botón, pero a cambio te da mucho más control: modelo, resolución, sampler, pasos, CFG, denoise, nodos, workflows y salida final. En CachyOS/Linux puede ser una pieza clave para montar un flujo de I.A local serio.

    La clave está en entender esto: ComfyUI no es solo “un generador de imágenes”. Es una herramienta modular. Cada parte del proceso se puede ver y conectar mediante nodos: cargar modelo, escribir prompt positivo, escribir prompt negativo, generar latente, aplicar sampler, decodificar imagen y guardar resultado.

    Para un creador de contenido, eso tiene mucho valor. Puedes crear fondos tecnológicos, conceptos visuales, estilos base para miniaturas, imágenes de apoyo para artículos y recursos propios sin depender siempre de herramientas online.

    Qué es ComfyUI

    ComfyUI es una interfaz de generación de imágenes basada en nodos. En vez de ocultarte todo el proceso, te muestra cómo fluye la generación de imagen paso a paso.

    Imagen local

    Qué puedes hacer con ComfyUI

    • Generar imágenes desde texto.
    • Usar modelos como SDXL, SDXL Turbo u otros checkpoints compatibles.
    • Crear fondos para miniaturas.
    • Diseñar conceptos visuales para artículos o vídeos.
    • Controlar resolución, sampler, pasos, seed y CFG.
    • Guardar workflows reutilizables.
    • Combinar nodos avanzados para procesos más complejos.

    ComfyUI no es lo mismo que Ollama

    Ollama sirve principalmente para modelos de texto. ComfyUI se centra en imagen y flujos visuales. Ambos forman parte de la I.A local, pero no hacen lo mismo.

    Herramienta Uso principal Ejemplo
    Ollama Texto local Chat, resúmenes, guiones, consultas
    Open WebUI Interfaz para modelos de texto Chat tipo web conectado a Ollama
    ComfyUI Imagen local Fondos, ilustraciones, miniaturas, workflows visuales

    Qué necesitas para ComfyUI en CachyOS/Linux

    Para montar ComfyUI en CachyOS/Linux con GPU AMD, necesitas una base técnica más seria que para un programa normal. No es imposible, pero conviene ir ordenado.

    • CachyOS o una distribución Linux moderna y actualizada.
    • Python y entorno virtual.
    • Git para clonar ComfyUI.
    • PyTorch compatible con ROCm si quieres acelerar con AMD.
    • Una GPU AMD compatible con ROCm o con soporte adecuado.
    • VRAM suficiente: 8GB puede servir para pruebas; 12GB o 16GB dan mucho más margen.
    • Espacio en disco para modelos, checkpoints y salidas.

    Realidad técnica: en NVIDIA suele ser más directo por CUDA. En AMD puede funcionar muy bien en CachyOS/Linux, pero la compatibilidad con ROCm, PyTorch y tu modelo concreto de GPU importa mucho.

    Paso 1: actualizar CachyOS

    Antes de instalar nada, actualiza el sistema:

    sudo pacman -Syu

    Reinicia si se actualizan kernel, Mesa, drivers o componentes importantes.

    Paso 2: instalar paquetes base

    Instala Git, Python, pip y herramientas necesarias:

    sudo pacman -S git python python-pip python-virtualenv

    En algunas instalaciones también puede venir bien tener herramientas de compilación:

    sudo pacman -S base-devel

    Paso 3: clonar ComfyUI

    Crea una carpeta de trabajo para I.A local y clona ComfyUI:

    mkdir -p ~/IA
cd ~/IA
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

    Paso 4: crear entorno virtual

    Trabajar con entorno virtual evita mezclar dependencias de Python con el sistema:

    python -m venv venv
source venv/bin/activate

    Si usas fish en vez de bash, activa el entorno así:

    source venv/bin/activate.fish

    Paso 5: instalar PyTorch para AMD/ROCm

    Este es el paso delicado. Para GPU AMD, necesitas instalar una versión de PyTorch compatible con ROCm. AMD y PyTorch recomiendan seleccionar Linux, pip, Python y ROCm en la matriz oficial para obtener el comando actualizado.

    No copies comandos antiguos a ciegas: la versión correcta de PyTorch ROCm cambia con el tiempo. Si algo falla, revisa la matriz oficial de PyTorch y la documentación de ROCm.

    Ejemplo orientativo de instalación con pip para ROCm:

    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.4

    Si en tu sistema usas una versión distinta de ROCm, cambia el índice por el que corresponda en la documentación oficial.

    Paso 6: instalar dependencias de ComfyUI

    Con el entorno virtual activado, instala los requisitos:

    pip install -r requirements.txt

    Este paso instala las librerías que ComfyUI necesita para funcionar.

    Paso 7: colocar un modelo en checkpoints

    ComfyUI necesita un modelo/checkpoint para generar imágenes. Los modelos suelen ir en esta carpeta:

    ~/IA/ComfyUI/models/checkpoints

    Desde terminal:

    mkdir -p ~/IA/ComfyUI/models/checkpoints

    Después copia ahí tu archivo de modelo, por ejemplo un archivo .safetensors.

    Consejo SurriorTec: para empezar, usa un modelo rápido y no te obsesiones con lo más pesado. Primero confirma que ComfyUI genera una imagen. Luego ya pruebas modelos mejores, LoRAs, ControlNet o workflows más complejos.

    Paso 8: arrancar ComfyUI

    Desde la carpeta de ComfyUI y con el entorno virtual activado:

    cd ~/IA/ComfyUI
source venv/bin/activate
python main.py

    Si usas fish:

    cd ~/IA/ComfyUI
source venv/bin/activate.fish
python main.py

    Luego abre en el navegador:

    http://127.0.0.1:8188

    Si ves la interfaz de ComfyUI, la parte básica ya está funcionando.

    Qué significa cada nodo básico

    Cuando abras ComfyUI, puede parecer raro al principio. La clave es entender los nodos principales.

    Nodo Qué hace
    Load Checkpoint Carga el modelo de imagen
    CLIP Text Encode Positive Prompt positivo: lo que quieres ver
    CLIP Text Encode Negative Prompt negativo: lo que quieres evitar
    Empty Latent Image Define tamaño/resolución inicial
    KSampler Genera la imagen usando modelo, prompts y parámetros
    VAE Decode Convierte el latente en imagen visible
    Save Image Guarda el resultado final

    Primer prompt de prueba

    Para comprobar que todo funciona, puedes usar un prompt simple:

    dark futuristic gaming PC setup, red and black lighting, high contrast, cinematic hardware photography, clean composition, sharp details

    Prompt negativo:

    blurry, low quality, distorted, bad anatomy, extra objects, text, watermark, logo, messy composition

    Para artículos y miniaturas, conviene evitar que el modelo genere texto dentro de la imagen. El texto final es mejor añadirlo después con editor gráfico.

    Ajustes iniciales recomendados

    Ajuste Valor inicial razonable
    Resolución 1024×576 o 1216×684 para formato 16:9
    Steps 4-8 en modelos turbo / 20-30 en modelos normales
    CFG 1-2 para turbo / 5-8 para modelos normales
    Sampler Euler, DPM++ o el recomendado por el workflow
    Seed Fijo si quieres repetir; aleatorio si quieres variar

    Ojo: SDXL Turbo y modelos turbo suelen usar pocos pasos y CFG bajo. Si usas parámetros de modelos normales, el resultado puede empeorar.

    ComfyUI para miniaturas y contenido

    Para un creador de contenido, ComfyUI puede servir especialmente para:

    • Fondos tecnológicos.
    • Escenas de hardware.
    • Conceptos visuales antes de diseñar una miniatura final.
    • Banners para artículos.
    • Imágenes base para web.
    • Mockups o estética general de un vídeo.
    • Explorar estilos visuales sin depender de bancos de imagen.

    Enfoque SurriorTec: ComfyUI no sustituye al criterio de miniatura. Te da materiales. La miniatura final necesita texto grande, claridad móvil, foco visual y promesa honesta.

    Problemas típicos

    Errores comunes

    Qué puede fallar

    • ComfyUI arranca pero no detecta el modelo.
    • El modelo no está en la carpeta correcta.
    • Faltan dependencias de Python.
    • PyTorch no detecta la GPU AMD.
    • ROCm no es compatible con tu GPU o versión concreta.
    • La generación crashea por falta de VRAM.
    • El workflow usa nodos que no tienes instalados.
    • Los parámetros no encajan con el modelo.

    Comandos útiles

    # Entrar a ComfyUI
cd ~/IA/ComfyUI

# Activar entorno virtual en bash
source venv/bin/activate

# Activar entorno virtual en fish
source venv/bin/activate.fish

# Arrancar ComfyUI
python main.py

# Actualizar ComfyUI
git pull

# Instalar dependencias de nuevo
pip install -r requirements.txt

# Ver si PyTorch detecta GPU ROCm
python -c "import torch; print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'Sin GPU')"

    ¿Cuánta VRAM necesitas?

    Depende del modelo, la resolución y el workflow. Para pruebas básicas, 8GB pueden servir con modelos y resoluciones moderadas. Para trabajar más cómodo con SDXL, 12GB o 16GB son mucho más interesantes.

    VRAM Experiencia esperable
    8GB Pruebas básicas, modelos ajustados, resoluciones moderadas
    12GB Más margen para SDXL y workflows razonables
    16GB Experiencia mucho más cómoda para I.A local creativa
    24GB o más Workflows más pesados, modelos grandes y más libertad

    Conclusión

    ComfyUI en CachyOS/Linux con GPU AMD puede ser una herramienta muy potente para generar imágenes en local, pero no conviene venderlo como algo mágico ni totalmente sencillo. Hay que montar bien Python, PyTorch, ROCm, modelos y workflows.

    Si lo consigues dejar funcionando, ganas una herramienta brutal para crear fondos, conceptos visuales y recursos propios. Para SurriorTec, eso encaja especialmente bien con miniaturas, artículos, guías, Linux, I.A local y creación de contenido.

    Veredicto SurriorTec: ComfyUI no es la opción más fácil, pero sí una de las más potentes si quieres control. En CachyOS/Linux con AMD puede tener mucho sentido si tienes VRAM suficiente y paciencia técnica.

    También puedes leer

    I.A Local en CachyOS y Linux

    Ollama y Open WebUI en CachyOS/Linux

    8GB vs 16GB de VRAM en 2026

    RX 9060 XT 16GB

    ¿Quieres ayuda para montarlo?

    Si quieres instalar ComfyUI, revisar si tu GPU AMD sirve o preparar un entorno de I.A local en CachyOS/Linux, puedes pedir asesoría SurriorTec.

    Ver servicios SurriorTec Contactar

    Transparencia: esta guía puede enlazar a contenido relacionado o componentes recomendados. La prioridad es explicar lo que funciona y lo que no, no vender humo.

    Última actualización: junio de 2026. ComfyUI, PyTorch y ROCm cambian con frecuencia. Revisa documentación oficial si algún comando no coincide con tu sistema.

  • Ollama y Open WebUI en CachyOS Linux: cómo montar tu propio ChatGPT local

    Ollama y Open WebUI permiten montar una especie de “ChatGPT local” en tu propio PC con CachyOS/Linux. No dependes siempre de la nube, puedes probar modelos abiertos y puedes aprovechar tu CPU o GPU para ejecutar I.A en casa.

    Respuesta rápida SurriorTec: Ollama es el motor que descarga y ejecuta modelos de lenguaje en local. Open WebUI es la interfaz web cómoda para hablar con esos modelos desde el navegador. En CachyOS/Linux, la combinación puede convertir tu PC en una estación de I.A local bastante seria.

    La idea es simple: en vez de abrir siempre una I.A online, instalas un servicio local que ejecuta modelos en tu propio equipo. Luego abres una interfaz tipo chat desde el navegador y empiezas a usar modelos como Qwen, Llama, Mistral u otros, dependiendo de tu hardware.

    No es magia. La I.A local tiene límites: consume RAM, VRAM, CPU, disco y a veces exige terminal. Pero si tienes un PC decente, especialmente con una GPU con bastante VRAM, se vuelve una herramienta muy potente para productividad, contenido, pruebas técnicas y privacidad.

    Qué es Ollama

    Ollama es una herramienta para descargar, gestionar y ejecutar modelos de lenguaje en local. Dicho de forma sencilla: es el motor que hace correr la I.A en tu PC.

    Con Ollama puedes instalar modelos y ejecutarlos desde terminal con comandos simples. Por ejemplo, puedes descargar un modelo y hablar con él sin montar una plataforma enorme ni depender de una API externa.

    Motor local

    Qué hace Ollama

    • Descarga modelos de lenguaje.
    • Los ejecuta en tu propio equipo.
    • Permite usar modelos desde terminal.
    • Expone un servicio local para que otras interfaces se conecten.
    • Puede aprovechar aceleración por hardware cuando el sistema lo permite.

    Qué es Open WebUI

    Open WebUI es una interfaz web para usar modelos de I.A con una experiencia más cómoda. En vez de hablar con la I.A desde terminal, entras desde el navegador y tienes una interfaz tipo chat.

    La gracia es que Open WebUI puede conectarse a Ollama. Ollama ejecuta los modelos y Open WebUI te da la parte visual.

    Interfaz web

    Qué aporta Open WebUI

    • Interfaz de chat desde navegador.
    • Gestión más cómoda de conversaciones.
    • Uso de varios modelos.
    • Experiencia parecida a un chat moderno.
    • Más cómodo para trabajar que usar solo terminal.

    Ollama vs Open WebUI: no son lo mismo

    Herramienta Función Ejemplo simple
    Ollama Ejecuta los modelos de I.A en local El motor
    Open WebUI Te da una interfaz web para hablar con los modelos La pantalla cómoda
    Modelo La I.A concreta que descargas y usas Qwen, Llama, Mistral…

    Qué necesitas antes de instalarlo

    En CachyOS/Linux, lo normal es necesitar:

    • Un sistema Linux actualizado, idealmente CachyOS si quieres seguir el enfoque SurriorTec.
    • Terminal.
    • Conexión a internet para descargar modelos.
    • Docker si quieres instalar Open WebUI de forma limpia.
    • Espacio en disco: los modelos pueden ocupar varios GB.
    • RAM suficiente: 16GB es un mínimo razonable; 32GB es más cómodo.
    • GPU opcional, pero recomendable si quieres más rendimiento.

    Importante: puedes usar I.A local sin GPU, pero será mucho más lenta. Para una experiencia seria, la GPU y la VRAM importan mucho.

    Paso 1: actualizar CachyOS

    Antes de instalar nada, actualiza el sistema. En CachyOS, puedes hacerlo con pacman:

    sudo pacman -Syu

    Reinicia si el sistema actualiza kernel, drivers o componentes importantes.

    Paso 2: instalar Ollama en CachyOS/Linux

    El método oficial de Ollama para Linux es ejecutar su script de instalación:

    curl -fsSL https://ollama.com/install.sh | sh

    Cuando termine, comprueba que Ollama existe:

    ollama --version

    Y revisa el servicio:

    systemctl status ollama

    Si no estuviera activo, puedes iniciarlo con:

    sudo systemctl start ollama

    Y dejarlo activado al iniciar:

    sudo systemctl enable ollama

    Paso 3: descargar tu primer modelo

    Para probar que todo funciona, instala un modelo razonable. Un buen punto de partida es un modelo 7B:

    ollama pull qwen2.5:7b

    Después puedes ejecutarlo así:

    ollama run qwen2.5:7b

    Si se abre un chat en terminal, Ollama está funcionando.

    Consejo SurriorTec: empieza con modelos moderados. No intentes cargar lo más pesado desde el minuto uno. Primero confirma que el sistema funciona, luego subes de nivel.

    Paso 4: instalar Docker para Open WebUI

    Open WebUI suele instalarse de forma cómoda con Docker. En CachyOS/Arch puedes instalar Docker así:

    sudo pacman -S docker

    Activa Docker:

    sudo systemctl enable --now docker

    Comprueba que funciona:

    docker --version

    Si quieres usar Docker sin escribir sudo cada vez, puedes añadir tu usuario al grupo docker:

    sudo usermod -aG docker $USER

    Después de ese comando, cierra sesión y vuelve a entrar, o reinicia.

    Nota: añadir tu usuario al grupo docker da permisos importantes. Si prefieres máxima seguridad, usa Docker con sudo.

    Paso 5: instalar Open WebUI conectado a Ollama

    Si Ollama ya está instalado en tu sistema como servicio, una forma práctica de lanzar Open WebUI es usar Docker con red host:

    docker run -d \
  --network=host \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

    Cuando termine, abre el navegador y entra en:

    http://localhost:8080

    La primera vez tendrás que crear el usuario administrador de Open WebUI. Después, la interfaz debería detectar Ollama si el servicio está funcionando correctamente.

    Paso 6: comprobar que Ollama y Open WebUI se ven

    Comprueba que Ollama responde:

    curl http://localhost:11434/api/tags

    Si devuelve información de modelos, Ollama está accesible.

    Comprueba el contenedor de Open WebUI:

    docker ps

    Deberías ver un contenedor llamado open-webui.

    Modelos recomendados para empezar

    Modelo Uso recomendado Comentario
    qwen2.5:7b Uso rápido y ligero Buen punto de partida para probar
    qwen3:14b Trabajo más serio Más pesado, requiere más memoria
    llama3.1:8b Modelo general Buena opción para pruebas variadas
    mistral Consultas generales Ligero y práctico

    Realidad: los modelos cambian con el tiempo. Lo importante no es memorizar una lista, sino entender qué tamaño puede mover tu equipo con fluidez.

    ¿GPU AMD, NVIDIA o CPU?

    La experiencia depende mucho del hardware. NVIDIA suele tener ventaja en I.A por CUDA. AMD puede funcionar muy bien en CachyOS/Linux si el soporte acompaña, especialmente con buena VRAM. CPU funciona, pero suele ser bastante más lento.

    Hardware Ventaja Límite
    CPU No necesitas GPU dedicada Más lento en modelos grandes
    GPU NVIDIA CUDA y ecosistema maduro Precio y VRAM según modelo
    GPU AMD Buena opción en CachyOS/Linux con VRAM suficiente Más dependencia de compatibilidad

    I.A local con AMD en CachyOS/Linux: lo importante

    En un sistema como CachyOS, una GPU AMD moderna con buena VRAM puede ser muy interesante para experimentar con I.A local. La clave está en no venderlo como magia: puede funcionar, pero a veces exige ajustar paquetes, drivers, backend, Vulkan, ROCm o herramientas concretas.

    Para texto local con Ollama, algunas configuraciones pueden usar aceleración por GPU. Para imagen local con herramientas como ComfyUI, normalmente entran en juego ROCm, PyTorch y compatibilidad concreta de la GPU.

    Enfoque SurriorTec: no necesitas creerte el cuento de “solo NVIDIA sirve para I.A”. Pero tampoco hay que negar la realidad: NVIDIA suele ser más fácil. AMD en CachyOS/Linux puede ser una alternativa real, especialmente si ya tienes una GPU con 16GB de VRAM y ganas de trastear.

    Problemas típicos

    Errores comunes

    Qué puede fallar

    • Ollama no arranca como servicio.
    • Open WebUI no detecta Ollama.
    • Docker no tiene permisos.
    • El puerto 8080 está ocupado.
    • El modelo es demasiado pesado para tu RAM o VRAM.
    • La GPU no acelera como esperabas.
    • Confundir instalación de texto con instalación de imagen.

    Comandos útiles

    # Ver modelos instalados
ollama list

# Ver modelos cargados
ollama ps

# Descargar un modelo
ollama pull qwen2.5:7b

# Ejecutar un modelo
ollama run qwen2.5:7b

# Ver estado de Ollama
systemctl status ollama

# Ver logs de Ollama
journalctl -u ollama -e

# Ver contenedores Docker
docker ps

# Ver logs de Open WebUI
docker logs open-webui

    Cuándo merece la pena montar esto

    Ollama + Open WebUI merece la pena si quieres aprender I.A local, probar modelos sin depender siempre de servicios externos, preparar contenido, hacer resúmenes, trabajar con textos, programar, experimentar con privacidad o crear un flujo de trabajo propio.

    No merece la pena si esperas que todo funcione igual de fácil que una web comercial desde el primer minuto. Aquí hay más control, pero también más responsabilidad técnica.

    Conclusión

    Montar Ollama y Open WebUI en CachyOS/Linux es una de las formas más directas de empezar con I.A local. Ollama ejecuta los modelos. Open WebUI te da la interfaz. Tu hardware marca los límites.

    Si tienes un PC moderno, suficiente RAM y una GPU con buena VRAM, esto deja de ser una curiosidad y empieza a ser una herramienta real para trabajar, crear contenido y experimentar.

    Veredicto SurriorTec: I.A local no sustituye a todo lo online, pero te da control, privacidad, aprendizaje y una base brutal para creadores y usuarios avanzados. En CachyOS/Linux, tiene mucho sentido si sabes lo que estás montando.

    También puedes leer

    I.A Local en CachyOS y Linux

    RX 9060 XT 16GB: por qué tiene más sentido del que parece

    8GB vs 16GB de VRAM en 2026

    ¿Quieres ayuda para montarlo?

    Si quieres instalar I.A local en tu PC con CachyOS/Linux, revisar si tu hardware sirve o preparar un entorno con Ollama, Open WebUI o ComfyUI, puedes pedir asesoría SurriorTec.

    Ver servicios SurriorTec Contactar

    Transparencia: esta guía puede enlazar a contenido relacionado o componentes recomendados. La prioridad es explicar lo que funciona y lo que no, no vender humo.

    Última actualización: junio de 2026. Los comandos y herramientas pueden cambiar. Revisa siempre la documentación oficial si algo no coincide con tu sistema.