LeaderGPU® | Soluciones de GPU para computación de alto rendimiento

Qwen3-Coder: un paradigma roto

Tue, 12 Aug 2025 14:11:06 +0200

Estamos acostumbrados a pensar que los modelos de código abierto siempre están por detrás de sus homólogos comerciales en cuanto a calidad. Puede parecer que están desarrollados exclusivamente por entusiastas que no pueden permitirse invertir grandes sumas en crear conjuntos de datos de alta calidad y entrenar modelos en decenas de miles de GPU modernas.

La cosa cambia cuando grandes corporaciones como OpenAI, Anthropic o Meta asumen la tarea. No sólo disponen de los recursos necesarios, sino también de los mejores especialistas en redes neuronales del mundo. Por desgracia, los modelos que crean, especialmente las últimas versiones, son de código cerrado. Los desarrolladores lo explican alegando los riesgos de un uso incontrolado y la necesidad de garantizar la seguridad de la IA.

Por un lado, su razonamiento es comprensible: muchas cuestiones éticas siguen sin resolverse y la propia naturaleza de los modelos de redes neuronales sólo permite influir indirectamente en el resultado final. Por otro lado, mantener los modelos cerrados y ofrecer acceso sólo a través de su propia API es también un modelo de negocio sólido.

Sin embargo, no todas las empresas se comportan así. Por ejemplo, la empresa francesa Mistral AI ofrece modelos comerciales y de código abierto, lo que permite a investigadores y aficionados utilizarlos en sus proyectos. Pero hay que prestar especial atención a los logros de las empresas chinas, la mayoría de las cuales construyen modelos de peso y código abiertos capaces de competir seriamente con las soluciones propietarias.

DeepSeek, Qwen3 y Kimi K2

El primer gran avance llegó con DeepSeek-V3. Este modelo lingüístico multimodal de DeepSeek AI se desarrolló utilizando el enfoque de Mezcla de Expertos (MoE) y unos impresionantes 671B parámetros, con 37B de los más relevantes activados para cada token. Y lo que es más importante, todos sus componentes (pesos del modelo, código de inferencia y conductos de formación) se han hecho públicos.

Esto lo convirtió instantáneamente en uno de los LLM más atractivos para desarrolladores de aplicaciones de IA e investigadores por igual. El siguiente titular fue DeepSeek-R1, el primer modelo de razonamiento de código abierto. El día de su lanzamiento, hizo temblar el mercado bursátil estadounidense después de que sus desarrolladores afirmaran que entrenar un modelo tan avanzado sólo había costado 6 millones de dólares.

Aunque el revuelo en torno a DeepSeek acabó por enfriarse, los siguientes lanzamientos no fueron menos importantes para la industria mundial de la IA. Hablamos, por supuesto, de Qwen 3. En nuestro análisis de Novedades de Qwen 3 tratamos en detalle sus características, por lo que no nos detendremos en él. Poco después apareció otro jugador: Kimi K2, de Moonshot AI.

Con su arquitectura MoE, parámetros 1T (32B activados por token) y código abierto, Kimi K2 atrajo rápidamente la atención de la comunidad. En lugar de centrarse en el razonamiento, Moonshot AI buscaba un rendimiento puntero en matemáticas, programación y conocimientos transversales profundos.

El as en la manga de Kimi K2 era su optimización para la integración en agentes de IA. Esta red se diseñó literalmente para aprovechar al máximo todas las herramientas disponibles. Sobresale en tareas que requieren no sólo escribir código, sino también pruebas iterativas en cada fase de desarrollo. Sin embargo, también tiene puntos débiles, que discutiremos más adelante.

Kimi K2 es un modelo de lenguaje grande en todos los sentidos. Ejecutar la versión completa requiere ~2 TB de VRAM (FP8: ~1 TB). Por razones obvias, esto no es algo que puedas hacer en casa, e incluso muchos servidores de GPU no lo soportarán. El modelo necesita al menos 8 aceleradores NVIDIA® H200. Las versiones cuantificadas pueden ayudar, pero con un coste notable para la precisión.

Codificador Qwen3

Viendo el éxito de Moonshot AI, Alibaba desarrolló su propio modelo similar a Kimi K2, pero con importantes ventajas que comentaremos en breve. Inicialmente, se lanzó en dos versiones:

Qwen3-Coder-480B-A35B-Instruct (~250 GB VRAM)
Qwen3-Coder-480B-A35B-Instruct-FP8 (~120 GB de VRAM)

Pocos días después, aparecieron modelos más pequeños sin el mecanismo de razonamiento, que requerían mucha menos VRAM:

Qwen3-Coder-30B-A3B-Instruct (~32 GB VRAM)
Qwen3-Coder-30B-A3B-Instruct-FP8 (~18 GB VRAM)

Qwen3-Coder fue diseñado para su integración con herramientas de desarrollo. Incluye un analizador especial para llamadas a funciones (qwen3coder_tool_parser.py, análogo a la llamada a funciones de OpenAI). Junto con el modelo, se ha lanzado una utilidad de consola, capaz de realizar desde la compilación de código hasta la consulta de una base de conocimientos. Esta idea no es nueva, esencialmente es una extensión muy reelaborada de la aplicación de código Gemini de Anthropic.

El modelo es compatible con la API OpenAI, lo que permite desplegarlo localmente o en un servidor remoto y conectarlo a la mayoría de los sistemas que admiten esta API. Esto incluye tanto aplicaciones cliente ya creadas como bibliotecas de aprendizaje automático. Esto lo hace viable no sólo para el segmento B2C, sino también para el B2B, ofreciendo un reemplazo drop-in sin fisuras para el producto de OpenAI sin ningún cambio en la lógica de la aplicación.

Una de sus características más demandadas es la longitud de contexto ampliada. Por defecto, admite 256k tokens, pero puede aumentarse hasta 1M utilizando el mecanismo YaRN (Yet another RoPe extensioN). Los LLM modernos se entrenan normalmente con conjuntos de datos cortos (2.000-8.000 tokens), y una longitud de contexto grande puede hacer que pierdan de vista el contenido anterior.

YaRN es un elegante "truco" que hace creer al modelo que está trabajando con sus secuencias cortas habituales, mientras que en realidad procesa secuencias mucho más largas. La idea clave es "estirar" o "dilatar" el espacio posicional conservando la estructura matemática que espera el modelo. Esto permite procesar eficazmente secuencias de decenas de miles de tokens sin el reentrenamiento o la memoria adicional que exigen los métodos tradicionales de ampliación del contexto.

Descarga y ejecución de Inference

Asegúrate de haber instalado CUDA® de antemano, ya sea utilizando las instrucciones oficiales de NVIDIA® o la guía Instalar el kit de herramientas CUDA® en Linux. Para comprobar el compilador necesario:

nvcc --version

Salida esperada:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Tue_Feb_27_16:19:38_PST_2024
Cuda compilation tools, release 12.4, V12.4.99
Build cuda_12.4.r12.4/compiler.33961263_0

Si obtiene:

Command 'nvcc' not found, but can be installed with:
sudo apt install nvidia-cuda-toolkit

necesitas añadir los binarios CUDA® al $PATH de tu sistema.

export PATH=/usr/local/cuda-12.4/bin:$PATH

export LD_LIBRARY_PATH=/usr/local/cuda-12.4/lib64:$LD_LIBRARY_PATH

Esta es una solución temporal. Para una solución permanente, edite ~/.bashrc y añada las mismas dos líneas al final.

Ahora, prepara tu sistema para gestionar entornos virtuales. Puedes usar el venv incorporado en Python o el más avanzado Miniforge. Asumiendo que Miniforge está instalado:

conda create -n venv python=3.10

conda activate venv

Instala PyTorch con soporte CUDA® compatible con tu sistema:

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

A continuación, instale las bibliotecas esenciales:

Transformers - La biblioteca de modelos principal de Hugging Face
Accelerate - permite la inferencia multi-GPU
HuggingFace Hub - para descargar/cargar modelos y conjuntos de datos
Safetensors - formato seguro del peso del modelo
vLLM - biblioteca de inferencia recomendada para Qwen

pip install transformers accelerate huggingface_hub safetensors vllm

Descargar el modelo:

hf download Qwen/Qwen3-Coder-30B-A3B-Instruct --local-dir ./Qwen3-30B

Ejecutar la inferencia con paralelismo tensorial (repartiendo los tensores de capa entre las GPUs, por ejemplo 8):

python -m vllm.entrypoints.openai.api_server \
--model /home/usergpu/Qwen3-30B \
--tensor-parallel-size 8 \
--gpu-memory-utilization 0.9 \
--dtype auto \
--host 0.0.0.0 \
--port 8000

Esto inicia el servidor API OpenAI de vLLM.

Pruebas e integración

cURL

Instale jq para la impresión bonita de JSON:

sudo apt -y install jq

Probar el servidor:

curl -s http://127.0.0.1:8000/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "/home/usergpu/Qwen3-30B",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello! What can you do?"}
  ],
  "max_tokens": 180
}' | jq -r '.choices[0].message.content'

VSCode

Para integrarse con Visual Studio Code, instale la extensión Continue y añádala a config.yaml:

- name: Qwen3-Coder 30B
  provider: openai
  apiBase: http://[server_IP_address]:8000/v1
  apiKey: none
  model: /home/usergpu/Qwen3-30B
  roles:
    - chat
    - edit
    - apply

Qwen-Agente

Para una configuración basada en GUI con Qwen-Agent (incluyendo RAG, MCP e intérprete de código):

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"

Abre el editor nano:

nano script.py

Ejemplo de script Python para lanzar Qwen-Agent con Gradio WebUI:

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

llm_cfg = {
    'model': '/home/usergpu/Qwen3-30B',
    'model_server': 'http://localhost:8000/v1',
    'api_key': 'EMPTY',
    'generate_cfg': {'top_p': 0.8},
}

tools = ['code_interpreter']

bot = Assistant(
    llm=llm_cfg,
    system_message="You are a helpful coding assistant.",
    function_list=tools
)

WebUI(bot).run()

Ejecute el script:

python script.py

El servidor estará disponible en: http://127.0.0.1:7860

También puedes integrar Qwen3-Coder en frameworks de agentes como CrewAI para automatizar tareas complejas con conjuntos de herramientas como la búsqueda web o la memoria de bases de datos vectoriales.

Véase también:

Cómo instalar CrewAI con GUI

Wed, 23 Jul 2025 15:05:43 +0200

Las capacidades de los modelos de redes neuronales crecen día a día. Los investigadores y las empresas comerciales invierten cada vez más en entrenarlos. Pero por sí solos, estos modelos no pueden actuar de forma autónoma. Para resolver tareas específicas, necesitan orientación: ampliación del contexto y establecimiento de direcciones. Este enfoque no siempre es eficaz, sobre todo cuando se trata de problemas complejos.

Pero, ¿y si permitiéramos a una red neuronal actuar de forma autónoma? ¿Y si le proporcionáramos muchas herramientas para interactuar con el mundo exterior? Obtendríamos un agente de IA capaz de resolver tareas determinando de forma independiente qué herramientas utilizar. Suena complicado, pero funciona muy bien. Sin embargo, incluso para un usuario avanzado, crear un agente de IA desde cero puede ser una tarea nada trivial.

La razón es que la mayoría de las bibliotecas populares carecen de interfaz gráfica de usuario. Requieren interacción a través de un lenguaje de programación como Python. Esto eleva drásticamente el umbral de entrada y hace que los agentes de IA sean demasiado complejos para su implementación independiente. Este es exactamente el caso de CrewAI.

Qué es CrewAI

CrewAI es una librería muy popular y práctica, pero no viene con una interfaz gráfica por defecto. Esto llevó a desarrolladores independientes a crear una interfaz no oficial. La naturaleza de código abierto de CrewAI hizo la tarea mucho más fácil, y pronto la comunidad lanzó el proyecto CrewAI Studio.

Los desarrolladores y entusiastas conocieron mejor la arquitectura del sistema y pudieron crear herramientas adaptadas a tareas específicas. Los usuarios normales podían crear agentes de IA sin escribir una sola línea de código. Se hizo más fácil asignar tareas y gestionar el acceso a redes neuronales y herramientas. También permitió exportar e importar agentes de un servidor a otro y compartirlos con amigos, colegas o la comunidad de código abierto.

Otra ventaja de CrewAI Studio es su flexibilidad de despliegue. Puede instalarse como una aplicación normal o como un contenedor Docker, el método preferido, ya que incluye todas las bibliotecas y componentes necesarios para ejecutar el sistema.

Instalación

Actualiza los paquetes de tu sistema operativo y las aplicaciones instaladas a las últimas versiones:

sudo apt update && sudo apt -y upgrade

Utiliza el script de instalación automática de controladores o sigue nuestra guía Instalar controladores NVIDIA® en Linux:

sudo ubuntu-drivers autoinstall

Reinicia el servidor para que los cambios surtan efecto:

sudo shutdown - r now

Tras volver a conectarte por SSH, instala las utilidades del servidor web Apache 2, que te darán acceso al generador de archivos .htpasswd utilizado para la autenticación básica de usuarios:

sudo apt install -y apache2-utils

Instala Docker Engine usando el script shell oficial:

curl -sSL https://get.docker.com/ | sh

Añade Docker Compose al sistema:

sudo apt install -y docker-compose

Clonar el repositorio:

git clone https://github.com/strnad/CrewAI-Studio.git

Navegue hasta el directorio descargado:

cd CrewAI-Studio

Cree un archivo .htpasswd para el usuario usergpu. Se le pedirá que introduzca una contraseña dos veces:

htpasswd -c .htpasswd usergpu

Ahora edita el archivo de despliegue del contenedor. Por defecto, hay dos contenedores:

sudo nano docker-compose.yaml

Borra la sección:

ports:
  - "5432:5432"

Y añada el siguiente servicio:


nginx:
  image: nginx:latest
  container_name: crewai_nginx
  ports:
    - "80:80"
  volumes:
    - ./nginx.conf:/etc/nginx/nginx.conf:ro
    - ./.htpasswd:/etc/nginx/.htpasswd:ro
  depends_on:
    - web

Nginx necesitará un archivo de configuración, así que crea uno:

sudo nano nginx.conf

Pega lo siguiente:

events {}

http {
  server {
    listen 80;

    location / {
      proxy_pass http://web:8501;

      # WebSocket headers
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection "upgrade";

      # Forward headers
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;

      auth_basic "Restricted Content";
      auth_basic_user_file /etc/nginx/.htpasswd;
    }
  }
}

Todas las variables de servicio importantes para CrewAI están definidas en el archivo .env. Abra el archivo .env_example para editarlo:

nano .env_example

Añade las siguientes líneas:

OLLAMA_HOST="http://open-webui:11434"
OLLAMA_MODELS="ollama/llama3.2:latest"

Y añade Postgres config:

POSTGRES_USER="admin"
POSTGRES_PASSWORD="your_password"
POSTGRES_DB="crewai_db"
AGENTOPS_ENABLED="False"

Ahora copia el archivo de ejemplo y renómbralo a .env para que el sistema pueda leerlo durante el despliegue del contenedor:

cp .env_example .env

En este ejemplo, usaremos modelos locales con inferencia manejada por Ollama. Recomendamos nuestra guía Open WebUI: Todo en uno, y durante el despliegue añadir -e OLLAMA_HOST=0.0.0.0 para permitir a CrewAI conectarse directamente al contenedor Ollama. Descargue el modelo deseado (por ejemplo, llama3.2:latest) a través de WebUI o conectándose a la consola del contenedor y ejecutando:

ollama pull llama3.2:latest

Una vez que todo esté configurado, inicie el despliegue:

sudo docker-compose up -d --build

Ahora, visitando http://[your_server_ip]/ se le pedirán las credenciales de acceso. Una vez introducidas correctamente, aparecerá la interfaz CrewAI.

Características

Exploremos las entidades clave que utiliza CrewAI. Esto le ayudará a entender cómo configurar los flujos de trabajo. La entidad central en el Agent, un ejecutor de tareas autónomo. Cada agente tiene atributos que le ayudan a cumplir sus tareas:

Role. Una breve descripción del trabajo, de 2-3 palabras.
Backstory. Opcional; ayuda al modelo lingüístico a entender cómo debe comportarse el agente y en qué experiencias debe basarse.
Goal. El objetivo que debe perseguir el agente.
Allow delegation. Permite al agente delegar tareas (o parte de ellas) en otros.
Verbose. Indica al agente que registre acciones detalladas.
LLM Provider and Model. Especifica el modelo y el proveedor a utilizar.
Temperature. Determina la creatividad de la respuesta. Mayor = más creativo.
Max iterations. Número de intentos que tiene el agente para tener éxito, actuando como salvaguarda (por ejemplo, contra bucles infinitos).

Los agentes actúan analizando de forma iterativa las entradas, razonando y extrayendo conclusiones utilizando las herramientas disponibles.

La entrada se define mediante una entidad Task. Cada tarea incluye una descripción, un agente asignado y, opcionalmente, un resultado esperado. Por defecto, las tareas se ejecutan de forma secuencial, pero pueden paralelizarse utilizando la bandera Async execution.

El trabajo de los agentes autónomos se apoya en Tools, que permite la interacción con el mundo real. CrewAI incluye herramientas para búsquedas web, análisis sintáctico de sitios, llamadas a API y manejo de archivos, lo que mejora el contexto y ayuda a los agentes a alcanzar sus objetivos.

Por último, está Crew entity. Une agentes con diferentes funciones en un equipo para abordar problemas complejos. Pueden comunicarse, delegar, revisar y corregirse unos a otros, formando esencialmente una inteligencia colectiva.

Utilizando

Ahora que estás familiarizado con las entidades, vamos a construir y ejecutar un flujo de trabajo CrewAI mínimo. En este ejemplo, seguiremos el progreso global en el desarrollo de fármacos contra el cáncer.

Utilizaremos tres agentes:

Oncology Drug Pipeline Analyst - sigue los nuevos desarrollos desde las primeras fases hasta los ensayos clínicos.
Regulatory and Approval Watchdog - monitoriza las aprobaciones de nuevos fármacos y los cambios normativos.
Scientific Literature and Innovation Scout - explora publicaciones científicas y patentes relacionadas con la oncología.

Abra la sección Agentes y cree el primer agente:

Por ahora, estamos utilizando el modelo llama3.2:latest previamente descargado, pero en un escenario real, elija el que mejor se adapte a la tarea. Repite el proceso para el resto de agentes y pasa a la creación de tareas.

Reúna a todos los agentes en una cuadrilla y asígneles la tarea preparada:

Active las herramientas necesarias de la lista:

Por último, vaya a la página Kickoff! y haga clic en Run Crew! Después de algunas iteraciones, el sistema devolverá un resultado, como por ejemplo:

Antes de terminar, revisemos la sección Import/export. Su flujo de trabajo o tripulación puede ser exportado como JSON para transferirlo a otro servidor CrewAI. También puede crear una aplicación de una sola página (SPA) con un solo clic - perfecto para el despliegue de producción:

Conclusión

CrewAI simplifica significativamente la creación de agentes de IA, permitiendo su integración en cualquier aplicación o su uso independiente. La librería se basa en la idea de inteligencia distribuida, donde cada agente es un experto de dominio, y el equipo combinado supera a un único agente generalista.

Al estar escrita en Python, CrewAI se integra fácilmente con plataformas y herramientas de ML. Su naturaleza de código abierto permite la ampliación mediante módulos de terceros. La comunicación entre agentes reduce el uso de tokens al distribuir el procesamiento del contexto.

Como resultado, las tareas complejas se completan de forma más rápida y eficiente. La menor barrera de entrada que ofrece CrewAI Studio amplía el alcance de los agentes de IA y los sistemas multiagente. Y la compatibilidad con modelos locales garantiza un mejor control de los datos confidenciales.

Véase también:

Novedades de Qwen 3

Mon, 14 Jul 2025 08:05:08 +0200

La carrera mundial de la IA se acelera. Instituciones de investigación, empresas privadas e incluso naciones enteras compiten ahora por el liderazgo en el ámbito de la IA. A grandes rasgos, esta carrera puede dividirse en varias fases. La primera fase consistió en la creación de IA restringida. Los modelos de redes neuronales existentes, como GPT, MidJourney y AlphaFold, demuestran que esta etapa se ha superado con éxito.

La siguiente etapa prevé la evolución de la IA hacia la AGI (Inteligencia Artificial General). La AGI debería igualar a la inteligencia humana en la resolución de una amplia gama de tareas, desde escribir historias y realizar cálculos científicos hasta comprender situaciones sociales y aprender de forma autónoma. En el momento de escribir estas líneas, aún no se ha alcanzado este nivel.

La última etapa en el desarrollo de la IA se denomina ASI (Superinteligencia Artificial). Superaría con creces las capacidades humanas en todos los ámbitos. Esto permitiría desarrollar tecnologías que hoy ni siquiera podemos imaginar y gestionar sistemas globales con una precisión superior a las capacidades humanas. Sin embargo, esto sólo podría hacerse realidad tras décadas (o incluso siglos) de avances continuos.

Por ello, la mayoría de los participantes en la carrera de la IA se centran en alcanzar la AGI manteniendo el control sobre ella. El desarrollo de la inteligencia artificial está estrechamente ligado a una serie de complejos retos técnicos, éticos y legales. Aun así, las recompensas potenciales superan con creces los costes, razón por la que empresas como Alibaba Group están invirtiendo fuertemente en este campo.

El lanzamiento de Qwen 3 marca un hito importante no sólo para las redes neuronales de una empresa, sino también en la escena mundial. En comparación con su predecesor, el modelo introduce varias innovaciones importantes.

Características

Qwen 2.5 se preentrenó en un conjunto de datos de 18.000 millones de tokens, mientras que el nuevo modelo ha duplicado esa cantidad hasta 36.000 millones de tokens. El mayor conjunto de datos ha mejorado significativamente la precisión del modelo base. Curiosamente, además de los datos de Internet disponibles públicamente recogidos mediante análisis sintáctico, el sistema también se entrenó con documentos PDF. Estos documentos suelen estar bien estructurados y ser densos en conocimientos, lo que ayuda al modelo a dar respuestas más precisas y a comprender mejor las formulaciones complejas.

Una de las direcciones más prometedoras en el desarrollo de la IA es la construcción de modelos capaces de razonar, que pueden ampliar el contexto de la tarea mediante un proceso iterativo. Por un lado, esto permite resolver problemas de forma más exhaustiva, pero por otro, el razonamiento tiende a ralentizar considerablemente el proceso. Por ello, los desarrolladores de Qwen 3 han introducido dos modos operativos:

Thinking mode. El modelo construye el contexto paso a paso antes de ofrecer una respuesta final. Esto permite abordar problemas complejos que requieren una comprensión profunda.
Non-thinking mode. El modelo responde casi instantáneamente, pero puede producir respuestas más superficiales sin un análisis en profundidad.

Este control manual sobre el comportamiento del modelo mejora la experiencia del usuario en el manejo de muchas tareas rutinarias. Reducir el uso del modo de pensamiento también disminuye significativamente la carga de la GPU, lo que permite procesar más tokens en el mismo periodo de tiempo.

Además de esta elección binaria, también existe un mecanismo de cambio suave. Este comportamiento híbrido permite al modelo adaptarse al contexto utilizando mecanismos internos de ponderación. Si el modelo considera que una tarea es difícil, activará automáticamente el razonamiento o incluso la autoverificación. También puede responder a indicaciones del usuario como "Pensemos paso a paso".

Otra mejora significativa es la ampliación del soporte multilingüe. Mientras que Qwen 2.5 sólo admitía 29 idiomas, la versión 3 puede ahora entender y generar texto en 119 idiomas y dialectos. Esto ha mejorado enormemente el seguimiento de instrucciones y la comprensión contextual. Como resultado, Qwen 3 puede utilizarse ahora eficazmente en entornos no anglosajones.

Además, Qwen 3 está ahora significativamente mejor integrado con los servidores MCP, lo que proporciona al modelo herramientas para profundizar en la resolución de problemas y ejecutar acciones. Ahora puede interactuar con fuentes externas y gestionar directamente procesos complejos.

Formación del modelo

Formación previa

Un avance tan sustancial no habría sido posible sin un sistema de formación en varias fases. Inicialmente, el modelo se preentrenó con 30B tokens con una longitud de contexto de 4K, lo que le permitió adquirir conocimientos generales y habilidades lingüísticas básicas.

A continuación se perfeccionó con datos más científicos y estructurados. Durante esta etapa, el modelo también adquirió la capacidad de escribir eficazmente aplicaciones en múltiples lenguajes de programación.

Por último, se entrenó en un conjunto de datos de alta calidad con contexto ampliado. Como resultado, Qwen 3 admite ahora una longitud de contexto efectiva de 128.000 tokens, lo que equivale aproximadamente a 350 páginas de texto mecanografiado, dependiendo del idioma. Por ejemplo, los idiomas cirílicos suelen tener tokens más cortos debido a la morfología y al uso de prefijos, sufijos, etc.

Proceso de razonamiento

Construir modelos capaces de razonar es un proceso fascinante pero laborioso que combina varias técnicas existentes destinadas a simular el pensamiento humano. Basándonos en la información pública disponible, podemos suponer que el entrenamiento del razonamiento de Qwen 3 implicó cuatro etapas principales:

Cold start for long chains of thought. Entrenamiento del modelo para dividir los problemas en múltiples pasos sin adaptación previa. Esto le ayuda a aprender el pensamiento iterativo y a desarrollar una capa básica de habilidades de razonamiento.
Reinforcement learning based on reasoning. En esta etapa, las recompensas dependen no sólo de la respuesta final, sino también de lo bien que el modelo construya cadenas de razonamiento lógicas, interpretables y estructuradas. También se evalúa la ausencia de errores y alucinaciones.
Merging reasoning modes. Los seres humanos suelen basarse en dos estilos de pensamiento: rápido (intuitivo) y lento (analítico). En función del tipo de tarea, el modelo neuronal debe aprender tanto a alternar entre estos estilos como a integrarlos. Para ello se suelen utilizar ejemplos que mezclan ambos estilos o fichas especiales que indican qué estilo aplicar.
General reinforcement learning. Esta etapa final se asemeja a un entorno de caja de arena en el que el modelo aprende a interactuar con herramientas, realizar tareas de varios pasos y desarrollar un comportamiento adaptativo. Aquí también se adapta a las preferencias del usuario.

Conclusión

Qwen 3 es un hito importante para Alibaba Group. La calidad de su formación y su metodología lo convierten en un serio competidor frente a empresas consolidadas como OpenAI y Anthropic. Las mejoras con respecto a la versión anterior son sustanciales.

Una ventaja añadida es su naturaleza de código abierto, con la base de código disponible públicamente en GitHub bajo la licencia Apache 2.0.

Un mayor desarrollo de la familia de modelos Qwen contribuirá a reforzar su posición en el panorama mundial de la IA y a reducir la brecha con los modelos comerciales de código cerrado. Y todos los logros actuales son, de un modo u otro, pasos hacia el progreso de la humanidad en la construcción de AGI.

Ver también:

Servidor MCP basado en N8N

Wed, 02 Jul 2025 15:28:18 +0200

El desarrollo de las redes neuronales generativas se ha acelerado considerablemente en los últimos años. Se han vuelto notablemente más rápidas y precisas en sus respuestas y han aprendido a razonar. Sin embargo, sus capacidades siguen estando fundamentalmente limitadas por su arquitectura. Por ejemplo, todas las LLM existentes en el momento de escribir estas líneas tienen una fecha límite de conocimiento. Esto significa que, cada día que pasa, es más probable que un LLM de este tipo produzca respuestas incorrectas, simplemente porque carece de información sobre hechos ocurridos después de esa fecha.

Esta limitación obliga a reentrenar el modelo por completo con datos más recientes, lo que resulta caro y lleva mucho tiempo. Pero hay otra manera. Si se permite al modelo interactuar con el mundo exterior, puede encontrar y actualizar de forma independiente la información solicitada durante una conversación con el usuario, sin necesidad de volver a entrenarlo.

Así funciona, a grandes rasgos, el mecanismo RAG (Retrieval Augmented Generation). Al responder a una pregunta, el modelo consulta primero una base de datos vectorial preparada de antemano y, si encuentra información pertinente, la incorpora a la pregunta. Así, explicando y actualizando la BD vectorial, la calidad de las respuestas LLM puede mejorar mucho.

Pero hay otra forma aún más interesante de incorporar un contexto actualizado a las instrucciones. Se llama MCP, que significa Protocolo de Contexto de Modelo. Fue desarrollado originalmente por Anthropic para su modelo Claude. El momento clave llegó cuando el código fuente de MCP se hizo de código abierto, lo que permitió a miles de investigadores de IA construir servidores personalizados para diversos fines.

La esencia de MCP es dar a un modelo de red neuronal acceso a herramientas con las que pueda actualizar de forma independiente sus conocimientos y realizar diversas acciones para resolver eficazmente tareas dadas. El propio modelo decide qué herramienta utilizar y si es adecuada en cada situación.

El soporte para MCP no tardó en aparecer en varios IDE como Cursor, así como en plataformas de automatización como N8N. Esta última es especialmente intuitiva, ya que los flujos de trabajo se crean visualmente, lo que facilita su comprensión. En N8N, puedes conectarte a un servidor MCP existente o crear el tuyo propio. Además, puede incluso organizar una conexión directa dentro de un mismo flujo de trabajo. Pero vayamos por partes.

Creación de un agente AI simple

Antes de empezar, asegúrate de que se cumple el requisito principal, tienes un LLM listo para las conexiones. Esto podría ser un modelo que se ejecuta localmente usando Ollama o un servicio externo como ChatGPT de OpenAI. En el primer caso, necesitarás conocer la dirección de la API local de Ollama (y opcionalmente su autenticación), y en el segundo caso, necesitarás una cuenta activa de OpenAI con suficientes créditos.

La construcción de un agente comienza con el nodo clave AI Agent. Como mínimo, debe estar vinculado con otros dos nodos, uno para actuar como disparador, y el otro para conectarse al LLM. Si no especificas un disparador, el sistema creará uno automáticamente, disparando el agente al recibir cualquier mensaje en el chat interno:

La única pieza que falta es el LLM. Por ejemplo, puede utilizar nuestra Open WebUI: Todo en uno para configurar Ollama con una interfaz web. El único cambio necesario es que los contenedores para N8N y Open WebUI deben estar en la misma red. Por ejemplo, si el contenedor N8N está en una red llamada web, entonces en el comando de despliegue para Open WebUI, sustituya --network=host por --network=web.

En algunos casos, también tendrá que configurar manualmente la variable de entorno OLLAMA_HOST, por ejemplo: -e OLLAMA_HOST=0.0.0.0. Esto permite conexiones a la API de Ollama no sólo desde localhost sino también desde otros contenedores. Supongamos que Ollama se despliega en un contenedor llamado ollama-webui. Entonces la URL base para conectarse desde N8N sería:

http://open-webui:11434

Antes de conectar el nodo Ollama Chat Model, no olvide descargar al menos un modelo. Puede hacerlo desde la interfaz web o a través de la CLI del contenedor. El siguiente comando descargará el modelo Llama 3.1 con 8 mil millones de parámetros:

ollama pull llama3.1:8b

Una vez descargado e instalado, el modelo aparecerá automáticamente en la lista de disponibles:

Un flujo de trabajo mínimo de un Agente AI tiene este aspecto:

En esta forma, el agente sólo puede utilizar un modelo y no almacena datos de entrada ni mejora las peticiones utilizando herramientas externas. Así que tiene sentido añadir al menos el nodo Simple Memory. Para cargas ligeras, es suficiente con almacenar peticiones y respuestas.

Pero volvamos a MCP. Para empezar, crea un servidor utilizando el nodo especial MCP Server Trigger:

Este nodo es totalmente autónomo y no requiere activación externa. Se activa únicamente mediante una solicitud externa entrante a su dirección webhook. Por defecto, hay dos URL: Test URL y Production URL. La primera se utiliza durante el desarrollo, mientras que la segunda sólo funciona cuando el flujo de trabajo se guarda y se activa.

El disparador es inútil por sí solo, necesita herramientas conectadas. Por ejemplo, conectemos una de las herramientas más sencillas: una calculadora. Esperará una expresión matemática como entrada. Los nodos se comunican usando JSON plano, así que para que la calculadora calcule 2 + 2, la entrada debería ser:

[
  {
    "query": {
      "input": "2 + 2"
    }
  }
]

Los LLM pueden generar fácilmente este tipo de JSON a partir de descripciones de tareas en texto plano y enviarlas al nodo, que realiza los cálculos y devuelve el resultado. Conectemos el cliente MCP al agente:

Cabe destacar que este nodo no necesita conexiones adicionales. En su configuración, basta con especificar la dirección del endpoint al que enviará los datos desde el Agente AI. En nuestro ejemplo, esta dirección apunta al contenedor llamado n8n.

Por supuesto, en esta etapa puede especificar cualquier dirección de servidor MCP externo disponible para usted. Pero para este artículo, utilizaremos una instancia local que se ejecuta dentro de N8N. Veamos cómo se comportan el cliente y el servidor cuando se le pide al Agente AI que realice una simple operación matemática:

Al recibir la petición, el Agente AI:

Busca en la Memoria Simple para ver si el usuario preguntó esto antes o si algún contexto puede ser reutilizado.
Enviará la petición al LLM, que descompondrá correctamente la expresión matemática y preparará el JSON correspondiente.
Envía el JSON a la herramienta Calculadora y recibe el resultado.
Utilizar el LLM para generar la respuesta final e insertar el resultado en la respuesta.
Almacenar el resultado en la memoria simple.
Emitir el mensaje en el chat.

De forma similar, los agentes pueden trabajar con otras herramientas en el servidor MCP. En lugar de Simple Memory, se pueden utilizar opciones más avanzadas como MongoDB, Postgres, Redis, o incluso algo como Zep. Por supuesto, estos requieren un mantenimiento mínimo de la base de datos, pero el rendimiento general aumentará significativamente.

También hay muchas más opciones para la selección de herramientas. El nodo MCP Server Trigger admite más de 200 herramientas. Puede tratarse de cualquier cosa, desde simples solicitudes HTTP hasta integraciones prediseñadas con servicios públicos de Internet. Dentro de un mismo flujo de trabajo, puedes crear tanto un servidor como un cliente. Una cosa importante a tener en cuenta: estos nodos no se pueden conectar visualmente en el editor, y ese es el comportamiento esperado:

En lugar del desencadenante predeterminado, puede utilizar otras opciones, como la recepción de un mensaje a través de un mensajero, el envío de un formulario de un sitio web o la ejecución en un horario. Esto le permite configurar flujos de trabajo que reaccionan a eventos o realizan operaciones rutinarias como exportaciones diarias de datos de Google Ads.

Y ahí no acaban las posibilidades de los agentes de IA. Puedes crear sistemas multiagente utilizando diferentes modelos de redes neuronales que trabajen juntos para resolver tareas con mayor precisión, teniendo en cuenta muchos más factores influyentes en el proceso.

Véase también:

Cómo instalar N8N

Mon, 23 Jun 2025 14:30:26 +0200

Los agentes de IA en 2025 siguen siendo uno de los enfoques más prometedores para resolver tareas complejas utilizando grandes modelos lingüísticos. Estos agentes son autónomos y capaces de seleccionar por sí mismos diversas herramientas para realizar las tareas asignadas. Este enfoque permite obtener resultados con menor intervención humana y mayor calidad. También abre oportunidades para descubrir formas más originales y eficaces de abordar los problemas.

En lugar de limitarse a formular una tarea, se ordena a la red neuronal que la resuelva de forma autónoma, en función de los recursos que se le asignen. Sin embargo, para que este esquema funcione, tiene que haber un mecanismo que conecte las interfaces de las redes neuronales con diversas herramientas, ya sea una búsqueda en la web o una base de datos vectorial para almacenar resultados intermedios.

n8n es una plataforma de automatización que admite la integración con diversas redes neuronales y servicios públicos. Los usuarios pueden diseñar visualmente cómo se procesarán los datos y qué resultado final debe obtenerse. A diferencia de las soluciones clásicas sin código, n8n permite incluir código arbitrario en cualquier fase del proceso, lo que resulta especialmente útil cuando la funcionalidad incorporada no es suficiente.

El resultado es un sistema que combina la sencillez del no-code con la flexibilidad de la programación tradicional. Sin embargo, para entenderlo completamente, todavía necesitarás pasar algún tiempo explorando y revisando ejemplos de flujos de trabajo para una mejor comprensión. En este artículo, le mostraremos cómo implementar n8n en servidores LeaderGPU.

Preparación del servidor

Actualizar el sistema

Actualice la lista de paquetes y actualice todos los paquetes instalados:

sudo apt update && sudo apt -y upgrade

Instala automáticamente el controlador NVIDIA® recomendado (propietario) o utiliza nuestra guía paso a paso Instalar controladores NVIDIA® en Linux:

sudo ubuntu-drivers autoinstall

Ahora reinicia el servidor:

sudo shutdown -r now

Instalar Docker

Puedes usar el script de instalación oficial:

curl -sSL https://get.docker.com/ | sh

Añadamos la clave GPG y el repositorio de NVIDIA® container toolkit para la integración en Docker:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualiza la lista de paquetes e instala NVIDIA® container toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Reinicia Docker para aplicar los cambios y activar el kit de herramientas instalado:

sudo systemctl restart docker

Instalar n8n

Para que el sistema pueda almacenar datos, es necesario crear un volumen antes de lanzar el contenedor:

sudo docker volume create n8n_data

Ahora, vamos a lanzar un contenedor que abrirá el puerto 5678 para conexiones externas y montará el volumen n8n_data creado en el directorio /home/node/.n8n dentro del contenedor:

sudo docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

La primera vez que lances la aplicación, puede que te sorprenda el siguiente mensaje de error:

Esto no es exactamente un error, es más bien una advertencia sobre cómo configurar correctamente el sistema para el acceso. El problema es que, por defecto, el sistema no tiene un certificado TLS/HTTPS. Sin él, la conexión no será segura. Así que tienes tres opciones:

Connect your own certificate. Puedes hacerlo especificando las rutas a los archivos de certificado mediante variables de entorno, o configurando un servidor proxy inverso.
Create an SSH tunnel and forward port 5678 a localhost en el ordenador desde el que te estás conectando. De esta forma, obtendrás inmediatamente una conexión personal segura. Sin embargo, nadie más podrá acceder externamente al servidor.
Bypass the warning. Si se trata de un servidor de pruebas que no está pensado para su uso en producción y no te preocupa la seguridad, puedes desactivar la advertencia estableciendo la variable de entorno N8N_SECURE_COOKIE en FALSE. Esto se desaconseja totalmente, ya que hace que el servidor sea vulnerable a posibles ataques. Aún así, puede ser aceptable en escenarios específicos.

Este artículo explorará cada opción en detalle para que puedas elegir la correcta.

Conexión al servidor

Si aún no dispone de un certificado SSL, le recomendamos que solicite uno a LeaderSSL. Se puede utilizar para cualquier sitio web, tienda en línea o para verificar la autenticidad de un correo electrónico.

Uso de variables de entorno

La forma más sencilla de configurar HTTPS es cargar el certificado en el servidor y especificarlo mediante variables de entorno Docker. Comience por crear un directorio para los archivos del certificado:

mkdir ~/n8n-certs

Puedes subir estos archivos (normalmente cert.crt y privkey.key) a este directorio usando cualquier método. Para obtener información más detallada, consulte:

Ahora, vamos a lanzar el contenedor utilizando un comando completo:

sudo docker run -d \
--name n8n \
-p 5678:5678 \
-v n8n_data:/home/node/.n8n \
-v ~/n8n-certs:/certs \
-e N8N_PROTOCOL=https \
-e N8N_SSL_CERT="/certs/cert.crt" \
-e N8N_SSL_KEY="/certs/privkey.key" \
docker.n8n.io/n8nio/n8n

Aquí tienes un desglose de cada argumento:

sudo docker run -d lanza el contenedor Docker en modo demonio (en segundo plano)
--name n8n asigna un nombre al contenedor n8n
-p 5678:5678 reenvía el puerto 5678 al contenedor
-v n8n_data:/home/node/.n8n crea y monta un volumen llamado n8n_data en el directorio oculto /home/node/.n8n dentro del contenedor
-v ~/n8n-certs:/certs monta el directorio de certificados
-e N8N_PROTOCOL=https obliga a N8N a utilizar el protocolo HTTPS
-e N8N_SSL_CERT="/certs/cert.crt" establece la ruta al archivo del certificado
-e N8N_SSL_KEY="/certs/privkey.key" establece la ruta a la clave del certificado
docker.n8n.io/n8nio/n8n fuente de la imagen del contenedor

Traefik

Una configuración ligeramente más compleja pero flexible implica el uso del servidor proxy inverso Traefik para asegurar la conexión a N8N. El archivo de configuración se basa en el método oficial especificado en la documentación. En primer lugar, instale la herramienta docker-compose:

sudo apt -y install docker-compose

Desplegaremos Traefik y N8N juntos, y necesitan estar en la misma red. Crea una red llamada web.

sudo docker network create web

Ahora, crea un archivo docker-compose.yml para definir y ejecutar ambos contenedores:

nano docker-compose.yml

services:
  traefik:
    image: "traefik"
    container_name: "proxy"
    restart: always
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.mytlschallenge.acme.tlschallenge=true"
      - "--certificatesresolvers.mytlschallenge.acme.email=${SSL_EMAIL}"
      - "--certificatesresolvers.mytlschallenge.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - traefik_data:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock:ro
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: "n8n"
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    labels:
      - traefik.enable=true
      - traefik.http.routers.n8n.rule=Host(`${SUBDOMAIN}.${DOMAIN_NAME}`)
      - traefik.http.routers.n8n.tls=true
      - traefik.http.routers.n8n.entrypoints=web,websecure
      - traefik.http.routers.n8n.tls.certresolver=mytlschallenge
      - traefik.http.middlewares.n8n.headers.SSLRedirect=true
      - traefik.http.middlewares.n8n.headers.STSSeconds=315360000
      - traefik.http.middlewares.n8n.headers.browserXSSFilter=true
      - traefik.http.middlewares.n8n.headers.contentTypeNosniff=true
      - traefik.http.middlewares.n8n.headers.forceSTSHeader=true
      - traefik.http.middlewares.n8n.headers.SSLHost=${DOMAIN_NAME}
      - traefik.http.middlewares.n8n.headers.STSIncludeSubdomains=true
      - traefik.http.middlewares.n8n.headers.STSPreload=true
      - traefik.http.routers.n8n.middlewares=n8n@docker
    environment:
      - N8N_HOST=${SUBDOMAIN}.${DOMAIN_NAME}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://${SUBDOMAIN}.${DOMAIN_NAME}/
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
    volumes:
      - n8n_data:/home/node/.n8n
      - ./local-files:/files
    networks:
      - web

volumes:
  n8n_data:
  traefik_data:

networks:
  web:
    name: web

Además del archivo docker-compose.yml, crearemos otro archivo llamado .env. Este archivo contendrá variables como el nombre de dominio y la dirección de correo electrónico utilizados para solicitar un certificado SSL a Let's Encrypt. Si alguna vez necesitamos cambiar algo, como el nombre de dominio, sólo tendremos que actualizarlo en este archivo y luego volver a crear el contenedor.

nano .env

DOMAIN_NAME=example.com
SUBDOMAIN=n8n
GENERIC_TIMEZONE=Europe/Amsterdam
SSL_EMAIL=user@example.com

Por último, despliega ambos contenedores:

sudo docker-compose up -d

Ahora, N8N está disponible aquí: https://n8n.example.com.

Gestor de proxy Nginx

A diferencia de Traefik, que se configura a través de archivos, Nginx Proxy Manager ofrece una interfaz web fácil de usar. Sin embargo, no detecta servicios dinámicamente, sino que hay que añadirlos manualmente. Aún así, funciona bien para servicios estáticos como N8N.

Crea otro archivo docker-compose.yml en un directorio separado con el siguiente contenido:

services:
  app:
    image: 'jc21/nginx-proxy-manager:latest'
    container_name: proxy
    restart: unless-stopped
    ports:
      - '80:80'
      - '443:443'
      - '81:81'
    volumes:
      - ./data:/data
      - ./letsencrypt:/etc/letsencrypt
    networks:
      - web

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    environment:
      - N8N_HOST=n8n.example.com
      - N8N_PORT=5678
      - WEBHOOK_URL=https://n8n.example.com/
      - N8N_PROTOCOL=http
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - web

volumes:
  n8n_data:

networks:
  web:
    external: true

Desplegar con:

sudo docker-compose up -d

A continuación, abra la interfaz web en: http://your_hostname_or_ip:81

Nombre de usuario: admin@example.com
Contraseña: changeme

Se te pedirá que actualices tus credenciales. A continuación, abra Hosts → Proxy Hosts → Add Proxy Host, introduzca su nombre de dominio (por ejemplo, n8n.example.com):

Rellena los campos necesarios:

Establezca Destination/IP en n8n.
Establezca Port en 5678.
En la pestaña SSL, seleccione Request a new SSL certificate with Let’s Encrypt.
Introduzca su correo electrónico y acepte las condiciones.
Haga clic en Websockets support.
Opcionalmente, haga clic en Force SSL.

Tras pulsar el botón Save, se solicitará e instalará el certificado:

Una vez hecho esto, al abrir su dominio accederá a la interfaz N8N.

Túnel SSH

Si no necesita la accesibilidad externa de N8N, puede reenviar el puerto 5678 a través de SSH. Esto encripta todo el tráfico, y N8N estará disponible en http://localhost:5678/.

Nota: Esta configuración no funcionará para integraciones con servicios externos como mensajeros que requieren acceso HTTPS público.

La forma más sencilla de redireccionar el puerto es con el popular cliente SSH PuTTY. Una vez instalado, abra SSH → Tunnels y configure Source port - 5678 y Destination - localhost:5678. A continuación, haga clic en Add.

Vuelva a Session, introduzca la IP de su servidor y haga clic en Open. Una vez autenticado, el túnel estará activo. Abra http://localhost:5678 en un navegador para acceder a N8N.

Nota: La conexión sólo funciona mientras la sesión SSH está activa. Cerrar PuTTY terminará el túnel.

Pasar por alto

No se recomienda utilizar este método en redes públicas. Si lanza el contenedor con la variable de entorno N8N_SECURE_COOKIE=false, la advertencia desaparecerá, y obtendrá acceso a través de HTTP:

sudo docker run -d --name n8n -p 5678:5678 -e N8N_SECURE_COOKIE=false -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

Warning: esto expone el panel de administración de N8N a través de HTTP sin cifrar, haciéndolo vulnerable a ataques MITM (Man-In-The-Middle) y potencialmente permite a un atacante tomar completamente el control de su servidor.

Véase también:

Triton™ Inference Server

Wed, 26 Feb 2025 16:40:21 +0100

Los requisitos empresariales pueden variar, pero todos comparten un principio básico: los sistemas deben funcionar con rapidez y ofrecer la máxima calidad posible. Cuando se trata de la inferencia de redes neuronales, el uso eficiente de los recursos computacionales se convierte en algo crucial. Cualquier infrautilización de la GPU o tiempo de inactividad se traduce directamente en pérdidas económicas.

Consideremos un mercado como ejemplo. Estas plataformas alojan numerosos productos, cada uno con múltiples atributos: descripciones de texto, especificaciones técnicas, categorías y contenido multimedia como fotos y vídeos. Todo el contenido requiere moderación para mantener unas condiciones justas para los vendedores y evitar que aparezcan en la plataforma productos prohibidos o contenidos ilegales.

Aunque la moderación manual es posible, resulta lenta e ineficaz. En un entorno tan competitivo como el actual, los vendedores necesitan ampliar su gama de productos con rapidez: cuanto más rápido aparezcan los artículos en el mercado, más posibilidades tendrán de ser descubiertos y comprados. La moderación manual también es costosa y propensa a errores humanos, lo que puede permitir la publicación de contenidos inapropiados.

La moderación automática mediante redes neuronales especialmente entrenadas ofrece una solución. Este enfoque aporta múltiples ventajas: reduce sustancialmente los costes de moderación al tiempo que suele mejorar la calidad. Las redes neuronales procesan los contenidos mucho más rápido que los humanos, lo que permite a los vendedores superar la fase de moderación con mayor rapidez, especialmente cuando se manejan grandes volúmenes de productos.

Sin embargo, este método tiene sus dificultades. La moderación automatizada requiere desarrollar y entrenar modelos de redes neuronales, lo que exige personal cualificado y recursos informáticos considerables. Sin embargo, las ventajas se aprecian rápidamente tras la implantación inicial. La implantación automatizada de modelos puede agilizar considerablemente las operaciones en curso.

Inferencia

Supongamos que hemos resuelto los procedimientos de aprendizaje automático. El siguiente paso es determinar cómo ejecutar la inferencia del modelo en un servidor alquilado. Para un único modelo, normalmente se elige una herramienta que funcione bien con el marco específico en el que se creó. Sin embargo, cuando se trata de múltiples modelos creados en diferentes marcos, tiene dos opciones.

Puedes convertir todos los modelos a un único formato, o elegir una herramienta que soporte múltiples marcos. Triton™ Inference Server encaja perfectamente con el segundo enfoque. Soporta los siguientes backends:

TensorRT™
TensorRT-LLM
vLLM
Python
PyTorch (LibTorch)
ONNX Runtime
Tensorflow
FIL
DALI

Además, puede utilizar cualquier aplicación como backend. Por ejemplo, si necesitas post-procesamiento con una aplicación C/C++, puedes integrarla sin problemas.

Escalado

Triton™ Inference Server gestiona eficientemente los recursos computacionales de un único servidor ejecutando múltiples modelos simultáneamente y distribuyendo la carga de trabajo entre las GPUs.

La instalación se realiza a través de un contenedor Docker. Los ingenieros de DevOps pueden controlar la asignación de GPU al inicio, eligiendo utilizar todas las GPU o limitar su número. Aunque el software no gestiona directamente el escalado horizontal, se pueden utilizar balanceadores de carga tradicionales como HAproxy o desplegar aplicaciones en un clúster Kubernetes con este fin.

Preparación del sistema

Para configurar Triton™ en un servidor LeaderGPU con Ubuntu 22.04, primero actualiza el sistema utilizando este comando:

sudo apt update && sudo apt -y upgrade

En primer lugar, instala los controladores NVIDIA® utilizando el script de autoinstalación:

sudo ubuntu-drivers autoinstall

Reinicia el servidor para aplicar los cambios:

sudo shutdown -r now

Una vez que el servidor vuelva a estar en línea, instale Docker utilizando el siguiente script de instalación:

curl -sSL https://get.docker.com/ | sh

Como Docker no puede pasar GPUs a contenedores por defecto, necesitarás el NVIDIA® Container Toolkit. Añade el repositorio de NVIDIA® descargando y registrando su clave GPG:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualiza la caché de paquetes e instala el kit de herramientas:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Reinicia Docker para habilitar las nuevas capacidades:

sudo systemctl restart docker

El sistema operativo ya está listo para su uso.

Instalación del servidor de inferencia Triton™

Vamos a descargar el repositorio del proyecto:

git clone https://github.com/triton-inference-server/server

Este repositorio contiene ejemplos de redes neuronales preconfiguradas y un script de descarga de modelos. Navega hasta el directorio examples:

cd server/docs/examples

Descargue los modelos ejecutando el siguiente script, que los guardará en ~/server/docs/examples/model_repository:

./fetch_models.sh

La arquitectura del Servidor de Inferencia Triton™ requiere que los modelos se almacenen por separado. Puedes almacenarlos localmente en cualquier directorio del servidor o en almacenamiento en red. Al iniciar el servidor, tendrás que montar este directorio en el contenedor en el punto de montaje /models. Esto sirve como repositorio para todas las versiones de los modelos.

Inicie el contenedor con este comando

sudo docker run --gpus=all --rm -p8000:8000 -p8001:8001 -p8002:8002 -v ~/server/docs/examples/model_repository:/models nvcr.io/nvidia/tritonserver:25.01-py3 tritonserver --model-repository=/models

Esto es lo que hace cada parámetro

--gpus=all especifica que se utilizarán todas las GPUs disponibles en el servidor;
--rm destruye el contenedor una vez finalizado o detenido el proceso;
-p8000:8000 reenvía el puerto 8000 para recibir peticiones HTTP;
-p8001:8001 reenvía el puerto 8001 para recibir peticiones gRPC;
-p8002:8002 reenvía el puerto 8002 para solicitar métricas;
-v ~/server/docs/examples/model_repository:/models reenvía el directorio con modelos
nvcr.io/nvidia/tritonserver:25.01-py3 dirección del contenedor del catálogo NGC;
tritonserver --model-repository=/models lanza el Servidor de Inferencia Triton™ con la ubicación del repositorio de modelos en /models.

La salida del comando mostrará todos los modelos disponibles en el repositorio, cada uno listo para aceptar peticiones:

+----------------------+---------+--------+
| Model                | Version | Status |
+----------------------+---------+--------+
| densenet_onnx        | 1       | READY  |
| inception_graphdef   | 1       | READY  |
| simple               | 1       | READY  |
| simple_dyna_sequence | 1       | READY  |
| simple_identity      | 1       | READY  |
| simple_int8          | 1       | READY  |
| simple_sequence      | 1       | READY  |
| simple_string        | 1       | READY  |
+----------------------+---------+--------+

Los tres servicios se han lanzado con éxito en los puertos 8000, 8001 y 8002:

I0217 08:00:34.930188 1 grpc_server.cc:2466] Started GRPCInferenceService at 0.0.0.0:8001
I0217 08:00:34.930393 1 http_server.cc:4636] Started HTTPService at 0.0.0.0:8000
I0217 08:00:34.972340 1 http_server.cc:320] Started Metrics Service at 0.0.0.0:8002

Usando la utilidad nvtop, podemos verificar que todas las GPUs están listas para aceptar la carga:

Instalación del cliente

Para acceder a nuestro servidor, necesitaremos generar una petición apropiada utilizando el cliente incluido en el SDK. Podemos descargar este SDK como un contenedor Docker:

sudo docker pull nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Ejecuta el contenedor en modo interactivo para acceder a la consola:

sudo docker run -it --gpus=all --rm --net=host nvcr.io/nvidia/tritonserver:25.01-py3-sdk

Vamos a probarlo con el modelo DenseNet en formato ONNX, utilizando el método INCEPTION para preprocesar y analizar la imagen mug.jpg:

/workspace/install/bin/image_client -m densenet_onnx -c 3 -s INCEPTION /workspace/images/mug.jpg

El cliente contactará con el servidor, que creará un lote y lo procesará utilizando las GPUs disponibles del contenedor. Este es el resultado:

Request 0, batch size 1
Image '/workspace/images/mug.jpg':
   15.349562 (504) = COFFEE MUG
   13.227461 (968) = CUP
   10.424891 (505) = COFFEEPOT

Preparando el repositorio

Para que Triton™ gestione los modelos correctamente, debes preparar el repositorio de una manera específica. Esta es la estructura de directorios:

model_repository/ 
        └── your_model/ 
                ├── config.pbtxt 
                └── 1/
                    └── model.*

Cada modelo necesita su propio directorio que contenga un archivo de configuración config.pbtxt con su descripción. He aquí un ejemplo:

name: "Test"
platform: "pytorch_libtorch"
max_batch_size: 8
input [
  {
    name: "INPUT_0"
    data_type: TYPE_FP32
    dims: [ 3, 224, 224 ]
  }
]
output [
  {
    name: "OUTPUT_0"
    data_type: TYPE_FP32
    dims: [ 1000 ]
  }
]

En este ejemplo, un modelo llamado Test se ejecutará en el backend PyTorch. El parámetro max_batch_size establece el número máximo de elementos que se pueden procesar simultáneamente, lo que permite un equilibrio de carga eficiente entre los recursos. Establecer este valor a cero desactiva el procesamiento por lotes, haciendo que el modelo procese las peticiones secuencialmente.

El modelo acepta una entrada y produce una salida, ambas utilizando el tipo de número FP32. Los parámetros deben coincidir exactamente con los requisitos del modelo. Para el procesamiento de imágenes, una especificación de dimensión típica es dims: [ 3, 224, 224 ], donde:

3 - número de canales de color (RGB);
224 - altura de la imagen en píxeles;
224 - anchura de la imagen en píxeles.

La salida dims: [ 1000 ] representa un vector unidimensional de 1000 elementos, que se adapta a las tareas de clasificación de imágenes. Para determinar la dimensionalidad correcta para su modelo, consulte su documentación. Si el archivo de configuración está incompleto, Triton™ intentará generar automáticamente los parámetros que falten.

Iniciar un modelo personalizado

Vamos a lanzar la inferencia del modelo DeepSeek-R1 destilado del que hemos hablado antes. En primer lugar, crearemos la estructura de directorios necesaria:

mkdir ~/model_repository && mkdir ~/model_repository/deepseek && mkdir ~/model_repository/deepseek/1

Navegue hasta el directorio del modelo:

cd ~/model_repository/deepseek

Cree un archivo de configuración config.pbtxt:

nano config.pbtxt

Pegue lo siguiente:

# Copyright 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
# Note: You do not need to change any fields in this configuration.
    
backend: "vllm"
    
# The usage of device is deferred to the vLLM engine
instance_group [
  {
    count: 1
    kind: KIND_MODEL
  }
]

Guarde el archivo pulsando Ctrl + O, luego el editor con Ctrl + X. Navegue hasta el directorio 1:

cd 1

Cree un fichero de configuración del modelo model.json con los siguientes parámetros:

{
    "model":"deepseek-ai/DeepSeek-R1-Distill-Llama-8B",
    "disable_log_requests": true,
    "gpu_memory_utilization": 0.9,
    "enforce_eager": true
}

Ten en cuenta que el valor de gpu_memory_utilization varía según la GPU y debe determinarse experimentalmente. Para esta guía, utilizaremos 0.9. Su estructura de directorios dentro de ~/model_repository ahora debe tener este aspecto:

└── deepseek
        ├── 1
        │   └── model.json
        └── config.pbtxt

Establece la variable LOCAL_MODEL_REPOSITORY por conveniencia:

LOCAL_MODEL_REPOSITORY=~/model_repository/

Inicie el servidor de inferencia con este comando:

sudo docker run --rm -it --net host --shm-size=2g  --ulimit memlock=-1 --ulimit stack=67108864 --gpus all -v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository  nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 tritonserver --model-repository=model_repository/

Esto es lo que hace cada parámetro:

--rm elimina automáticamente el contenedor tras detenerse;
-it ejecuta el contenedor en modo interactivo con salida de terminal;
--net utiliza la pila de red del host en lugar del aislamiento del contenedor;
--shm-size=2g establece la memoria compartida en 2 GB;
--ulimit memlock=-1 elimina el límite de bloqueo de memoria;
--ulimit stack=67108864 fija el tamaño de la pila en 64 MB;
--gpus all habilita el acceso a todas las GPU del servidor;
-v $LOCAL_MODEL_REPOSITORY:/opt/tritonserver/model_repository monta el directorio del modelo local en el contenedor;
nvcr.io/nvidia/tritonserver:25.01-vllm-python-py3 especifica el contenedor con soporte vLLM backend;
tritonserver --model-repository=model_repository/ lanza el Servidor de Inferencia Triton™ con la ubicación del repositorio de modelos en model_repository.

Prueba el servidor enviando una petición con curl, utilizando un prompt simple y un límite de respuesta de 4096 tokens:

curl -X POST localhost:8000/v2/models/deepseek/generate -d '{"text_input": "Tell me about the Netherlands?", "max_tokens": 4096}'

El servidor recibe y procesa la petición con éxito.

El programador de tareas interno de Triton™ gestiona todas las peticiones entrantes cuando el servidor está bajo carga.

Conclusión

El Servidor de Inferencia Triton™ destaca en el despliegue de modelos de aprendizaje automático en producción al distribuir eficientemente las peticiones entre las GPUs disponibles. Esto maximiza el uso de los recursos del servidor alquilado y reduce los costes de la infraestructura informática. El software funciona con varios backends, incluido vLLM para modelos lingüísticos de gran tamaño.

Dado que se instala como un contenedor Docker, puede integrarse fácilmente en cualquier canal CI/CD moderno. Pruébelo usted mismo alquilando un servidor de LeaderGPU.

DeepSeek-R1: el futuro de los LLM

Wed, 19 Feb 2025 15:10:33 +0100

Aunque las redes neuronales generativas se han desarrollado rápidamente, su progreso en los últimos años se ha mantenido bastante estable. Esto cambió con la llegada de DeepSeek, una red neuronal china que no sólo impactó en la bolsa, sino que captó la atención de desarrolladores e investigadores de todo el mundo. A diferencia de otros grandes proyectos, el código de DeepSeek se publicó bajo la permisiva licencia MIT. Este paso hacia el código abierto se ganó los elogios de la comunidad, que empezó a explorar con entusiasmo las capacidades del nuevo modelo.

El aspecto más impresionante fue que, al parecer, el entrenamiento de esta nueva red neuronal costó 20 veces menos que el de competidores que ofrecían una calidad similar. El modelo sólo necesitó 55 días y 5,6 millones de dólares para entrenarse. El lanzamiento de DeepSeek provocó una de las mayores caídas en un solo día de la historia del mercado bursátil estadounidense. Aunque los mercados acabaron estabilizándose, el impacto fue significativo.

Este artículo examinará la precisión con la que los titulares de los medios reflejan la realidad y explorará qué configuraciones de LeaderGPU son adecuadas para instalar usted mismo esta red neuronal.

Características arquitectónicas

DeepSeek ha elegido un camino de máxima optimización, lo que no es de extrañar dadas las restricciones a la exportación de China a Estados Unidos. Estas restricciones impiden que el país utilice oficialmente los modelos de GPU más avanzados para el desarrollo de IA.

El modelo emplea la tecnología Multi Token Prediction (MTP), que predice múltiples tokens en un solo paso de inferencia en lugar de uno solo. Esto funciona mediante la descodificación paralela de tokens combinada con capas especiales enmascaradas que mantienen la autorregresividad.

Las pruebas de MTP han mostrado resultados notables, aumentando la velocidad de generación entre 2 y 4 veces en comparación con los métodos tradicionales. La excelente escalabilidad de la tecnología la hace valiosa para aplicaciones actuales y futuras de procesamiento del lenguaje natural.

El modelo Multi-Head Latent Attention (MLA) presenta un mecanismo de atención mejorado. A medida que el modelo construye largas cadenas de razonamiento, mantiene la atención centrada en el contexto en cada etapa. Esta mejora le permite manejar mejor los conceptos abstractos y las dependencias textuales.

La característica clave de MLA es su capacidad para ajustar dinámicamente el peso de la atención a distintos niveles de abstracción. Al procesar consultas complejas, MLA examina los datos desde múltiples perspectivas: el significado de las palabras, la estructura de las frases y el contexto general. Estas perspectivas forman capas distintas que influyen en el resultado final. Para mantener la claridad, MLA equilibra cuidadosamente el impacto de cada capa sin perder de vista la tarea principal.

Los desarrolladores de DeepSeek incorporaron al modelo la tecnología de Mezcla de Expertos (MoE). Contiene 256 redes neuronales expertas preentrenadas, cada una especializada en tareas diferentes. El sistema activa 8 de estas redes para cada entrada de token, lo que permite un procesamiento eficiente de los datos sin aumentar los costes computacionales.

En el modelo completo con 671b parámetros, sólo se activan 37b para cada token. El modelo selecciona de forma inteligente los parámetros más relevantes para procesar cada ficha entrante. Esta eficiente optimización ahorra recursos computacionales al tiempo que mantiene un alto rendimiento.

Una característica crucial de cualquier chatbot de red neuronal es la longitud de su ventana de contexto. Llama 2 tiene un límite de contexto de 4.096 tokens, GPT-3.5 maneja 16.284 tokens, mientras que GPT-4 y DeepSeek pueden procesar hasta 128.000 tokens (unas 100.000 palabras, equivalentes a 300 páginas de texto mecanografiado).

R - Razonamiento

DeepSeek-R1 ha adquirido un mecanismo de razonamiento similar al de OpenAI o1, lo que le permite gestionar tareas complejas con mayor eficacia y precisión. En lugar de proporcionar respuestas inmediatas, el modelo amplía el contexto generando razonamientos paso a paso en pequeños párrafos. Este enfoque mejora la capacidad de la red neuronal para identificar relaciones complejas entre datos, lo que da lugar a respuestas más completas y precisas.

Cuando se enfrenta a una tarea compleja, DeepSeek utiliza su mecanismo de razonamiento para descomponer el problema en componentes y analizar cada uno por separado. A continuación, el modelo sintetiza estos resultados para generar una respuesta para el usuario. Aunque este parece ser un enfoque ideal para las redes neuronales, conlleva importantes retos.

Todas las LLM modernas comparten un rasgo preocupante: las alucinaciones artificiales. Cuando se le presenta una pregunta que no puede responder, en lugar de reconocer sus limitaciones, el modelo puede generar respuestas ficticias apoyadas en hechos inventados.

Cuando se aplican a una red neuronal de razonamiento, estas alucinaciones podrían comprometer el proceso de pensamiento al basar las conclusiones en información ficticia y no en hechos. Esto podría llevar a conclusiones incorrectas, un reto que los investigadores y desarrolladores de redes neuronales tendrán que abordar en el futuro.

Consumo de VRAM

Veamos cómo ejecutar y probar DeepSeek R1 en un servidor dedicado, centrándonos en los requisitos de memoria de vídeo de la GPU.

Modelo	VRAM (Mb)	Tamaño del modelo (Gb)
deepseek-r1:1.5b	1,952	1.1
deepseek-r1:7b	5,604	4.7
deepseek-r1:8b	6,482	4.9
deepseek-r1:14b	10,880	9
deepseek-r1:32b	21,758	20
deepseek-r1:70b	39,284	43
deepseek-r1:671b	470,091	404

Las tres primeras opciones (1.5b, 7b, 8b) son modelos básicos que pueden realizar la mayoría de las tareas de forma eficiente. Estos modelos funcionan sin problemas en cualquier GPU de consumo con 6-8 GB de memoria de vídeo. Las versiones intermedias (14b y 32b) son ideales para tareas profesionales, pero requieren más VRAM. Los modelos más grandes (70b y 671b) requieren GPU especializadas y se utilizan principalmente para aplicaciones industriales y de investigación.

Selección de servidores

Para ayudarte a elegir un servidor para la inferencia DeepSeek, aquí tienes las configuraciones LeaderGPU ideales para cada grupo de modelos:

1,5b / 7b / 8b / 14b / 32b / 70b

Para este grupo, cualquier servidor con los siguientes tipos de GPU será adecuado. La mayoría de los servidores LeaderGPU ejecutarán estas redes neuronales sin problemas. El rendimiento dependerá principalmente del número de núcleos CUDA®. Recomendamos servidores con múltiples GPUs, tales como:

671b

Ahora pasemos al caso más difícil: ¿cómo ejecutar la inferencia en un modelo con un tamaño base de 404 GB? Esto significa que se necesitarán aproximadamente 470 GB de memoria de vídeo. LeaderGPU ofrece múltiples configuraciones con las siguientes GPU capaces de manejar esta carga:

A100
H100

Ambas configuraciones gestionan la carga del modelo de forma eficiente, distribuyéndola uniformemente entre varias GPU. Por ejemplo, este es el aspecto de un servidor con 8xH100 después de cargar el modelo deepseek-r1:671b:

La carga computacional se equilibra dinámicamente entre las GPU, mientras que las interconexiones NVLink® de alta velocidad evitan los cuellos de botella en el intercambio de datos, garantizando el máximo rendimiento.

Conclusión

DeepSeek-R1 combina muchas tecnologías innovadoras como la predicción multitoken, la atención latente multicabeza y la mezcla de expertos en un modelo significativo. Este software de código abierto demuestra que los LLM pueden desarrollarse de forma más eficiente con menos recursos computacionales. El modelo tiene varias versiones, desde la más pequeña de 1,5b hasta la enorme de 671b, que requieren hardware especializado con múltiples GPU de gama alta trabajando en paralelo.

Al alquilar un servidor de LeaderGPU para la inferencia de DeepSeek-R1, obtendrá una amplia gama de configuraciones, fiabilidad y tolerancia a fallos. Nuestro equipo de soporte técnico le ayudará con cualquier problema o pregunta, mientras que la instalación automática del sistema operativo reduce el tiempo de implementación.

Elija su servidor LeaderGPU y descubra las posibilidades que se abren al utilizar modernos modelos de redes neuronales. Si tiene alguna pregunta, no dude en formularla en nuestro chat o por correo electrónico.

Intel Habana Gaudí 2: instalación y prueba

Thu, 23 Jan 2025 13:41:09 +0100

Antes de empezar a instalar el software de los aceleradores Gaudí 2, hay una característica importante que merece la pena mencionar. Estamos acostumbrados a que el entrenamiento y la inferencia de redes neuronales se realicen utilizando GPUs. Sin embargo, Intel Habana Gaudi 2 es muy diferente de las GPU y representa una clase diferente de dispositivos que están diseñados exclusivamente para la aceleración de tareas de IA.

Muchas aplicaciones y marcos de trabajo conocidos no funcionarán sin preparar primero el sistema operativo y, en algunos casos, sin un kit de herramientas especial para la migración a la GPU. Esto explica el gran número de pasos preparatorios que describimos en este artículo. Empecemos por orden.

Paso 1. Instala SynapseAI Software Stack

Para empezar a trabajar con los aceleradores Intel Habana Gaudi 2, es necesario instalar la pila SynapseAI. Incluye un compilador de gráficos especial que transforma la topología del modelo de red neuronal para optimizar eficazmente la ejecución en la arquitectura Gaudí, bibliotecas API para el escalado horizontal, así como un SDK independiente para crear algoritmos de alto rendimiento y modelos de aprendizaje automático.

Por otra parte, cabe destacar que SynapseAI es la parte que permite crear un puente entre marcos de trabajo populares como PyTorch/TensorFlow y los aceleradores de IA de Gaudi 2. Esto permite trabajar con abstracciones conocidas, y Gaudi 2 optimiza de forma independiente los cálculos Los operadores específicos para los que los aceleradores no tienen soporte de hardware se ejecutan en la CPU.

Para simplificar la instalación de los componentes individuales de SynapseAI, se ha creado un cómodo script de shell. Vamos a descargarlo:

wget -nv https://vault.habana.ai/artifactory/gaudi-installer/latest/habanalabs-installer.sh

Haga el archivo ejecutable:

chmod +x habanalabs-installer.sh

Ejecuta el script:

./habanalabs-installer.sh install --type base

Siga las instrucciones del sistema durante la instalación. Encontrarás un informe detallado en el archivo de registro. En él podrás ver qué paquetes se instalaron, así como si los aceleradores se encontraron e inicializaron correctamente.

Registros aquí: /var/log/habana_logs/install-YYYY-MM-DD-HH-MM-SS.log

[  +3.881647] habanalabs hl5: Found GAUDI2 device with 96GB DRAM
[  +0.008145] habanalabs hl0: Found GAUDI2 device with 96GB DRAM
[  +0.032034] habanalabs hl3: Found GAUDI2 device with 96GB DRAM
[  +0.002376] habanalabs hl4: Found GAUDI2 device with 96GB DRAM
[  +0.005174] habanalabs hl1: Found GAUDI2 device with 96GB DRAM
[  +0.000390] habanalabs hl2: Found GAUDI2 device with 96GB DRAM
[  +0.007065] habanalabs hl7: Found GAUDI2 device with 96GB DRAM
[  +0.006256] habanalabs hl6: Found GAUDI2 device with 96GB DRAM

Al igual que la utilidad nvidia-smi proporciona información sobre las GPUs instaladas y los procesos de computación en ejecución, SynapseAI tiene un programa similar. Puedes ejecutarlo para obtener un informe sobre el estado actual de los aceleradores de IA Gaudí 2:

hl-smi

Paso 2. Prueba TensorFlow

TensorFlow es una de las plataformas más populares para el aprendizaje automático. Usando el mismo script de instalación, puedes instalar una versión pre-construida de TensorFlow con soporte para los aceleradores Gaudi 2. Empecemos instalando las dependencias generales:

./habanalabs-installer.sh install -t dependencies

A continuación, instalaremos las dependencias para TensorFlow:

./habanalabs-installer.sh install -t dependencies-tensorflow

Instalar la plataforma TensorFlow dentro de un entorno virtual implementado mediante el mecanismo Python Virtual Environment (venv):

./habanalabs-installer.sh install --type tensorflow --venv

Activemos el entorno virtual creado:

source habanalabs-venv/bin/activate

Crear un sencillo ejemplo de código Python que utilizará las capacidades de los aceleradores Gaudí 2:

nano example.py


import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import os
# Import Habana Torch Library
import habana_frameworks.torch.core as htcore
class SimpleModel(nn.Module):
   def __init__(self):
       super(SimpleModel, self).__init__()
       self.fc1   = nn.Linear(784, 256)
       self.fc2   = nn.Linear(256, 64)
       self.fc3   = nn.Linear(64, 10)
   def forward(self, x):
       out = x.view(-1,28*28)
       out = F.relu(self.fc1(out))
       out = F.relu(self.fc2(out))
       out = self.fc3(out)
       return out
def train(net,criterion,optimizer,trainloader,device):
   net.train()
   train_loss = 0.0
   correct = 0
   total = 0
   for batch_idx, (data, targets) in enumerate(trainloader):
       data, targets = data.to(device), targets.to(device)
       optimizer.zero_grad()
       outputs = net(data)
       loss = criterion(outputs, targets)
       loss.backward()
       # API call to trigger execution
       htcore.mark_step()
       optimizer.step()
       # API call to trigger execution
       htcore.mark_step()
       train_loss += loss.item()
       _, predicted = outputs.max(1)
       total += targets.size(0)
       correct += predicted.eq(targets).sum().item()
   train_loss = train_loss/(batch_idx+1)
   train_acc = 100.0*(correct/total)
   print("Training loss is {} and training accuracy is {}".format(train_loss,train_acc))
def test(net,criterion,testloader,device):
   net.eval()
   test_loss = 0
   correct = 0
   total = 0
   with torch.no_grad():
       for batch_idx, (data, targets) in enumerate(testloader):
           data, targets = data.to(device), targets.to(device)
           outputs = net(data)
           loss = criterion(outputs, targets)
           # API call to trigger execution
           htcore.mark_step()
           test_loss += loss.item()
           _, predicted = outputs.max(1)
           total += targets.size(0)
           correct += predicted.eq(targets).sum().item()
   test_loss = test_loss/(batch_idx+1)
   test_acc = 100.0*(correct/total)
   print("Testing loss is {} and testing accuracy is {}".format(test_loss,test_acc))
def main():
   epochs = 20
   batch_size = 128
   lr = 0.01
   milestones = [10,15]
   load_path = './data'
   save_path = './checkpoints'
   if(not os.path.exists(save_path)):
       os.makedirs(save_path)
   # Target the Gaudi HPU device
   device = torch.device("hpu")
   # Data
   transform = transforms.Compose([
       transforms.ToTensor(),
   ])
   trainset = torchvision.datasets.MNIST(root=load_path, train=True,
                                           download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
   testset = torchvision.datasets.MNIST(root=load_path, train=False,
                                       download=True, transform=transform)
   testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
   net = SimpleModel()
   net.to(device)
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(net.parameters(), lr=lr,
                       momentum=0.9, weight_decay=5e-4)
   scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1)
   for epoch in range(1, epochs+1):
       print("=====================================================================")
       print("Epoch : {}".format(epoch))
       train(net,criterion,optimizer,trainloader,device)
       test(net,criterion,testloader,device)
       torch.save(net.state_dict(), os.path.join(save_path,'epoch_{}.pth'.format(epoch)))
       scheduler.step()
if __name__ == '__main__':
   main()

Por último, ejecute la aplicación:

python3 example.py

Para salir del entorno virtual, ejecute el siguiente comando:

deactivate

Paso 3. Clonar el repositorio de formación

Clone el repositorio con el código MLperf:

git clone https://github.com/mlcommons/training_results_v3.0

Crear un directorio separado que será utilizado por el contenedor Docker con MLperf:

mkdir -p mlperf

Cambia el directorio:

cd mlperf

Exportemos algunas variables de entorno:

export MLPERF_DIR=/home/usergpu/mlperf

export SCRATCH_DIR=/home/usergpu/mlperf/scratch

export DATASETS_DIR=/home/usergpu/mlperf/datasets

Cree nuevos directorios utilizando las variables creadas:

mkdir -p $MLPERF_DIR/Habana

mkdir -p $SCRATCH_DIR

mkdir -p $DATASETS_DIR

Copia la aplicación de benchmark a $MLPERF_DIR/Habana:

cp -R training_results_v3.0/Intel-HabanaLabs/benchmarks/ $MLPERF_DIR/Habana

Exporta otra variable que almacenará un enlace para descargar la versión deseada del contenedor Docker:

export MLPERF_DOCKER_IMAGE=vault.habana.ai/gaudi-docker-mlperf/ver3.1/pytorch-installer-2.0.1:1.13.99-41

Paso 4. Instalar Docker

Nuestra instancia ejecuta Ubuntu Linux 22.04 LTS y no soporta Docker por defecto. Por lo tanto, antes de descargar y ejecutar contenedores, es necesario instalar el soporte para Docker. Actualicemos la caché de paquetes e instalemos algunos paquetes básicos que necesitaremos más adelante:

sudo apt update && sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Para instalar Docker, necesitas añadir un repositorio de proyecto firmado digitalmente. Descarga la clave de firma digital y añádela al almacén de claves del sistema operativo:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Docker puede ejecutarse en plataformas con diversas arquitecturas. El siguiente comando detectará la arquitectura de su servidor y añadirá la línea del repositorio correspondiente a la lista del gestor de paquetes de APT:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualice la caché de paquetes y las políticas e instale docker-ce (Docker Community Edition):

sudo apt update && apt-cache policy docker-ce && sudo apt install docker-ce

Por último, compruebe que el demonio Docker está en funcionamiento:

sudo systemctl status docker

Paso 5. Ejecutar el contenedor Docker

Vamos a lanzar el contenedor en modo privilegiado utilizando las variables especificadas anteriormente:

sudo docker run --privileged --security-opt seccomp=unconfined \
  --name mlperf3.0 -td                    \
  -v /dev:/dev                            \
  --device=/dev:/dev                      \
  -e LOG_LEVEL_ALL=6                      \
  -v /sys/kernel/debug:/sys/kernel/debug  \
  -v /tmp:/tmp                            \
  -v $MLPERF_DIR:/root/MLPERF             \
  -v $SCRATCH_DIR:/root/scratch           \
  -v $DATASETS_DIR:/root/datasets/        \
  --cap-add=sys_nice --cap-add=SYS_PTRACE \
  --user root --workdir=/root --net=host  \
  --ulimit memlock=-1:-1 $MLPERF_DOCKER_IMAGE

Para mayor comodidad, puedes acceder al terminal dentro del contenedor a través de SSH:

sudo docker exec mlperf3.0 bash -c "service ssh start"

Para abrir un shell de comandos (bash) en la sesión actual, ejecute el siguiente comando:

sudo docker exec -it mlperf3.0 bash

Paso 6. Preparar un conjunto de datos

Para ejecutar las pruebas de implementación de Bert desde MLperf, necesita un conjunto de datos preparado. El método óptimo es generar un conjunto de datos a partir de datos precargados. El repositorio MLperf incluye un script especial, prepare_data.sh, que requiere un conjunto específico de paquetes para funcionar. Naveguemos hasta el siguiente directorio:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/PyTorch

Instale todos los paquetes necesarios utilizando la lista pregenerada y el gestor de paquetes pip:

pip install -r requirements.txt

Establezca la variable PYTORCH_BERT_DATA para indicar al script dónde almacenar los datos:

export PYTORCH_BERT_DATA=/root/datasets/pytorch_bert

Ejecute el script:

bash input_preprocessing/prepare_data.sh -o $PYTORCH_BERT_DATA

El procedimiento de generación es bastante largo y puede durar varias horas. Por favor, sea paciente y no interrumpa el proceso. Si tiene previsto desconectarse de la sesión SSH, se recomienda utilizar la utilidad de pantalla inmediatamente antes de iniciar el contenedor Docker.

Paso 7. Empaquetar el conjunto de datos

El siguiente paso es "cortar" el conjunto de datos en trozos iguales para el posterior lanzamiento de MLperf. Vamos a crear el directorio separado para los datos empaquetados:

mkdir $PYTORCH_BERT_DATA/packed

Ejecute el script de empaquetado:

python3 pack_pretraining_data_pytorch.py \
  --input_dir=$PYTORCH_BERT_DATA/hdf5/training-4320/hdf5_4320_shards_uncompressed \
  --output_dir=$PYTORCH_BERT_DATA/packed \
  --max_predictions_per_seq=76

Paso 8. Ejecute una prueba

Ahora que el conjunto de datos está preparado, es el momento de ejecutar la prueba. Sin embargo, es imposible hacerlo sin una preparación previa. Los autores de la prueba Bert dejaron algunos valores codificados en el script, que interferirán con la ejecución de la prueba. En primer lugar, cambie el nombre del siguiente directorio

mv $PYTORCH_BERT_DATA/packed $PYTORCH_BERT_DATA/packed_data_500_pt

Cambia el directorio:

cd /root/MLPERF/Habana/benchmarks/bert/implementations/HLS-Gaudi2-PT

Como el editor GNU Nano no está instalado dentro del contenedor, debe instalarse por separado. Como alternativa, puede utilizar el editor Vi integrado:

apt update && apt -y install nano

Ahora, edita el script de lanzamiento de la prueba:

nano launch_bert_pytorch.sh

Encuentra la primera línea:

DATA_ROOT=/mnt/weka/data/pytorch/bert_mlperf/packed_data

Sustitúyela por lo siguiente:

DATA_ROOT=/root/datasets/pytorch_bert

Encuentra la segunda línea:

INPUT_DIR=$DATA_ROOT/packed

Sustitúyela por lo siguiente:

INPUT_DIR=$DATA_ROOT/packed_data_500_pt

Guarde el archivo y salga.

El código de la prueba incluye una función limitadora que restringe el gradiente para que no exceda ciertos valores, previniendo un potencial crecimiento exponencial. Por razones que desconocemos, esta función está ausente en la versión de PyTorch utilizada en el contenedor, causando que la prueba termine anormalmente durante la etapa de calentamiento.

Una posible solución podría ser eliminar temporalmente esta función del código en el archivo fastddp.py. Para ello, abra el archivo:

nano ../PyTorch/fastddp.py

Busque y comente las siguientes tres líneas de código utilizando el símbolo # (símbolo shebang) para que tengan este aspecto:

#from habana_frameworks.torch import _hpex_C
#    clip_global_grad_norm = _hpex_C.fused_lamb_norm(grads, 1.0)
#    _fusion_buffer.div_((clip_global_grad_norm * _all_reduce_group_size).to(_fusion_buffer.dtype))

Además, guarda el archivo y sal. Cambia el directorio:

cd ../HLS-Gaudi2-PT

Por último, ejecute el script. Tardará aproximadamente 20 minutos en completarse:

./launch_bert_pytorch.sh

Ver también:

NVIDIA® RTX™ 50: expectativas y realidad

Thu, 23 Jan 2025 13:34:30 +0100

The highlight of CES 2025 was NVIDIA® CEO Jensen Huang’s speech. The revelation of new GPU specifications within minutes caught many off guard. In this article, we’ll examine how expert predictions matched the actual announcements.

Veamos primero la gama. La serie RTX™ 40 se lanzó con 6 modelos, desde la RTX™ 4060 hasta la RTX™ 4090. Muchos esperaban una gama similar para la serie RTX™ 50, pero no ha sido así. En su lugar, la familia RTX™ 50 incluye sólo 4 modelos: RTX™ 5070, RTX™ 5070 Ti, RTX™ 5080 y RTX™ 5090. Es posible que veamos tanto la RTX™ 5050 como la RTX5060 en el futuro, pero ninguna fuente oficial ha verificado aún estas tarjetas gráficas.

Proceso tecnológico

A menudo se dice que la ley de Moore, la observación empírica de que "el número de transistores en un circuito integrado se duplica aproximadamente cada dos años", ya no es relevante para el rendimiento de los chips. Desde 2022, Jensen Huang ha declarado repetidamente que la ley de Moore ha muerto. En su lugar, propuso un nuevo concepto que hace hincapié en el desarrollo simultáneo de la arquitectura, los microchips, las bibliotecas de software y los algoritmos.

Juntos, este cambio nos permite centrarnos en el rendimiento global del sistema en lugar de sólo en el recuento de transistores. El concepto de eficiencia informática ha suscitado continuos debates en la comunidad tecnológica. Aunque las opiniones al respecto varían, está claro que la industria se enfrenta a barreras tanto físicas como económicas para lograr una mayor miniaturización.

Echemos un vistazo a la nueva generación de tecnología de proceso para GPU. En la presentación no se mencionó específicamente, pero todas las tarjetas de la generación anterior se fabricaron con el proceso 4N. The RTX™ 50 series uses a different 4NP process technology. Al mismo tiempo, es importante entender que 4N y 4NP son sólo nombres comerciales. Los transistores siguen teniendo un tamaño de 5 nm.

La tecnología de proceso 4NP mejorada permite principalmente una mayor densidad de transistores en el chip y velocidades de reloj más rápidas. Aunque los expertos predijeron que el RTX™ 50 utilizaría la misma tecnología de proceso que el RTX™ 40, técnicamente se equivocaron, aunque no por mucho, ya que el tamaño de los transistores no varía y TSMC sigue siendo el fabricante.

Número de núcleos

Antes del lanzamiento de la serie RTX™ 50, numerosas filtraciones de datos revelaron las características básicas de la GPU. Los primeros informes internos de julio de 2024 sugerían que el buque insignia contaría con 24.576 núcleos, 192 de trazado de rayos y 768 de tensor. Sin embargo, posteriores filtraciones ajustaron estas cifras a valores más realistas.

La RTX™ 5090 final se comercializó con 21,760 CUDA® cores (frente a los 16.384 de la RTX™ 4090), 170 Ray-tracing cores y 680 Tensor cores. Esto concuerda con la reciente estrategia de la compañía de aumentar el rendimiento no solo mediante un mayor número de transistores, sino a través de una exhaustiva optimización de la arquitectura.

Memoria

El uso de memoria GDDR7 en las nuevas GPU no es ninguna sorpresa. Los expertos del sector habían pronosticado este cambio en 2024, después de que los tres principales fabricantes (Samsung, Micron y SK hynix) presentaran sus prototipos GDDR7 sucesivamente. NVIDIA® fue generosa con la distribución de la memoria: el modelo base RTX™ 5070 incluye 12 GB GDDR7 en un bus 192-bit, mientras que los dos RTX™ 5070 Ti and RTX™ 5080 llevan 16 GB GDDR7 en un bus 256-bit. En el extremo superior, el buque insignia RTX™ 5090 viene con una enorme 32 GB GDDR7 en un bus 512-bit.

Los expertos predijeron inicialmente que el rendimiento máximo de esta configuración de memoria sería de 1,5 Tbps. Sin embargo, la realidad superó estas expectativas, achieving a throughput of 1,7 Tbps. Esta espectacular mejora beneficia principalmente a la capacidad de procesamiento de IA de la GPU, más que al rendimiento en juegos. La combinación de alta capacidad y memoria rápida de la nueva generación es especialmente valiosa para los grandes modelos lingüísticos y las redes neuronales generativas.

Tecnologías

Para jugadores

El trazado de rayos en tiempo real se ha convertido en una de las tecnologías de GPU más revolucionarias, marcando el inicio de la línea RTX™. Para muchos consumidores, esta característica ha sido un factor clave en sus decisiones de compra. En las tarjetas de la serie RTX™ 50, la versión 4 de DLSS (Deep Learning Super Sampling) puede desempeñar un papel igualmente importante. Esta tecnología aumenta significativamente el rendimiento de la GPU en los juegos gracias a su enfoque híbrido de renderizado de fotogramas.

Con DLSS activado, en lugar de renderizar cada fotograma de forma convencional, algunos fotogramas se generan en tiempo real utilizando IA. Mientras que las primeras versiones de esta tecnología sólo podían escalar los fotogramas a resoluciones superiores, DLSS 3 introdujo una capacidad más avanzada: por cada fotograma renderizado de forma convencional, puede generar un fotograma adicional creado por IA.

DLSS 4 generará tres fotogramas creados por la IA por cada fotograma renderizado tradicionalmente. This significantly increases the frame per second (FPS) without putting heavy load on the GPU. La IA analiza el movimiento de los objetos y la escena para garantizar que los fotogramas generados coincidan con los renderizados convencionalmente.

Esto plantea una cuestión importante: ¿cómo gestionar el desfase de entrada? Como la generación de fotogramas lleva tiempo, cada iteración aumenta el tiempo de respuesta. Una imagen fluida con una respuesta lenta a las acciones del jugador puede afectar gravemente a la experiencia de juego. To address this, NVIDIA® has improved their Reflex 2 technology alongside DLSS to minimize latency.

En concreto, se integró Frame Warp en el sistema. Esta tecnología reduce la latencia del juego actualizando los fotogramas renderizados con la última entrada del ratón justo antes de la visualización. Mejora tanto la competición multijugador como la capacidad de respuesta para un solo jugador.

Para los creadores de contenidos

La serie RTX™ 50 no es solo para juegos. Los creadores de contenidos de vídeo encontrarán un valor significativo en estas nuevas GPU. El modelo insignia RTX™ 5090 viene equipado con 3 codificadores y 2 descodificadores, frente a los 2 codificadores y 1 descodificador de la RTX™ 4090. Estos componentes se han mejorado gracias a la colaboración con líderes del sector: Adobe, Blackmagic Design, ByteDance y Wondershare. As a result, the RTX™ 5090 renders video 60% faster than the RTX™ 4090 and four times faster than the RTX™ 3090.

Además de las mejoras de velocidad, también se ha mejorado la calidad. The 9th generation NVENC encoder delivers 5% better quality in HEVC and AV1 tasks. The AV1 Ultra Quality mode achieves better data compression while maintaining image quality, reducing file sizes by 5%. Esto se traduce en un renderizado de vídeo más rápido en la RTX™ 5090, y en una disminución del tiempo entre la edición y la producción.

Conclusión

Si echamos la vista atrás seis meses, las predicciones y expectativas de los expertos resultaron ser demasiado optimistas. A medida que se acercaba la fecha de lanzamiento, se hizo evidente que las nuevas GPU ofrecerían algo más que unidades de cálculo adicionales. The key innovation would be new optimization and AI technologies enhancing existing frame rendering systems.

En CES 2025, durante la presentación de la serie GPU 50, se desveló una nueva era de la IA. Esta visión retrataba un mundo en el que los asistentes digitales y los robots manejan tareas complejas. En su centro habría un ecosistema que combinaría superordenadores para el entrenamiento de la IA, aceleradores de inferencia asequibles para dispositivos de consumo y software versátil que funcionaría tanto localmente como en la nube. Aunque el alcance de este futuro sigue siendo incierto, una cosa está clara: estamos en el umbral de convertir la ciencia ficción en realidad.

LeaderGPU remains committed to providing reliable access to these cutting-edge technologies. Order your first GPU server today and begin transforming your ideas into reality.

Ver también:

Ventajas y desventajas de compartir la GPU

Thu, 23 Jan 2025 13:24:12 +0100

La Ley de Moore sigue vigente desde hace casi medio siglo. Los chips procesadores siguen incorporando más transistores y las tecnologías avanzan día a día. A medida que evoluciona la tecnología, también lo hace nuestro enfoque de la informática. El auge de determinadas tareas informáticas ha influido significativamente en el desarrollo del hardware. Por ejemplo, los dispositivos diseñados originalmente para el procesamiento de gráficos son ahora herramientas clave y asequibles para las redes neuronales modernas.

La gestión de los recursos informáticos también se ha transformado. Ahora, los servicios masivos rara vez utilizan mainframes, como hacían en los años setenta y ochenta. En su lugar, prefieren los servicios en la nube o construir su propia infraestructura. Este cambio ha modificado las demandas de los clientes, que se centran en un escalado rápido y a la carta y en maximizar el uso de los recursos informáticos asignados.

Las tecnologías de virtualización y contenedorización surgieron como soluciones. Las aplicaciones se empaquetan ahora en contenedores con todas las bibliotecas necesarias, lo que simplifica la implantación y el escalado. Sin embargo, la gestión manual se volvió impracticable a medida que el número de contenedores se disparaba a miles. Orquestadores especializados como Kubernetes se encargan ahora de la gestión y el escalado eficaces. Estas herramientas se han convertido en una parte esencial de cualquier infraestructura de TI moderna.

Virtualización de servidores

Al mismo tiempo, las tecnologías de virtualización evolucionaron, permitiendo la creación de entornos aislados dentro de un único servidor físico. Las máquinas virtuales se comportan de forma idéntica a los servidores físicos normales, lo que permite utilizar herramientas de gestión estándar. Dependiendo del hipervisor, a menudo se incluye una API especializada que facilita la automatización de procedimientos rutinarios.

Sin embargo, esta flexibilidad viene acompañada de una menor seguridad. Los atacantes han pasado de centrarse en las máquinas virtuales individuales a explotar las vulnerabilidades del hipervisor. Al hacerse con el control de un hipervisor, los atacantes pueden acceder a voluntad a todas las máquinas virtuales asociadas. A pesar de las continuas mejoras de seguridad, los hipervisores modernos siguen siendo objetivos atractivos.

La virtualización tradicional aborda dos cuestiones clave. Primera cuestión: garantiza el aislamiento de las máquinas virtuales entre sí. Las soluciones bare-metal evitan este problema, ya que los clientes alquilan servidores físicos enteros bajo su control. Pero en el caso de las máquinas virtuales, el aislamiento se basa en el software a nivel del hipervisor. Un error de código o un fallo aleatorio pueden comprometer este aislamiento, con el consiguiente riesgo de fuga o corrupción de datos.

El segundo problema se refiere a la gestión de recursos. Aunque es posible garantizar la asignación de recursos a máquinas virtuales específicas, la gestión de numerosas máquinas plantea un dilema. Los recursos pueden infrautilizarse, lo que se traduce en un menor número de máquinas virtuales por servidor físico. Este escenario no es rentable para la infraestructura y conduce inevitablemente a un aumento de los precios.

Otra alternativa es utilizar mecanismos automáticos de gestión de recursos. Aunque a una máquina virtual se le asignan características específicas declaradas, en realidad sólo se le proporciona el mínimo necesario dentro de estos límites. Si la máquina necesita más tiempo de procesador o RAM, el hipervisor intentará proporcionárselo, pero no puede garantizarlo. Esta situación es similar al overbooking de los aviones, cuando las aerolíneas venden más billetes de los asientos disponibles.

La lógica es idéntica. Si las estadísticas muestran que un 10% de los pasajeros no llegan a tiempo a su vuelo, las aerolíneas pueden vender un 10% más de billetes con un riesgo mínimo. Si llegan todos los pasajeros, algunos no cabrán a bordo. La aerolínea se enfrentará a consecuencias menores en forma de indemnización, pero probablemente seguirá con esta práctica.

Muchos proveedores de infraestructuras emplean una estrategia similar. Algunos son transparentes al respecto, declarando que no garantizan la disponibilidad constante de recursos informáticos pero ofrecen precios significativamente reducidos. Otros utilizan mecanismos similares sin anunciarlo. Apuestan a que no todos los clientes utilizarán sistemáticamente el 100% de los recursos de sus servidores y, aunque algunos lo hagan, serán minoría. Mientras tanto, los recursos ociosos generan beneficios.

En este contexto, las soluciones bare-metal tienen una ventaja. Garantizan que los recursos asignados son totalmente gestionados por el cliente y no compartidos con otros usuarios del proveedor de infraestructura. Esto elimina los escenarios en los que la alta carga de un usuario de un servidor vecino repercute negativamente en el rendimiento.

Virtualización de GPU

La virtualización clásica se enfrenta inevitablemente al reto de emular dispositivos físicos. Para reducir los gastos generales, se han desarrollado tecnologías especiales que permiten a las máquinas virtuales acceder directamente a los dispositivos físicos del servidor. Este enfoque funciona bien en muchos casos, pero cuando se aplica a los procesadores gráficos, crea limitaciones inmediatas. Por ejemplo, si un servidor tiene instaladas 8 GPU, sólo 8 máquinas virtuales pueden acceder a ellas.

Para superar esta limitación, se inventó la tecnología vGPU. Divide una GPU en varias lógicas, que pueden asignarse a máquinas virtuales. Esto permite que cada máquina virtual tenga su "trozo de tarta", y su número total ya no está limitado por el número de tarjetas de vídeo instaladas en el servidor.

Las GPU virtuales se utilizan con mayor frecuencia cuando se construye VDI (Virtual Desktop Infrastructure) en áreas en las que las máquinas virtuales requieren aceleración 3D. Por ejemplo, un puesto de trabajo virtual para un diseñador o planificador suele implicar procesamiento gráfico. La mayoría de las aplicaciones de estos campos realizan cálculos tanto en el procesador central como en la GPU. Este enfoque híbrido aumenta significativamente la productividad y garantiza un uso óptimo de los recursos de cálculo disponibles.

Sin embargo, esta tecnología presenta varios inconvenientes. No es compatible con todas las GPU y sólo está disponible en el segmento de servidores. La compatibilidad también depende de la versión instalada del sistema operativo y del controlador de la GPU. vGPU tiene un mecanismo de licencia independiente, lo que incrementa sustancialmente los costes de las operaciones. Además, sus componentes de software pueden servir potencialmente como vectores de ataque.

Recientemente, se ha publicado información sobre ocho vulnerabilidades que afectan a todos los usuarios de GPU NVIDIA®. Se identificaron seis vulnerabilidades en los controladores de la GPU y dos en el software vGPU. Estos problemas se solucionaron rápidamente, pero sirven para recordar que los mecanismos de aislamiento de estos sistemas no son impecables. La supervisión constante y la instalación oportuna de actualizaciones siguen siendo las principales formas de garantizar la seguridad.

Cuando se construye una infraestructura para procesar datos confidenciales y sensibles de los usuarios, cualquier virtualización se convierte en un factor de riesgo potencial. En tales casos, un enfoque bare-metal puede ofrecer mejor calidad y seguridad.

Conclusión

Construir una infraestructura informática siempre requiere una evaluación de riesgos. Entre las preguntas clave que hay que plantearse se incluyen: ¿Están protegidos de forma segura los datos de los clientes? ¿Crean las tecnologías elegidas vectores de ataque adicionales? ¿Cómo se pueden aislar y eliminar las posibles vulnerabilidades? Responder a estas preguntas ayuda a tomar decisiones informadas y a protegerse contra problemas futuros.

En LeaderGPU, hemos llegado a una conclusión clara: actualmente, la tecnología bare-metal es superior a la hora de garantizar la seguridad de los datos de los usuarios y, al mismo tiempo, constituye una base excelente para crear una nube bare-metal. Este enfoque permite a nuestros clientes mantener la flexibilidad sin asumir los riesgos añadidos asociados a la virtualización de la GPU.

Ver también:

¿Qué es la destilación de conocimientos?

Thu, 23 Jan 2025 13:21:29 +0100

Los grandes modelos lingüísticos (LLM) se han convertido en parte integrante de nuestras vidas gracias a sus capacidades únicas. Comprenden el contexto y generan textos coherentes y extensos basados en él. Pueden procesar y responder en cualquier idioma teniendo en cuenta los matices culturales de cada uno.

Los LLM destacan en la resolución de problemas complejos, la programación, el mantenimiento de conversaciones y mucho más. Esta versatilidad se debe a que procesan grandes cantidades de datos de entrenamiento, de ahí el término "grandes". Estos modelos pueden contener decenas o cientos de miles de millones de parámetros, lo que hace que consuman muchos recursos para su uso cotidiano.

El entrenamiento es el proceso más exigente. Los modelos de redes neuronales aprenden procesando enormes conjuntos de datos, ajustando sus "pesos" internos para formar conexiones estables entre neuronas. Estas conexiones almacenan conocimientos que la red neuronal entrenada puede utilizar posteriormente en dispositivos finales.

Sin embargo, la mayoría de los dispositivos finales carecen de la potencia de cálculo necesaria para ejecutar estos modelos. Por ejemplo, ejecutar la versión completa de Llama 2 (70B parámetros) requiere una GPU con 48 GB de memoria de vídeo, hardware que pocos usuarios tienen en casa, y menos aún en dispositivos móviles.

En consecuencia, la mayoría de las redes neuronales modernas funcionan en infraestructuras en la nube y no en dispositivos portátiles, que acceden a ellas a través de API. Aun así, los fabricantes de dispositivos están avanzando en dos sentidos: equipando los dispositivos con unidades de cálculo especializadas, como las NPU, y desarrollando métodos para mejorar el rendimiento de los modelos compactos de redes neuronales.

Reducir el tamaño

Cortar el exceso

La cuantización es el primer método, y el más eficaz, para reducir el tamaño de una red neuronal. Los pesos de las redes neuronales suelen utilizar números de 32 bits en coma flotante, pero podemos reducirlos cambiando este formato. Utilizar valores de 8 bits (o incluso unos binarios en algunos casos) puede reducir diez veces el tamaño de la red, aunque esto disminuye significativamente la precisión de la respuesta.

La poda es otro método que elimina las conexiones sin importancia de la red neuronal. Este proceso funciona tanto durante el entrenamiento como con las redes terminadas. Además de las conexiones, la poda puede eliminar neuronas o capas enteras. Esta reducción de parámetros y conexiones reduce los requisitos de memoria.

La descomposición matricial o tensorial es la tercera técnica habitual de reducción de tamaño. La descomposición de una matriz grande en un producto de tres matrices más pequeñas reduce los parámetros totales manteniendo la calidad. Esto puede reducir el tamaño de la red decenas de veces. La descomposición tensorial ofrece resultados aún mejores, aunque requiere más hiperparámetros.

Aunque estos métodos reducen eficazmente el tamaño, todos se enfrentan al reto de la pérdida de calidad. Los modelos comprimidos de gran tamaño superan a sus homólogos más pequeños sin comprimir, pero cada compresión corre el riesgo de reducir la precisión de la respuesta. La destilación del conocimiento representa un intento interesante de equilibrar la calidad con el tamaño.

Intentémoslo juntos

La destilación de conocimientos se explica mejor mediante la analogía de un alumno y un profesor. Mientras los alumnos aprenden, los profesores enseñan y también actualizan continuamente sus conocimientos. Cuando ambos se encuentran con nuevos conocimientos, el profesor tiene ventaja, puede recurrir a sus amplios conocimientos de otras áreas, mientras que el alumno carece aún de esta base.

Este principio se aplica a las redes neuronales. Cuando se entrenan dos redes neuronales del mismo tipo pero de distinto tamaño con datos idénticos, la red más grande suele obtener mejores resultados. Su mayor capacidad de "conocimiento" permite respuestas más precisas que su homóloga más pequeña. Esto plantea una posibilidad interesante: ¿por qué no entrenar la red más pequeña no sólo con el conjunto de datos, sino también con los resultados más precisos de la red más grande?

Este proceso es la destilación del conocimiento: una forma de aprendizaje supervisado en el que un modelo más pequeño aprende a replicar las predicciones de uno más grande. Aunque esta técnica ayuda a compensar la pérdida de calidad al reducir el tamaño de la red neuronal, requiere más recursos informáticos y tiempo de entrenamiento.

Software y lógica

Una vez aclarados los fundamentos teóricos, examinemos el proceso desde una perspectiva técnica. Empezaremos con las herramientas de software que pueden guiarle a través de las etapas de formación y destilación de conocimientos.

Python, junto con la biblioteca TorchTune del ecosistema PyTorch, ofrece el enfoque más sencillo para estudiar y afinar grandes modelos lingüísticos. He aquí cómo funciona la aplicación:

Se cargan dos modelos: un modelo completo (profesor) y un modelo reducido (alumno). Durante cada iteración de entrenamiento, el modelo del profesor genera predicciones de alta temperatura, mientras que el modelo del alumno procesa el conjunto de datos para hacer sus propias predicciones.

Los valores de salida brutos (logits) de ambos modelos se evalúan mediante una función de pérdida (una medida numérica de cuánto se desvía una predicción del valor correcto). A continuación, se aplican ajustes de peso al modelo del alumno mediante retropropagación. Esto permite al modelo más pequeño aprender y replicar las predicciones del modelo maestro.

El principal archivo de configuración del código de la aplicación se denomina receta. Este archivo almacena todos los parámetros y ajustes de destilación, lo que hace que los experimentos sean reproducibles y permite a los investigadores hacer un seguimiento de cómo influyen los distintos parámetros en el resultado final.

A la hora de seleccionar los valores de los parámetros y el número de iteraciones, es fundamental mantener el equilibrio. Un modelo que se destila demasiado puede perder su capacidad de reconocer detalles sutiles y el contexto, recurriendo por defecto a respuestas planificadas. Aunque el equilibrio perfecto es casi imposible de conseguir, una supervisión cuidadosa del proceso de destilación puede mejorar sustancialmente la calidad de la predicción incluso de los modelos de redes neuronales más modestos.

También merece la pena prestar atención a la supervisión durante el proceso de entrenamiento. Esto ayudará a identificar los problemas a tiempo y a corregirlos con prontitud. Para ello, puede utilizar la herramienta TensorBoard. Se integra perfectamente en los proyectos PyTorch y permite evaluar visualmente muchas métricas, como la precisión y las pérdidas. Además, permite construir un gráfico del modelo, hacer un seguimiento del uso de memoria y del tiempo de ejecución de las operaciones.

Conclusión

La destilación del conocimiento es un método eficaz para optimizar las redes neuronales con el fin de mejorar los modelos compactos. Funciona mejor cuando es esencial equilibrar el rendimiento con la calidad de la respuesta.

Aunque la destilación de conocimientos requiere un seguimiento cuidadoso, sus resultados pueden ser notables. Los modelos se hacen mucho más pequeños manteniendo la calidad de la predicción, y funcionan mejor con menos recursos informáticos.

Cuando se planifica bien con los parámetros adecuados, la destilación de conocimientos sirve como herramienta clave para crear redes neuronales compactas sin sacrificar la calidad.

Ver también:

AudioCraft de MetaAI: crear música por descripción

Wed, 22 Jan 2025 15:51:35 +0100

Las redes neuronales generativas modernas son cada vez más inteligentes. Escriben historias, entablan conversaciones con la gente y crean imágenes ultrarrealistas. Ahora, pueden producir sencillas pistas de música sin necesidad de artistas profesionales. Este futuro ya es una realidad. Era de esperar, ya que las armonías y ritmos musicales tienen sus raíces en principios matemáticos.

Meta ha demostrado su compromiso con el mundo del software de código abierto. Han puesto a disposición del público tres modelos de redes neuronales que permiten crear sonidos y música a partir de descripciones de texto:

MusicGen - genera música a partir de texto.
AudioGen - genera audio a partir de texto.
EnCodec - compresor neural de audio de alta calidad.

MusicGen fue entrenado en 20.000 horas de música. Puede utilizarlo localmente a través de servidores LeaderGPU dedicados como plataforma.

Instalación estándar

Actualice el repositorio de caché de paquetes:

sudo apt update && sudo apt -y upgrade

Instale el gestor de paquetes de Python, pip, y las bibliotecas ffmpeg:

sudo apt -y install python3-pip ffmpeg

Instala torch 2.0 o más reciente usando pip:

pip install 'torch>=2.0'

El siguiente comando instala automáticamente audiocraft y todas las dependencias necesarias:

pip install -U audiocraft

Vamos a escribir una sencilla aplicación Python, utilizando el gran modelo MusicGen pre-entrenado con 3.3B parámetros:

nano generate.py

from audiocraft.models import MusicGen
from audiocraft.data.audio import audio_write
model = MusicGen.get_pretrained("facebook/musicgen-large")
model.set_generation_params(duration=30)  # generate a 30 seconds sample.
descriptions = ["rock solo"]
wav = model.generate(descriptions)  # generates sample.
for idx, one_wav in enumerate(wav):
    # Will save under {idx}.wav, with loudness normalization at -14 db LUFS.
    audio_write(f'{idx}', one_wav.cpu(), model.sample_rate, strategy="loudness")

Ejecuta la aplicación creada:

python3 generate.py

Después de unos segundos, el archivo generado (0.wav) aparecerá en el directorio.

Café Vampir 3

Clonar un repositorio de proyecto:

git clone https://github.com/CoffeeVampir3/audiocraft-webui.git

Abre el directorio clonado:

cd audiocraft-webui

Ejecuta el comando que prepara tu sistema e instala todos los paquetes necesarios:

pip install -r requirements.txt

A continuación, ejecute el servidor Coffee Vampire 3 con el siguiente comando:

python3 webui.py

Coffee Vampire 3 utiliza Flask como framework. Por defecto, se ejecuta en localhost con el puerto 5000. Si desea acceso remoto, por favor utilice la función de redirección de puertos en su cliente SSH. De lo contrario, puede organizar la conexión VPN al servidor.

Atención. Se trata de una acción potencialmente peligrosa; utilícela bajo su propia responsabilidad:

nano webui.py

Desplácese hasta el final y sustituya socketio.run(app) por socketio.run(app, host=’0.0.0.0’, port=5000)

Guarde el archivo y ejecute el servidor utilizando el comando anterior. Esto permite el acceso al servidor desde la Internet pública sin ningún tipo de autenticación.

No olvides disable AdBlock software, ya que puede bloquear el reproductor de música a la derecha de la página web. Puedes empezar entrando en el prompt y confirmando con el botón Submit:

TTS Generation WebUI

Paso 1. Controladores

Actualice el repositorio de caché de paquetes:

sudo apt update && sudo apt -y upgrade

Instale los controladores NVIDIA® usando el instalador automático o nuestra guía Instalar controladores NVIDIA® en Linux:

sudo ubuntu-drivers autoinstall

Reinicie el servidor:

sudo shutdown -r now

Paso 2. Docker

El siguiente paso es instalar Docker. Vamos a instalar algunos paquetes que hay que añadir al repositorio de Docker:

sudo apt -y install apt-transport-https curl gnupg-agent ca-certificates software-properties-common

Descarga la clave GPG de Docker y guárdala:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Añade el repositorio:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Instale Docker CE (Community Edition) con CLI y el runtime containerd:

sudo apt -y install docker-ce docker-ce-cli containerd.io

Añade el usuario actual al grupo docker:

sudo usermod -aG docker $USER

Aplicar los cambios sin el procedimiento de cierre de sesión e inicio de sesión:

newgrp docker

Paso 3. Paso de GPU

Vamos a habilitar NVIDIA® GPU passthrough en Docker. El siguiente comando lee la versión actual del sistema operativo en la variable de distribución, que podemos utilizar en el siguiente paso:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)

Descarga la clave GPG del repositorio de NVIDIA® y guárdala:

curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -

Descarga la lista de repositorios de NVIDIA® y almacénala para utilizarla en el gestor de paquetes estándar de APT:

curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

Actualiza el repositorio de caché de paquetes e instala el kit de herramientas GPU passthrough:

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit

Reinicia el demonio Docker:

sudo systemctl restart docker

Paso 4. WebUI

Descargue el archivo del repositorio:

wget https://github.com/rsxdalv/tts-generation-webui/archive/refs/heads/main.zip

Descomprímelo:

unzip main.zip

Abre el directorio del proyecto:

cd tts-generation-webui-main

Empieza a construir la imagen:

docker build -t rsxdalv/tts-generation-webui .

Ejecuta el contenedor creado:

docker compose up -d

Ahora puede abrir http://[server_ip]:7860, escriba su consulta, seleccione el modelo necesario y pulse el botón Generate:

El sistema descarga automáticamente el modelo seleccionado durante la primera generación. ¡Que aproveche!

Ver también:

Cómo supervisar la aplicación LangFlow

Wed, 22 Jan 2025 15:14:55 +0100

En nuestro artículo Langflow, creador de aplicaciones de IA de bajo código, exploramos cómo empezar a utilizar el entorno de programación visual de este creador de aplicaciones de IA de bajo código. Permite a cualquier persona, incluso sin conocimientos de programación, crear aplicaciones basadas en grandes modelos de redes neuronales. Podrían ser chatbots de IA o aplicaciones de procesamiento de documentos que pueden analizar y resumir contenido.

Langflow utiliza un enfoque de bloques de construcción en el que los usuarios conectan componentes prefabricados para crear la aplicación deseada. Sin embargo, a menudo surgen dos retos clave: la resolución de problemas cuando las redes neuronales se comportan de forma inesperada y la gestión de los costes. Las redes neuronales requieren importantes recursos informáticos, por lo que es esencial controlar y predecir los gastos de infraestructura.

LangWatch aborda ambos retos. Esta herramienta especializada ayuda a los desarrolladores de Langflow a supervisar las solicitudes de los usuarios, realizar un seguimiento de los costes y detectar anomalías, como cuando las aplicaciones se utilizan de forma no deseada.

Esta herramienta se diseñó originalmente como un servicio, pero puede desplegarse en cualquier servidor, incluso localmente. Se integra con la mayoría de los proveedores de LLM, ya sean basados en la nube o locales. Al ser de código abierto, LangWatch puede adaptarse a casi cualquier proyecto: añadiendo nuevas funciones o conectándose con sistemas internos.

LangWatch permite configurar alertas cuando determinadas métricas superan los umbrales definidos. Esto le ayuda a detectar rápidamente aumentos inesperados en los costes de las solicitudes o retrasos inusuales en las respuestas. La detección precoz ayuda a evitar gastos imprevistos y posibles ataques al servicio.

Para los investigadores de redes neuronales, esta aplicación permite tanto la supervisión como la optimización de las peticiones habituales de los usuarios. También proporciona herramientas para evaluar la calidad de respuesta del modelo y realizar ajustes cuando sea necesario.

Inicio rápido

Preparación del sistema

Al igual que Langflow, la forma más sencilla de ejecutar la aplicación es a través de un contenedor Docker. Antes de instalar LangWatch, necesitarás instalar Docker Engine en tu servidor. En primer lugar, actualiza tu caché de paquetes y los paquetes a sus últimas versiones:

sudo apt update && sudo apt -y upgrade

Instala los paquetes adicionales requeridos por Docker:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Descarga la clave GPG para añadir el repositorio oficial de Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Añade el repositorio a APT utilizando la clave que descargaste e instalaste anteriormente:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualice la lista de paquetes:

sudo apt update

Para asegurarte de que Docker se instalará desde el repositorio recién añadido y no desde el del sistema, puedes ejecutar el siguiente comando:

apt-cache policy docker-ce

Instalar motor Docker:

sudo apt install docker-ce

Compruebe que Docker se ha instalado correctamente y que el demonio correspondiente se está ejecutando y se encuentra en el estado active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
    Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
    Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
      Docs: https://docs.docker.com
  Main PID: 1842 (dockerd)
     Tasks: 29
    Memory: 1.8G
       CPU: 3min 15.715s
    CGroup: /system.slice/docker.service

Construir y ejecutar

Con el motor Docker instalado y en ejecución, puede descargar el repositorio de la aplicación LangWatch:

git clone https://github.com/langwatch/langwatch

La aplicación incluye un archivo de configuración de ejemplo con variables de entorno. Copie este archivo para que la utilidad de creación de imágenes pueda procesarlo:

cp langwatch/.env.example langwatch/.env

Ahora estás listo para el primer lanzamiento:

sudo docker compose up --build

El sistema tardará un momento en descargar todas las capas contenedoras necesarias para LangWatch. Una vez completado, verás un mensaje de consola indicando que la aplicación está disponible en:

http://[LeaderGPU_IP_address]:3000

Vaya a esta página en su navegador, donde se le pedirá que cree una cuenta de usuario:

A diferencia de Langflow, este sistema tiene la autenticación activada por defecto. Después de iniciar sesión, tendrá que configurar el sistema para recopilar datos de su servidor Langflow.

Integración con Langflow

LangWatch necesita una fuente de datos para funcionar. El servidor escucha en el puerto 3000 y utiliza una API RESTful, que autentica los datos entrantes a través de una clave de API generada automáticamente.

Para habilitar la transferencia de datos, tendrá que establecer dos variables en los archivos de configuración de Langflow: LANGWATCH_ENDPOINT y LANGWATCH_API_KEY. En primer lugar, establezca una conexión SSH a su servidor Langflow (que debe estar fuera de línea durante este proceso).

Navegue hasta el directorio con la configuración de ejemplo para Docker:

cd langflow/docker_example

Abra el archivo de configuración para editarlo:

nano docker-compose.yml

En la sección "Entorno:", añada las siguientes variables (sin corchetes [] ni comillas):

- LANGWATCH_API_KEY= [YOUR_API_KEY]
- LANGWATCH_ENDPOINT=http://[IP_ADDRESS]:3000

El archivo YML requiere un formato específico. Siga estas dos reglas clave:

Utilice espacios (2 ó 4) para la sangría, nunca tabuladores.
Mantenga una estructura jerárquica adecuada con una sangría coherente.

Guarde el archivo con Ctrl + O y salga del editor con Ctrl + X, Langflow ya está listo para ejecutarse:

sudo docker compose up

Después del lanzamiento, verifique que todo funciona correctamente. Cree un nuevo proyecto o abra uno existente, luego inicie un diálogo a través de Playground. Langflow enviará automáticamente datos a LangWatch para su monitorización, que podrá ver en la interfaz web.

En la sección de verificación de la integración, aparece una marca de verificación en el elemento "Sincronizar el primer mensaje". Esto indica que los datos de Langflow están fluyendo con éxito a LangWatch, confirmando que su configuración es correcta. Examinemos que aparece en la sección Messages:

La sección Mensajes muestra los datos introducidos en la aplicación, los parámetros utilizados para la generación de la respuesta y la propia respuesta de la red neuronal. Puede evaluar la calidad de la respuesta y utilizar varios filtros para ordenar los datos, incluso con cientos o miles de mensajes.

Tras esta configuración inicial, explora sistemáticamente las funciones de la aplicación. En la sección Evaluations, puedes configurar algoritmos de verificación de diálogos para la moderación de diálogos o el reconocimiento de datos, como PII Detection. Esta función escanea las entradas en busca de información sensible, como números de la seguridad social o números de teléfono.

La aplicación ofrece opciones tanto locales como basadas en la nube a través de proveedores como Azure o Cloudflare. Para utilizar las funciones en la nube, necesitarás cuentas en estos servicios, junto con sus direcciones de punto final y claves API. Ten en cuenta que se trata de proveedores externos, así que comprueba directamente los costes de sus servicios.

Para las opciones locales, la aplicación cuenta con sofisticadas funciones RAG (Retrieval-augmented generation). Puede medir la precisión y relevancia de los contenidos generados por RAG y utilizar las estadísticas recopiladas para optimizar el sistema RAG y obtener respuestas más precisas de la red neuronal.

Ver también:

Creador de aplicaciones de inteligencia artificial de código reducido Langflow

Wed, 22 Jan 2025 15:11:30 +0100

El desarrollo de software ha evolucionado espectacularmente en los últimos años. Los programadores modernos tienen ahora acceso a cientos de lenguajes y marcos de programación. Más allá de los enfoques imperativos y declarativos tradicionales, está surgiendo un nuevo y apasionante método de creación de aplicaciones. Este enfoque innovador aprovecha el poder de las redes neuronales, abriendo fantásticas posibilidades a los desarrolladores.

La gente se ha acostumbrado a que los asistentes de IA de los IDE ayuden a autocompletar el código y a que las redes neuronales modernas generen fácilmente código para juegos sencillos en Python. Sin embargo, están surgiendo nuevas herramientas híbridas que podrían revolucionar el panorama del desarrollo. Una de ellas es Langflow.

Langflow sirve para múltiples propósitos. Para los desarrolladores profesionales, ofrece un mejor control de sistemas complejos como las redes neuronales. Para quienes no están familiarizados con la programación, permite crear aplicaciones sencillas pero prácticas. Estos objetivos se logran a través de diferentes medios, que exploraremos con más detalle.

Redes neuronales

El concepto de red neuronal puede simplificarse para los usuarios. Imagine una caja negra que recibe datos de entrada y parámetros que influyen en el resultado final. Esta caja procesa la entrada utilizando algoritmos complejos, a menudo denominados "mágicos", y produce datos de salida que pueden presentarse al usuario.

El funcionamiento interno de esta caja negra varía en función del diseño de la red neuronal y de los datos de entrenamiento. Es fundamental comprender que los desarrolladores y los usuarios nunca pueden alcanzar una certeza del 100% en los resultados. A diferencia de la programación tradicional, en la que 2 + 2 siempre es igual a 4, una red neuronal puede dar esta respuesta con un 99% de certeza, manteniendo siempre un margen de error.

El control sobre el proceso de "pensamiento" de una red neuronal es indirecto. Sólo podemos ajustar ciertos parámetros, como la "temperatura". Este parámetro determina lo creativa o limitada que puede ser la red neuronal en su planteamiento. Un valor bajo de temperatura limita la red a un enfoque más formal y estructurado de las tareas y soluciones. Por el contrario, los valores altos de temperatura conceden más libertad a la red, lo que puede llevarla a basarse en hechos menos fiables o incluso a crear información ficticia.

Este ejemplo ilustra cómo los usuarios pueden influir en el resultado final. Para la programación tradicional, esta incertidumbre plantea un reto importante: los errores pueden aparecer de forma inesperada y los resultados concretos se vuelven impredecibles. Sin embargo, esta imprevisibilidad es sobre todo un problema para los ordenadores, no para los humanos, que pueden adaptarse a resultados variables e interpretarlos.

Si la salida de una red neuronal está destinada a un ser humano, la redacción específica utilizada para describirla suele ser menos importante. Dado el contexto, las personas pueden interpretar correctamente diversos resultados desde la perspectiva de la máquina. Mientras que conceptos como "valor positivo", "resultado obtenido" o "decisión positiva" pueden significar más o menos lo mismo para una persona, la programación tradicional tendría problemas con esta flexibilidad. Tendría que tener en cuenta todas las posibles variaciones de respuesta, lo cual es casi imposible.

En cambio, si el procesamiento posterior se transfiere a otra red neuronal, ésta puede entender y procesar correctamente el resultado obtenido. A partir de ahí, puede llegar a su propia conclusión con un cierto grado de confianza, como ya se ha dicho.

Código bajo

La mayoría de los lenguajes de programación implican escribir código. Los programadores crean mentalmente la lógica de cada parte de una aplicación y luego la describen mediante expresiones específicas del lenguaje. Este proceso forma un algoritmo: una secuencia Clara™ de acciones que conducen a un resultado específico y predeterminado. Es una tarea compleja que requiere un gran esfuerzo mental y un profundo conocimiento de las posibilidades del lenguaje.

Sin embargo, no es necesario reinventar la rueda. Muchos de los problemas a los que se enfrentan los desarrolladores modernos ya se han resuelto de diversas maneras. A menudo se pueden encontrar fragmentos de código relevantes en StackOverflow. La programación moderna puede compararse con el ensamblaje de un todo a partir de piezas de diferentes juegos de construcción. El sistema Lego ofrece un modelo de éxito, al haber estandarizado diferentes conjuntos de piezas para garantizar la compatibilidad.

El método de programación de bajo código sigue un principio similar. Se modifican varias piezas de código para que encajen a la perfección y se presentan a los desarrolladores como bloques listos para usar. Cada bloque puede tener entradas y salidas de datos. La documentación especifica la tarea que resuelve cada tipo de bloque y el formato en que acepta o emite datos.

Al conectar estos bloques en una secuencia específica, los desarrolladores pueden formar el algoritmo de una aplicación y visualizar claramente su lógica operativa. Quizá el ejemplo más conocido de este método de programación sea el de los gráficos de tortuga, utilizado habitualmente en entornos educativos para introducir conceptos de programación y desarrollar el pensamiento algorítmico.

La esencia de este método es simple: dibujar imágenes en la pantalla utilizando una tortuga virtual que deja un rastro mientras se arrastra por el lienzo. Utilizando bloques prefabricados, como mover un número determinado de píxeles, girar en ángulos específicos o subir y bajar el lápiz, los desarrolladores pueden crear programas que dibujen las imágenes que deseen. La creación de aplicaciones mediante un constructor de bajo código es similar a los gráficos de tortuga, pero permite a los usuarios resolver una amplia gama de problemas, no sólo dibujar sobre un lienzo.

Este método se implementó mejor en la herramienta de programación Node-RED de IBM. Se desarrolló como medio universal para garantizar el funcionamiento conjunto de diversos dispositivos, servicios en línea y API. El equivalente de los fragmentos de código eran nodos de la biblioteca estándar (paleta).

Las capacidades de Node-RED pueden ampliarse instalando complementos o creando nodos personalizados que realicen acciones de datos específicas. Los desarrolladores colocan los nodos de la paleta en el escritorio y establecen relaciones entre ellos. Este proceso crea la lógica de la aplicación, y la visualización ayuda a mantener la claridad.

Si a este concepto se añaden las redes neuronales, se obtiene un sistema fascinante. En lugar de procesar los datos con fórmulas matemáticas específicas, puedes introducirlos en una red neuronal y especificar la salida deseada. Aunque los datos de entrada pueden variar ligeramente cada vez, los resultados siguen siendo aptos para ser interpretados por humanos u otras redes neuronales.

Generación Aumentada de Recuperación (RAG)

La precisión de los datos en los grandes modelos lingüísticos es una preocupación acuciante. Estos modelos se basan únicamente en los conocimientos adquiridos durante el entrenamiento, que depende de la relevancia de los conjuntos de datos utilizados. En consecuencia, los modelos lingüísticos de gran tamaño pueden carecer de suficientes datos pertinentes, lo que puede dar lugar a resultados incorrectos.

Para resolver este problema, se necesitan métodos de actualización de datos. Permitir que las redes neuronales extraigan contexto de fuentes adicionales, como páginas web, puede mejorar notablemente la calidad de las respuestas. Así es como funciona precisamente RAG (Retrieval-Augmented Generation). Los datos adicionales se convierten en representaciones vectoriales y se almacenan en una base de datos.

En funcionamiento, los modelos de redes neuronales pueden convertir las peticiones de los usuarios en representaciones vectoriales y compararlas con las almacenadas en la base de datos. Cuando se encuentran vectores similares, se extraen los datos y se utilizan para formar una respuesta. Las bases de datos vectoriales son lo bastante rápidas para soportar este esquema en tiempo real.

Para que este sistema funcione correctamente, debe establecerse una interacción entre el usuario, el modelo de red neuronal, las fuentes de datos externas y la base de datos vectorial. Langflow simplifica esta configuración con su componente visual: los usuarios simplemente construyen bloques estándar y los "enlazan", creando una ruta para el flujo de datos.

El primer paso consiste en poblar la base de datos vectorial con las fuentes pertinentes. Éstas pueden incluir archivos de un ordenador local o páginas web de Internet. He aquí un sencillo ejemplo de carga de datos en la base de datos:

Ahora que tenemos una base de datos vectorial además del LLM entrenado, podemos incorporarla al esquema general. Cuando un usuario envía una petición en el chat, éste forma simultáneamente una petición y consulta la base de datos de vectores. Si se encuentran vectores similares, los datos extraídos se analizan y se añaden como contexto a la solicitud formada. A continuación, el sistema envía una petición a la red neuronal y emite la respuesta recibida al usuario en el chat.

Aunque el ejemplo menciona servicios en la nube como OpenAI y AstraDB, puedes utilizar cualquier servicio compatible, incluidos los desplegados localmente en servidores LeaderGPU. Si no encuentras la integración que necesitas en la lista de bloques disponibles, puedes escribirla tú mismo o añadir una creada por otra persona.

Inicio rápido

Preparación del sistema

La forma más sencilla de desplegar Langflow es dentro de un contenedor Docker. Para configurar el servidor, comience por instalar Docker Engine. A continuación, actualice tanto la caché de paquetes como los paquetes a sus últimas versiones:

sudo apt update && sudo apt -y upgrade

Instale los paquetes adicionales requeridos por Docker:

sudo apt -y install apt-transport-https ca-certificates curl software-properties-common

Descarga la clave GPG para añadir el repositorio oficial de Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Añade el repositorio a APT utilizando la clave que descargaste e instalaste anteriormente:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualice la lista de paquetes:

sudo apt update

Para asegurarte de que Docker se instalará desde el repositorio recién añadido y no desde el del sistema, puedes ejecutar el siguiente comando:

apt-cache policy docker-ce

Instalar motor Docker:

sudo apt install docker-ce

Compruebe que Docker se ha instalado correctamente y que el demonio correspondiente se está ejecutando y se encuentra en el estado active (running):

sudo systemctl status docker

● docker.service - Docker Application Container Engine
  Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset>
  Active: active (running) since Mon 2024-11-18 08:26:35 UTC; 3h 27min ago
TriggeredBy: ● docker.socket
    Docs: https://docs.docker.com
Main PID: 1842 (dockerd)
   Tasks: 29
  Memory: 1.8G
     CPU: 3min 15.715s
  CGroup: /system.slice/docker.service

Construir y ejecutar

Todo está listo para construir y ejecutar un contenedor Docker con Langflow. Sin embargo, hay una advertencia: en el momento de escribir esta guía, la última versión (etiquetada v1.1.0) tiene un error y no se inicia. Para evitar este problema, vamos a utilizar la versión anterior, v1.0.19.post2, que funciona perfectamente después de la descarga.

Lo más sencillo es descargar el repositorio del proyecto desde GitHub:

git clone https://github.com/langflow-ai/langflow

Navega hasta el directorio que contiene la configuración de despliegue de ejemplo:

cd langflow/docker_example

Ahora tendrá que hacer dos cosas. Primero, cambiar la etiqueta release para que se construya una versión funcional (en el momento de escribir estas instrucciones). En segundo lugar, añada una autorización simple para que nadie pueda utilizar el sistema sin conocer el nombre de usuario y la contraseña.

Abra el archivo de configuración:

sudo nano docker-compose.yml

en lugar de la siguiente línea:

image: langflowai/langflow:latest

especifique la versión en lugar de la etiqueta latest:

image: langflowai/langflow:v1.0.19.post2

También debe añadir tres variables a la sección environment:

  - LANGFLOW_AUTO_LOGIN=false
  - LANGFLOW_SUPERUSER=admin
  - LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

La primera variable desactiva el acceso a la interfaz web sin autorización. La segunda añade el nombre de usuario que recibirá derechos de administrador del sistema. La tercera añade la contraseña correspondiente.

Si tiene previsto almacenar el archivo docker-compose.yml en un sistema de control de versiones, evite escribir la contraseña directamente en este archivo. En su lugar, cree un archivo independiente con extensión .env en el mismo directorio y almacene allí el valor de la variable.

LANGFLOW_SUPERUSER_PASSWORD=your_secure_password

En el archivo docker-compose.yml, ahora puede hacer referencia a una variable en lugar de especificar directamente una contraseña:

LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD}

Para evitar exponer accidentalmente el archivo *.env en GitHub, recuerda añadirlo a .gitignore. Esto mantendrá tu contraseña razonablemente a salvo de accesos no deseados.

Ahora, todo lo que queda es construir nuestro contenedor y ejecutarlo:

sudo docker compose up

Abre la página web en http://[LeaderGPU_IP_address]:7860, y verás el formulario de autorización:

Una vez que introduzcas tu nombre de usuario y contraseña, el sistema te dará acceso a la interfaz web donde podrás crear tus propias aplicaciones. Para una orientación más detallada, le sugerimos que consulte la documentación oficial. En ella se ofrecen detalles sobre diversas variables de entorno que permiten personalizar fácilmente el sistema para adaptarlo a sus necesidades.

Ver también:

Easy Diffusion UI

Wed, 22 Jan 2025 12:13:37 +0100

Easy Diffusion UI es un software de código abierto disponible para su descarga en GitHub. A continuación te explicamos cómo instalarlo en Ubuntu 22.04 LTS. Si acabas de alquilar un servidor, instala los controladores de la GPU y amplía tu directorio de inicio. A continuación, descarga la última versión de Easy Diffusion UI:

wget https://github.com/cmdr2/stable-diffusion-ui/releases/latest/download/Easy-Diffusion-Linux.zip

Descomprime el archivo ZIP descargado:

unzip Easy-Diffusion-Linux.zip

Cambia el directorio a easy-diffusion:

cd easy-diffusion

Inicie la instalación:

./start.sh

Esta es una colección de scripts que descarga e instala automáticamente todos los componentes necesarios. También descarga el modelo estándar de Difusión Estable en formato SafeTensors. Una vez finalizadas todas las descargas e instalaciones, la interfaz de usuario de Easy Diffusion se iniciará automáticamente.

Uso de

El artículo anterior, Stable Diffusion WebUI, esboza un método para aceptar conexiones desde la Internet pública y proporciona un simple login y contraseña de autorización. En este caso, pretendemos demostrar otro método universal para reenviar puertos a través de una conexión SSH. Utilizamos PuTTY para establecer una conexión segura con el servidor remoto. Puedes encontrar más información al respecto en nuestra guía Conectarse a un servidor Linux.

Para elegir los puertos a redireccionar, abra Connection > SSH > Tunnels en el árbol de opciones de la izquierda. Escribe 9000 en el campo Source Port y 127.0.0.1:9000 en el campo Destination. A continuación, haz clic en el botón Add:

Después, puedes volver a Session y guardarlo para utilizarlo más adelante. Conéctate al servidor remoto como de costumbre. Ahora, todos los datos que envíes o recibas en el puerto 9000 de la dirección de loopback 127.0.0.1 se redirigirán al servidor remoto. Este método crea un túnel seguro virtual que existe mientras dure la conexión.

Una vez que Easy Diffusion UI se inicia y el reenvío de puertos está activado, puede abrir un navegador web y navegar a la dirección http://127.0.0.1:9000. Recomendamos descargar e instalar modelos personalizados, como se describe en este artículo, en lugar de confiar únicamente en el modelo estándar para generar imágenes. No olvide aumentar el número de pasos de inferencia y ajustar la resolución de imagen deseada (marcada con asteriscos).

Una de las principales ventajas de Easy Diffusion UI es su compatibilidad con múltiples GPUs. Cuando quieras crear un lote de imágenes, puedes elegir cuántas imágenes se crearán en paralelo. Por ejemplo, si tienes una configuración de doble GPU:

Puedes visualizar la carga de la GPU durante el proceso de generación de imágenes. Establece otra conexión SSH y ejecuta un único comando:

watch -n 1 nvidia-smi

Además, Easy Diffusion UI simplifica la creación de indicaciones, ya que proporciona numerosos ejemplos de modificadores de imagen. Puede mezclarlos para conseguir resultados más precisos:

Es una buena idea explorar PromptBook de OpenArt. Esta guía puede mejorar significativamente tus habilidades de creación de avisos. Con Easy Diffusion UI, una vez generada la imagen, puede descargarla, utilizarla como ejemplo para generar la siguiente imagen o realizar modificaciones con un solo clic:

El uso más común del botón Upscale es aumentar la resolución de una imagen. La red neuronal generativa utiliza la imagen original como base y añade píxeles adicionales, interpolando así la imagen de origen al tamaño deseado.

Al generar rostros, pueden surgir problemas como ojos desalineados, tamaños desproporcionados o partes malformadas. Afortunadamente, estos problemas pueden solucionarse con el botón Fix Faces. Además, pueden utilizarse indicaciones negativas para evitar que se generen caras incorrectas.

Desinstalar

Todos los archivos, scripts, bibliotecas y modelos se almacenan en un único directorio. Si desea eliminar Easy Diffusion UI de su servidor, simplemente borre este directorio junto con todo el contenido:

sudo rm -rf easy-diffusion

Ver también:

Stable Video Diffusion

Wed, 22 Jan 2025 11:53:04 +0100

Las redes neuronales generativas pueden crear varios tipos de contenidos. Stable Diffusion se creó para generar imágenes a partir de la descripción de textos. Sin embargo, también puede utilizarse para crear música, sonidos e incluso vídeos. Hoy, te mostraremos cómo crear videos cortos a partir de una sola imagen utilizando Stable Diffusion con WebUI y ComfyUI.

Instalar Stable Diffusion

Comencemos instalando Stable Diffusion usando nuestra guía paso a paso. Tras la instalación, por favor interrumpe la ejecución del script webui.sh pulsando Ctrl + C y cierra la conexión SSH. El sistema no le permite instalar extensiones con las opciones --listen (--share) habilitadas. Esto significa que necesita configurar el reenvío de puertos (7860 y 8189) desde su máquina local al servidor remoto. El primer puerto es necesario para WebUI y el segundo para ComfyUI.

Por ejemplo, en PuTTY, necesitas abrir Connection >> SSH >> Tunnels y añadir dos nuevos puertos reenviados como se muestra en la siguiente captura de pantalla:

Ahora, puedes reconectarte al servidor remoto y ejecutar ./webui.sh de nuevo.

Abra esta URL en su navegador:

http://127.0.0.1:7860

Navegue hasta Extensions >> Available, luego haga clic en el botón Load from::

El sistema descargará el archivo JSON con todas las extensiones disponibles. Escriba ComfyUI en el cuadro de entrada de búsqueda y haga clic en el botón Install:

La página web se recargará y aparecerá una nueva pestaña ComfyUI en el panel principal. Cambie a ella y haga clic en Install ComfyUI:

Cuando termine la instalación, interrumpe de nuevo la ejecución del script webui.sh pulsando Ctrl + C.

Instalar el modelo Stable Video Diffusion

Abra el directorio del modelo:

cd stable-diffusion-webui/models/Stable-diffusion/

Descargue el modelo completo de difusión de vídeo estable:

curl -L https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt/resolve/main/svd_xt.safetensors?download=true --output svd_xt.safetensors

Volver al directorio de inicio:

cd ~/

Y ejecute de nuevo el servicio Stable Diffusion:

./webui.sh

Descarga el ejemplo del flujo de trabajo de Difusión de Video Estable en formato JSON. Borra el flujo de trabajo por defecto de ComfyUI pulsando Clear, luego Load el ejemplo descargado:

Asegúrate de que tienes el modelo correcto seleccionado en el nodo Image Only Checkpoint Loader (img2vid model):

Pulsa el botón choose file to upload en el nodo Load Image y selecciona cualquier imagen individual que la red neuronal generativa transformará en un vídeo:

Pruebe a generar un vídeo con todos los parámetros por defecto haciendo clic en el botón Queue Prompt:

Una vez finalizado el proceso, obtendrá su vídeo en formato WEBP en el nodo SaveAnimatedWEBP. Haga clic con el botón derecho en el vídeo generado y elija Save Image:

Aquí tienes el GIF resultante.

Solución de problemas

Si aparece un mensaje de error: ModuleNotFoundError: No module named 'utils.json_util'; 'utils' is not a package, siga estos pasos:

Cambie el nombre del directorio utils por utilities:

mv /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utils /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/utilities

Edite custom_node_manager.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/app/custom_node_manager.py

Sustituya esta línea:

from utils.json_util import merge_json_recursive

por:

from utilities.json_util import merge_json_recursive

Guarde el archivo (Ctrl + O) y salga del editor (Ctrl + X). A continuación, edite main.py:

nano /home/usergpu/stable-diffusion-webui/extensions/sd-webui-comfyui/ComfyUI/main.py

Reemplace esta línea:

import utils.extra_config

por:

import utilities.extra_config

Guarde el archivo, salga del editor y ejecute de nuevo el servicio Difusión Estable:

./webui.sh

Ver también:

PyTorch para Windows

Wed, 22 Jan 2025 11:35:30 +0100

Antes de empezar a instalar PyTorch, necesitas instalar el intérprete de Python y Microsoft Visual C++ Redistributable. Abre un navegador web y navega hasta la página de descargas de Python. Busca la última versión de Python 3 y haz clic en el enlace:

A continuación, desplácese por la página y haga clic en Windows Installer (64-bit):

Abre el archivo descargado para proceder a la instalación:

Marque la casilla Add python.exe to PATH y haga clic en Install Now:

Espera un minuto a que finalice el proceso de instalación:

Puede optar por Disable path length limit si tiene previsto utilizar nombres largos que podrían superar los límites de MAX_PATH:

Instale MS Visual C++

A continuación, descargue Microsoft Visual C++ Redistributable utilizando este enlace y haga clic en el instalador:

Debe marcar la casilla I agree to the license terms and conditions y hacer clic en el botón Install:

Después de unos segundos, este software se instalará y podrás Close el instalador:

Ahora, todo está listo para la instalación de PyTorch. Haz clic en el botón Start y escribe cmd en el teclado. Haz clic con el botón derecho del ratón en Command Prompt y selecciona Run as administrator en el menú contextual:

Instalar PyTorch

Ejecuta el siguiente comando:

pip install torch torchvision

Si desea instalar una versión específica de PyTorch, puede especificarla durante la instalación:

pip install torch==1.9.0 torchvision==0.10.0

Una vez completada la instalación, comprobemos que PyTorch funciona correctamente. Ejecute el siguiente comando para abrir el intérprete de Python:

python

Escribe estas dos cadenas, terminando tu entrada con la tecla Enter:

import torch
print(torch.__version__)

Si obtienes un resultado como este, significa que PyTorch fue instalado correctamente:

2.0.1+cu117

Ver también:

PyTorch para Linux

Wed, 22 Jan 2025 10:14:16 +0100

Las distribuciones modernas de Linux dependen en gran medida de la versión instalada de Python. Por lo tanto, antes de instalar PyTorch, recomendamos crear un entorno virtual utilizando nuestra guía paso a paso Utilidades del sistema Linux.

Active el venv creado y proceda con la actualización pip3:

pip3 install --upgrade pip

Inicie la instalación de PyTorch:

pip3 install torch torchvision

Si quieres instalar una versión específica de PyTorch, simplemente escribe el número de versión requerido:

pip3 install torch==1.9.0 torchvision==0.10.0

Cuando la instalación haya terminado, comprobemos que PyTorch se ha instalado correctamente. Abra el intérprete de Python:

python3

Escribe estas dos cadenas, terminando tu entrada con la tecla Enter:

import torch
print(torch.__version__)

Si obtiene un resultado como este, significa que PyTorch ha sido instalado correctamente:

2.0.1+cu117

Ver también:

Stable Diffusion: Rifusión

Tue, 21 Jan 2025 14:12:29 +0100

En nuestros artículos anteriores, exploramos las fascinantes capacidades de la Difusión Estable para generar imágenes cautivadoras. Sin embargo, es importante señalar que esta potente red neuronal generativa tiene aún más que ofrecer.

Riffusion es un modelo de Difusión Estable para la creación y edición de música. Con Riffusion, puedes generar un espectrograma de un segmento musical deseado y transformarlo sin esfuerzo en un fragmento musical. Instalemos Riffusion en un servidor LeaderGPU y probémoslo en acción.

Requisitos previos

Empieza por actualizar el repositorio de caché de paquetes y los paquetes instalados:

sudo apt update && sudo apt -y upgrade

No olvides instalar los controladores NVIDIA® mediante el comando autoinstall o manualmente, siguiendo nuestra guía paso a paso:

sudo ubuntu-drivers autoinstall

Reinicia el servidor:

sudo shutdown -r now

Para crear un entorno virtual, los desarrolladores sugieren utilizar una herramienta llamada Anaconda. También puedes usar venv, de la que hablamos en el tutorial de utilidades del sistema Linux. Descarga el script de instalación de Anaconda usando curl:

curl --output anaconda.sh https://repo.anaconda.com/archive/Anaconda3-5.3.1-Linux-x86_64.sh

Hazlo ejecutable:

chmod +x anaconda.sh

Y ejecuta:

./anaconda.sh

Responde SÍ a todas las preguntas, excepto a la última (instalar Microsoft VSCode). A continuación, vuelve a iniciar sesión en la consola SSH y crea un nuevo entorno virtual con Python v3.9:

conda create --name riffusion python=3.9

Activa el nuevo entorno virtual:

conda activate riffusion

Si desea utilizar formatos de música distintos de wav, es necesario instalar también el conjunto de bibliotecas FFmpeg:

conda install -c conda-forge ffmpeg

Instalar Riffusion

Clona el repositorio de Riffusion:

git clone https://github.com/riffusion/riffusion.git

Abra el directorio descargado:

cd riffusion

Hagamos algunos cambios en el archivo de requisitos. Esto evita errores con la compatibilidad de la antorcha:

nano requirements.txt

Buscar y corregir versiones de paquetes:

diffusers==0.9.0
torchaudio==2.0.1

Guarde los cambios y proceda a preparar un entorno virtual. El siguiente comando instala todos los paquetes necesarios:

python -m pip install -r requirements.txt

Por último, puede abrir un "patio de recreo". Se trata de una sencilla interfaz web que le ayudará a conocer mejor las características de Riffusion:

python -m riffusion.streamlit.playground

Abre tu navegador favorito e introduce la dirección http://[SERVER_IP]:8501/

Probar una zona de juegos

Ahora, puedes crear música utilizando indicaciones de texto y cambiando los demás parámetros:

Además, puedes hacer algunas cosas complicadas, como dividir el audio en componentes separados. Por ejemplo, puedes extraer la voz de Bohemian rhapsody de Queen:

Recuerda que éste es sólo un ejemplo de cómo utilizar Riffusion. Creando tu propia aplicación, puedes conseguir resultados mucho más cautivadores. Los potentes servidores de LeaderGPU se encargarán de los cálculos.

Ver también:

Stable Diffusion: Generación de caras repetibles

Tue, 21 Jan 2025 13:51:05 +0100

La repetibilidad es el aspecto más importante a la hora de crear contenidos gráficos con redes neuronales generativas. Esto es válido independientemente del tipo de contenido que se cree, ya sea un personaje de cine o de videojuegos, un paisaje o el entorno de una escena. El problema principal puede formularse como: "¿Cómo puedo repetir mi resultado?". Cada vez que empieces a generar imágenes con las mismas indicaciones positivas y negativas, obtendrás resultados diferentes. A veces, las diferencias son menores y aceptables, pero en la mayoría de los casos, podrían plantear un problema.

Stable Diffusion se aprende en un gran conjunto de datos capturados del mundo real, lo que explica por qué la repetibilidad no es un punto fuerte de este modelo de red neuronal. Sin embargo, esta regla no se aplica a las fotos de famosos. Estas fotos se encuentran con mucha más frecuencia en el mundo real y, por tanto, en el conjunto de datos sobre el que se entrenó Stable Diffusion. Puede utilizar estas fotos como "constante" o "punto de partida" en el proceso de generación.

Método 1. "Agitado, no revuelto"

Por supuesto, no necesitas crear sólo imágenes de famosos, sino que puedes utilizar varias indicaciones relevantes para obtener resultados más o menos coherentes. Por ejemplo, podemos tomar a dos famosas cantantes griegas: Elena Paparizou y Marina Satti, y obtener resultados repetibles:

Model: Visión realista v6.0 beta 1

Positive prompts:

Elena Paparizou, Marina Satti, fashion portrait, alone, solo, greek woman in beautiful clothes, natural skin, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Funciona con cualquier famoso, ya que Stable Diffusion intentó reproducir los rasgos faciales más destacados. Aquí, utilizamos el mismo modelo y "agitamos" a dos estrellas de Hollywood (Dwayne Johnson y Danny Trejo) en un nuevo personaje sintético.

Positive prompts:

Dwayne Johnson, Danny Trejo, fashion portrait, alone, solo, 8k uhd, high quality, film grain, Canon EOS

Negative prompts:

bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Cada vez que mezclas las mismas celebridades, obtienes resultados similares. Veamos otro método para generar personajes repetibles.

Método 2. Anclaje de nombres

Los famosos son un buen comienzo, pero consideremos otros métodos para conseguir resultados repetibles. La respuesta es muy sencilla: podemos utilizar varios nombres humanos. Cada nación tiene nombres únicos, relacionados con rasgos lingüísticos. Por ejemplo, el nombre griego Kostas puede traducirse como "trabajo" o "esfuerzo", mientras que Nikos significa "Victoria del pueblo". Estos dos nombres crean una imagen única de una persona generada, lo que ayuda a los modelos de redes neuronales a comprender nuestros objetivos de creación.

Positive prompts:

Portrait of [Kostas | Nikos] on a white background, greek man, short haircut, beard

Negative prompts:

woman, bad anatomy, bad hands, three hands, three legs, bad arms, missing legs, missing arms, poorly drawn face, bad face, fused face, cloned face, worst face, three crus, extra crus, fused crus, worst feet, three feet, fused feet, fused thigh, three thigh, fused thigh, extra thigh, worst thigh, missing fingers, extra fingers, ugly fingers, long fingers, horn, extra eyes, huge eyes, 2girl, amputation, disconnected limbs, cartoon, cg, 3d, unreal, animate, nsfw, nude, censored

Vamos a generar numerosas imágenes (80-100) para la posterior creación del conjunto de datos. La indicación principal se seleccionó para proporcionar imágenes convenientes que puedan borrarse fácilmente del fondo. Las indicaciones negativas nos protegen de incluir imágenes aleatorias con distorsiones en el conjunto de datos, así como imágenes de mujeres.

Consejo: si recibe imágenes muy diferentes entre sí, pruebe a cambiar el parámetro Escala CFG de 7,5 a 15. Esto obligará a la red neuronal a seguir las indicaciones de manera más formal.

Puedes seleccionar tus propios nombres únicos con un sencillo generador de nombres, como Behind the Name. También puedes utilizar la función ControlNet para tener un mayor control.

Método 3. Enseñar apariencia

No podemos influir directamente en el resultado final, pero observamos que algunos tokens (como los de imagen de famosos) tienen más peso que otros. Esto significa que podemos crear nuestro token condicional "celebridad" creando un prompt apropiado para él y entrenando más el modelo con él. Así funciona LoRA (Low-Rank Adaptation of Large Language Models). Puede utilizar nuestra guía paso a paso para entrenar su propio modelo LoRA a partir de un conjunto de datos creado por usted.

Tras eliminar el fondo, obtenemos retratos nítidos y los utilizamos para crear un modelo LoRA específico. Este modelo ayuda a reproducir un rostro con unos pequeños cambios:

Ahora, podemos generar este personaje en diferentes lugares, crear historias y colocarlo en varios papeles: desde jardinero a hombre de negocios. Su rostro será siempre reconocible y repetible:

Este método no es ideal, pero funciona perfectamente en diversas situaciones. No hace falta preparar un conjunto de datos de una persona real, y se puede generar a distancia:

Puedes intentar crear un personaje virtual de este tipo tú mismo, sin la ayuda de un diseñador profesional o un especialista en modelado 3D. Todo lo que necesitas son GPU rápidas, que puedes encontrar en los servidores dedicados de LeaderGPU.

Ver también:

Stable Diffusion: LoRA selfie

Tue, 21 Jan 2025 13:44:25 +0100

Puedes crear tu primer conjunto de datos con una cámara sencilla y un fondo bastante uniforme, como una pared blanca o una cortina monótona. Para un conjunto de datos de muestra, he utilizado una cámara sin espejo Olympus OM-D EM5 Mark II con objetivos de kit 14-42. Esta cámara admite el control remoto desde cualquier smartphone y un modo de disparo continuo muy rápido.

Monté la cámara en un trípode y establecí la prioridad de enfoque en cara. A continuación, seleccioné el modo en el que la cámara captura 10 fotogramas consecutivos cada 3 segundos e inicié el proceso. Durante el proceso de disparo, giré lentamente la cabeza en la dirección seleccionada y cambié de dirección cada 10 fotogramas:

El resultado fueron unos 100 fotogramas con un fondo monótono:

El siguiente paso es eliminar el fondo y dejar el retrato sobre un fondo blanco.

Eliminar el fondo

Puede utilizar la función estándar de Adobe Photoshop Remove background y el procesamiento por lotes. Vamos a almacenar las acciones que queremos aplicar a cada imagen de un conjunto de datos. Abra cualquier imagen, haga clic en el icono del triángulo y, a continuación, haga clic en el símbolo +:

Escriba el nombre de la nueva acción, por ejemplo, Remove Background y haga clic en Record:

En la pestaña Layers, busque el símbolo del candado y haga clic en él:

A continuación, haga clic en el botón Remove background del panel flotante:

Haga clic con el botón derecho del ratón en Layer 0 y seleccione Flatten Image:

Todas nuestras acciones han sido registradas. Detengamos este proceso:

Ahora, puede cerrar el archivo abierto sin guardar los cambios y seleccionar File >> Scripts >> Image Processor…

Seleccione los directorios de entrada y salida, elija la acción Remove Background creada en el paso 4 y haga clic en el botón Run:

Tenga paciencia. Adobe Photoshop abrirá todas las imágenes del directorio seleccionado, repetirá las acciones grabadas (desactivar el bloqueo de capas, eliminar el fondo, aplanar la imagen) y las guardará en otro directorio seleccionado. Este proceso puede tardar un par de minutos, dependiendo del número de imágenes.

Una vez finalizado el proceso, puede pasar al siguiente paso.

Subir al servidor

Utilice una de las siguientes guías (adaptada al sistema operativo de su PC) para cargar el directorio dataset en el servidor remoto. Por ejemplo, colócalo en el directorio de inicio del usuario por defecto, /home/usergpu:

Preinstalación

Actualice los paquetes existentes del sistema:

sudo apt update && sudo apt -y upgrade

Instale dos paquetes adicionales:

sudo apt install -y python3-tk python3.10-venv

Instalemos el CUDA® Toolkit versión 11.8. Descarguemos el archivo pin específico:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

El siguiente comando coloca el archivo descargado en el directorio del sistema, controlado por el gestor de paquetes apt:

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

El siguiente paso es descargar el repositorio principal de CUDA:

wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Después, proceda a la instalación del paquete utilizando la utilidad estándar dpkg:

sudo dpkg -i cuda-repo-ubuntu2204-11-8-local_11.8.0-520.61.05-1_amd64.deb

Copie el llavero GPG en el directorio del sistema. Esto hará que esté disponible para su uso por las utilidades del sistema operativo, incluyendo el gestor de paquetes apt:

sudo cp /var/cuda-repo-ubuntu2204-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/

Actualice los repositorios de caché del sistema:

sudo apt-get update

Instala el kit de herramientas CUDA® usando apt:

sudo apt-get -y install cuda

Añade CUDA® a PATH. Abra la configuración de shell bash:

nano ~/.bashrc

Añade las siguientes líneas al final del archivo:

export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64\
                         ${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Guarde el archivo y reinicie el servidor:

sudo shutdown -r now

Instalar entrenador

Copie el repositorio del proyecto Kohya en el servidor:

git clone https://github.com/bmaltais/kohya_ss.git

Abra el directorio descargado:

cd kohya_ss

Haz ejecutable el script de instalación:

chmod +x ./setup.sh

Ejecuta el script:

./setup.sh

Recibirás un mensaje de advertencia de la utilidad de aceleración. Vamos a resolver el problema. Activa el entorno virtual del proyecto:

source venv/bin/activate

Instala el paquete que falta:

pip install scipy

Y configura manualmente la utilidad de aceleración:

accelerate config

Ten cuidado, porque activar un número impar de CPUs causará un error. Por ejemplo, si tengo 5 GPUs, sólo se pueden utilizar 4 con este software. De lo contrario, se producirá un error al iniciar el proceso. Puede comprobar inmediatamente la nueva configuración de la utilidad llamando a una prueba predeterminada:

accelerate test

Si todo está bien, recibirá un mensaje como este:

Test is a success! You are ready for your distributed training!

deactivate

Ahora, puedes iniciar el servidor público del entrenador con la GUI de Gradio y una simple autenticación de usuario/contraseña (cambia el usuario/contraseña por los tuyos):

./gui.sh --share --username user --password password

Recibirás dos cadenas:

Running on local URL: http://127.0.0.1:7860
Running on public URL: https://.gradio.live

Abra su navegador web e introduzca la URL pública en la barra de direcciones. Escriba su nombre de usuario y contraseña en los campos correspondientes y, a continuación, haga clic en Iniciar sesión:

Preparar el conjunto de datos

Comience por crear una nueva carpeta en la que almacenará el modelo LoRA entrenado:

mkdir /home/usergpu/myloramodel

Abre las siguientes pestañas: Utilities >> Captioning >> BLIP captioning. Rellena los huecos como se muestra en la imagen y haz clic en Caption images:

Trainer descargará y ejecutará un modelo de red neuronal específico (1,6 Gb) que crea mensajes de texto para cada archivo de imagen del directorio seleccionado. Se ejecutará en una sola GPU y tardará alrededor de un minuto.

Cambia la pestaña a LoRA >> Tools >> Dataset preparation >> Dreambooth/LoRA folder preparation, rellena los huecos y pulsa secuencialmente Prepare training data y Copy info to Folders Tab:

En este ejemplo, utilizamos el nombre nikolai como Instance prompt y "persona" como Class prompt. También establecemos /home/usergpu/dataset como Training Images y /home/usergpu/myloramodel como Destination training directory.

Cambie de nuevo a la pestaña LoRA >> Training >> Folders. Asegúrese de que Image folder, Output folder y Logging folder están correctamente rellenados. Si lo desea, puede cambiar el Model output name por el suyo propio. Por último, haga clic en el botón Start training:

El sistema comenzará a descargar archivos y modelos adicionales (~10 GB). A continuación, comenzará el proceso de entrenamiento. Dependiendo de la cantidad de imágenes y de los ajustes aplicados, puede tardar varias horas. Una vez finalizado el entrenamiento, puede descargar el directorio /home/usergpu/myloramodel a su ordenador para utilizarlo en el futuro.

Pruebe su LoRA

Hemos preparado algunos artículos sobre Stable Diffusion y sus bifurcaciones. Puedes intentar instalar Easy Diffusion con nuestra guía Easy Diffusion UI. Después de que el sistema se haya instalado y esté funcionando, puedes subir tu modelo LoRA en formato SafeTensors directamente a /home/usergpu/easy-diffusion/models/lora

Actualiza la página web de Easy diffusion y selecciona tu modelo de la lista desplegable:

Vamos a escribir un simple mensaje, portrait of <nikolai> wearing a cowboy hat, y generar nuestras primeras imágenes. Aquí, usamos un modelo personalizado de Difusión Estable descargado de civitai.com: Realistic Vision v6.0 B1:

Puedes experimentar con instrucciones y modelos basados en Stable Diffusion para obtener mejores resultados. ¡Que aproveche!

Ver también:

Stable Diffusion: ¿Qué es ControlNet?

Tue, 21 Jan 2025 10:42:39 +0100

Un error común entre quienes se enfrentan por primera vez a las redes neuronales generativas es que el control del resultado final es tremendamente difícil, especialmente cuando se intenta alterar el resultado mediante diferentes frases. En la actualidad, existe un conjunto de herramientas conocido como ControlNet que facilita un control relativamente sencillo y eficaz de los resultados de la generación.

En este artículo, demostraremos cómo manipular fácilmente la pose de los personajes generados utilizando imágenes preexistentes y "esqueletos" personalizados, con la ayuda de una de estas herramientas, OpenPose.

Paso 1. Instalar Stable Diffusion Instalar Stable Diffusion

Por favor, utilice nuestra guía paso a paso para instalar Stable Diffusion con el modelo básico y WebUI. Esta guía se basa en el script AUTOMATIC1111.

Paso 2. Instalar la extensión ControlNet Instale la extensión ControlNet

Recomendamos encarecidamente no instalar la extensión ControlNet (sd-webui-controlnet) desde el repositorio estándar debido a posibles problemas de funcionalidad. Un problema importante que encontramos durante la preparación de esta guía fue la congelación de la interfaz web. Aunque la imagen se genera inicialmente con éxito, la WebUI deja de responder cuando se genera la imagen por segunda vez. Una solución alternativa sería instalar la misma extensión desde una fuente externa.

Abra WebUI y siga las pestañas: Extensions > Install from URL. Pegue esta URL en el campo apropiado:

https://github.com/Mikubill/sd-webui-controlnet

A continuación, haga clic en el botón Install:

Cuando el proceso se complete con éxito, debería aparecer el siguiente mensaje:

Installed into /home/usergpu/stable-diffusion-webui/extensions/sd-webui-controlnet. Use Installed tab to restart.

Vamos a reiniciar la URL pulsando el botón Aplicar y reiniciar UI en la pestaña Instalado:

Tras reiniciar la interfaz, aparecerá el nuevo elemento ControlNet con muchas opciones adicionales:

Paso 3. Descargar OpenPose

Añadir clave HF

Vamos a generar y añadir una clave SSH que podrás utilizar en Hugging Face:

cd ~/.ssh && ssh-keygen

Cuando se genera el par de claves, puedes mostrar la clave pública en el emulador de terminal:

cat id_rsa.pub

Copie toda la información empezando por ssh-rsa y terminando por usergpu@gpuserver, como se muestra en la siguiente captura de pantalla:

Abre un navegador web, escribe https://huggingface.co/ en la barra de direcciones y pulsa Enter. Inicie sesión en su cuenta de HF y abra Configuración del perfil. A continuación, seleccione SSH and GPG Keys y pulse el botón Add SSH Key:

Rellene el Key name y pegue el SSH Public key copiado del terminal. Guarda la clave pulsando Add key:

Ahora, tu cuenta HF está vinculada a la clave SSH pública. La segunda parte (clave privada) se almacena en el servidor. El siguiente paso es instalar una extensión específica de Git LFS (Large File Storage), que se utiliza para descargar archivos de gran tamaño, como modelos de redes neuronales.

Instalar Git LFS

El siguiente paso es instalar una extensión específica de Git LFS (Large File Storage), que se utiliza para descargar archivos de gran tamaño, como modelos de redes neuronales. Abre tu directorio de inicio:

cd ~/

Descarga y ejecuta el script de shell. Este script instala un nuevo repositorio de terceros con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ahora, puedes instalarlo usando el gestor de paquetes estándar:

sudo apt-get install git-lfs

Vamos a configurar git para utilizar nuestro apodo HF:

git config --global user.name "John"

Y vinculado a la cuenta de correo de HF:

git config --global user.email "john.doe@example.com"

Descargar el repositorio

Recomendamos, si es posible, utilizar un disco duro local para descargar y almacenar los modelos. Puedes aprender más sobre esto en nuestra guía, Particionado de discos en Linux. Para este ejemplo, hemos montado un disco SSD en el punto de montaje /mnt/fastdisk. Hagámoslo propiedad del usuario por defecto:

sudo chown usergpu:usergpu /mnt/fastdisk

Abre el directorio:

cd /mnt/fastdisk

Clonar el repositorio ControlNet de HuggingFace. Git-LFS previamente instalado sustituirá automáticamente los punteros por archivos reales:

git clone git@hf.co:lllyasviel/ControlNet-v1-1

En este ejemplo, añadimos sólo un modelo a Stable Diffusion WebUI. Sin embargo, puedes copiar todos los modelos disponibles del repositorio (~18GB):

cp /mnt/fastdisk/ControlNet-v1-1/control_v11p_sd15_openpose.pth /home/usergpu/stable-diffusion-webui/models/ControlNet/

Paso 4. Ejecutar el proceso de generación

El modelo actual es bastante básico y puede no dar resultados satisfactorios. Por lo tanto, le sugerimos que lo sustituya por un modelo personalizado. Encontrará directrices sobre cómo hacerlo en este artículo: Modelos de difusión estable: personalización y opciones. Para este ejemplo, hemos descargado RealisticVision v6.0 B1.

Si desea generar su primera imagen utilizando OpenPose, abra la pestaña ControlNet, elija OpenPose, marque Enable y Allow Preview. A continuación, haga clic en Upload para añadir una imagen que contenga la pose deseada:

Puede solicitar al sistema que genere una vista previa de la pose haciendo clic en el botón con el icono de la explosión:

A la izquierda, se muestra la imagen original. A la derecha, puede ver el "esqueleto" que representa la pose reconocida por el modelo de red neuronal:

Ahora puede escribir la indicación principal, por ejemplo "dancing bear, by Pixar" o "dancing fox, by Pixar" y pulsar el botón Generate. Al cabo de unos segundos obtendrás resultados como estos:

El sistema intentará generar una nueva imagen, dado el "esqueleto" obtenido de la imagen original. En algunos casos, la pose puede no ser exacta, pero esto puede corregirse fácilmente editando manualmente el "esqueleto".

Paso 5. Cambio de pose

Aunque parezca magia, el modelo no es perfecto, y los errores ocasionales pueden afectar a la imagen final. Para evitar problemas durante la generación de la imagen, tienes la opción de ajustar manualmente el "esqueleto" haciendo clic en el botón Edit:

En el editor proporcionado, puedes ajustar fácilmente la pose arrastrando y soltando, o eliminar los puntos no deseados con un clic derecho. A continuación, haz clic en el botón Send pose to ControlNet y se aplicará la nueva pose:

Además de OpenPose, ControlNet ofrece diversas herramientas para personalizar y perfeccionar los resultados. Además, los servidores dedicados proporcionados por LeaderGPU garantizan un proceso rápido y cómodo.

Ver también:

Fooocus: Replanteamiento de SD y MJ

Tue, 21 Jan 2025 10:36:52 +0100

La llegada de Stable Diffusion y MidJourney ha revolucionado nuestra comprensión del potencial de las redes neuronales generativas. Estas herramientas han desvelado una nueva perspectiva del proceso de creación de imágenes y hasta qué punto podemos manipularlo. El enfoque principal consiste en proporcionar al sistema indicaciones sobre el resultado deseado. Esencialmente, destacamos tres aspectos importantes: objeto, estilo y entorno.

También son importantes, aunque no indispensables, otras instrucciones más concretas, como la composición deseada, el tipo de cámara/lente y la coloración. Cuanto más completas sean las instrucciones, más fácil le resultará a la red neuronal procesarlas. En el espacio profesional ha surgido incluso el papel del ingeniero de instrucciones. Sin embargo, este papel puede ser fácilmente sustituido por las mismas redes neuronales generativas. Combinando la creación de imágenes con la creación de textos, podemos generar instrucciones adicionales para lograr un resultado óptimo.

Este es el concepto fundamental de Fooocus. Integra el modelo XL Stable Diffusion y un generador de prompt basado en GPT2, que enriquece y detalla tu simple prompt. Además, Fooocus está equipado con diversas mejoras y extensiones. Estas características facilitan la generación de imágenes espectaculares a través de una interfaz sencilla, desprovista de herramientas complejas. Profundicemos en su funcionalidad e instalemos Fooocus en un servidor dedicado LeaderGPU.

Requisitos previos

Comienza con los prerrequisitos de instalación y reinicia después:

sudo apt update && sudo apt -y upgrade && sudo ubuntu-drivers autoinstall && sudo shutdown -r now

Descargue el script de shell que instala Anaconda para gestionar entornos virtuales:

wget https://repo.anaconda.com/archive/Anaconda3-2023.09-0-Linux-x86_64.sh

Establezca la bandera de ejecución y proporcione acceso a los datos:

chmod a+x Anaconda3-2023.09-0-Linux-x86_64.sh

Ejecute el script de instalación:

./Anaconda3-2023.09-0-Linux-x86_64.sh

Una vez finalizado el proceso, recomendamos desconectar la sesión SSH y preparar el reenvío de puertos. Necesita redirigir el puerto 7865 desde el servidor remoto a una dirección loopback local, 127.0.0.1:7865. Para obtener más información, consulte una de nuestras guías anteriores: Difusión de vídeo estable. A continuación, vuelve a conectarte y procede a clonar el repositorio del proyecto en GitHub.

Instalación de Fooocus

git clone https://github.com/lllyasviel/Fooocus.git

Cambia el directorio a Fooocus:

cd Fooocus

Crea un entorno virtual usando Anaconda y el YAML-config preparado por el autor del proyecto:

conda env create -f environment.yaml

Cambiemos nuestro entorno base por uno recién creado:

conda activate fooocus

El siguiente paso es instalar las librerías de Python:

pip install -r requirements_versions.txt

Ahora, todo está listo para empezar:

Fooocus start

python entry_with_update.py

El arranque inicial puede llevar algún tiempo mientras la aplicación verifica y descarga todos los archivos necesarios para su funcionamiento. Es posible que quieras tomarte una taza de café mientras tanto. Una vez finalizado el proceso, abre tu navegador y escribe la siguiente URL en la barra de direcciones:

http://127.0.0.1:7865

Escriba su consulta simple y haga clic en el botón Generate. Si quieres más control, marca Advanced y selecciona las opciones necesarias:

La verdadera magia se despliega entre bastidores. En el momento en que pulsa el botón Generate, su pregunta se transfiere al modelo de lenguaje basado en GPT2. Este modelo transforma su breve mensaje en una mezcla de mensajes elaborativos positivos y negativos. Posteriormente, esta mezcla se introduce en el modelo Stable Diffusion XL, ajustado para emular el estilo MidJourney. De este modo, incluso un mensaje breve puede generar resultados impresionantes.

Por supuesto, no hay ninguna restricción a la hora de escribir sus propios mensajes. Sin embargo, tras varias iteraciones, resulta evidente que, incluso en ausencia de éstas, el contenido generado sigue siendo intrigante y diverso.

Ver también:

Renderizado remoto en Blender con Flamenco

Tue, 21 Jan 2025 09:47:24 +0100

Cuando el renderizado de escenas pesadas en Blender empieza a consumir demasiado tiempo de su equipo, tiene dos opciones: actualizar el ordenador de cada miembro del equipo o subcontratar el renderizado a una granja dedicada. Muchas empresas ofrecen soluciones de renderizado ya preparadas, pero si necesita un control total sobre la infraestructura, estas soluciones pueden no ser la opción más fiable.

Un enfoque alternativo podría consistir en crear una infraestructura híbrida. En esta configuración, mantendría el almacenamiento de datos y la gestión de la granja de renderizado dentro de su infraestructura existente. El único elemento que se ubicaría fuera serían los servidores GPU alquilados en los que se realizaría el renderizado.

En general, la infraestructura de la granja de renderizado para Blender tiene este aspecto:

Aquí tenemos un nodo central Manager que organiza todos los procesos. Recibe las tareas de renderizado de los usuarios a través de un Blender Add-on específico y mueve todos los archivos necesarios a Shared Storage. Luego, el Manager distribuye las tareas a Worker nodes. Ellos reciben un trabajo que contiene toda la información acerca de dónde el Trabajador puede encontrar los archivos para renderizar y qué hacer con los resultados obtenidos. Para implementar este esquema, puedes utilizar una aplicación completamente gratuita y de código abierto llamada Flamenco. En esta guía, mostramos cómo preparar todos los nodos, especialmente los Manager y Worker.

El nodo Storage no tiene requisitos específicos. Puede utilizarse con cualquier sistema operativo que soporte los protocolos SMB/CIFS o NFS. El único requisito es que el directorio de almacenamiento debe estar montado y accesible por el sistema operativo. En tu infraestructura, puede ser cualquier carpeta compartida accesible a todos los nodos.

Cada nodo tiene direcciones IP diferentes, y el servidor Wireguard VPN será un punto central que los una en una red L2. Este servidor, situado en el perímetro externo, te permite trabajar sin realizar cambios en la política NAT existente.

Para este ejemplo, creamos la siguiente configuración mixta:

10.0.0.1 - Wireguard VPN server (servidor virtual por cualquier proveedor de infraestructura) con una IP externa;
10.0.0.2 - Worker node (servidor dedicado por LeaderGPU) con una IP externa;
10.0.0.3 - Manager node (servidor virtual en la red de la oficina) situado detrás de NAT;
10.0.0.4 - Storage node (servidor virtual en la red de la oficina) situado detrás de NAT;
10.0.0.5 - User node (ordenador portátil del consumidor en la red de la oficina) situado detrás de NAT.

Primer paso Wireguard

Servidor VPN

Puedes instalar y configurar Wireguard manualmente, usando una guía oficial y ejemplos. Sin embargo, hay una alternativa más fácil: script no oficial por el ingeniero de software de París (Stanislas aka angristan).

Descarga el script desde GitHub:

wget https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

Hazlo ejecutable:

sudo chmod +x wireguard-install.sh

Ejecutar:

sudo ./wireguard-install.sh

Siga las instrucciones y configure el rango de direcciones IP 10.0.0.1/24. El sistema te pedirá que crees inmediatamente un fichero de configuración para el primer cliente. Según el plan, este cliente será el nodo trabajador con nombre Worker y dirección 10.0.0.2. Cuando finalice el script, aparecerá un archivo de configuración en el directorio raíz: /root/wg0-client-Worker.conf.

Ejecuta el siguiente comando para ver esta configuración:

cat /home/usergpu/wg0-client-Worker.conf

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0

Ejecute de nuevo el script de instalación para crear otro cliente. Añada todos los clientes futuros de esta forma y, finalmente, podrá comprobar que se han creado todos los archivos de configuración:

cd ~/

ls -l | grep wg0

-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Manager.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Storage.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-User.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:58 wg0-client-Worker.conf

Clientes VPN

Los clientes VPN incluyen todos los nodos que necesitan estar conectados a una única red. En nuestra guía, esto se refiere al nodo gestor, el nodo de almacenamiento, el nodo cliente (si se utiliza Linux) y los nodos trabajadores. Si el servidor VPN se ejecuta en un nodo trabajador, no es necesario configurarlo como cliente (este paso puede omitirse).

Actualice el repositorio de caché de paquetes y, a continuación, instale los paquetes de soporte de Wireguard y CIFS:

sudo apt update && sudo apt -y install wireguard cifs-utils

Eleve los privilegios a superusuario:

sudo -i

Abra el directorio de configuración de Wireguard:

cd /etc/wireguard

Ejecute el comando umask para que sólo el superusuario tenga acceso a los archivos de este directorio:

umask 077

Genera una clave privada y guárdala en un archivo:

wg genkey > private-key

Generar una clave pública utilizando la clave privada:

wg pubkey > public-key < private-key

Crear un archivo de configuración:

nano /etc/wireguard/wg0.conf

Pega tu propia configuración, creada para este cliente:

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [SERVER_IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0
PersistentKeepalive = 1

No olvides añadir la opción PersistentKeepalive = 1 (donde 1 significa 1 segundo) en cada nodo situado detrás de NAT. Puedes elegir este periodo experimentalmente. El valor recomendado por los autores de Wireguard es 25. Guarda el archivo y sal, usando el atajo de teclado CTRL + X y la tecla Y para confirmar.

Si quieres pasar el trafico de internet configura AllowedIPs a 0.0.0.0/0,::/0

A continuación, cierra la sesión desde la cuenta raíz:

exit

Inicie la conexión usando systemctl:

sudo systemctl start wg-quick@wg0.service

Comprueba que todo va bien y que el servicio se ha iniciado correctamente:

sudo systemctl status wg-quick@wg0.service

● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2023-10-23 09:47:53 UTC; 1h 45min ago
  Docs: man:wg-quick(8)
        man:wg(8)
        https://www.wireguard.com/
        https://www.wireguard.com/quickstart/
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8
Process: 4128 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
Main PID: 4128 (code=exited, status=0/SUCCESS)
  CPU: 76ms

Si encuentra un error como "resolvconf: command not found" en Ubuntu 22.04 simplemente cree un enlace de símbolo:

sudo ln -s /usr/bin/resolvectl /usr/local/bin/resolvconf

Habilite el nuevo servicio para que se conecte automáticamente mientras el sistema operativo está arrancando:

sudo systemctl enable wg-quick@wg0.service

Ahora, puedes comprobar la conectividad enviando paquetes eco:

ping 10.0.0.1

PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=145 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=4 ttl=64 time=72.2 ms
--- 10.0.0.1 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 71.981/90.230/144.750/31.476 ms

Paso 2. Nodo NAS

Conéctese al servidor VPN siguiendo la guía del paso 1. A continuación, instale los paquetes Samba de servidor y cliente:

sudo apt install samba samba-client

Haga una copia de seguridad de su configuración por defecto:

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

Cree un directorio que se utilizará como recurso compartido:

sudo mkdir /mnt/share

Cree un nuevo grupo de usuarios que tendrá acceso al nuevo recurso compartido:

sudo groupadd smbusers

Añade un usuario existente al grupo creado:

sudo usermod -aG smbusers user

Establezca una contraseña para este usuario. Este paso es necesario porque la contraseña del sistema y la contraseña de Samba son entidades diferentes:

sudo smbpasswd -a $USER

Elimine la configuración por defecto:

sudo rm /etc/samba/smb.conf

Y crea una nueva:

sudo nano /etc/samba/smb.conf

[global]
workgroup = WORKGROUP
security = user
map to guest = bad user
wins support = no
dns proxy = no
[private]
path = /mnt/share
valid users = @smbusers
guest ok = no
browsable = yes
writable = yes

Guarda el archivo y prueba los nuevos parámetros:

testparm -s

Reinicie ambos servicios Samba:

sudo service smbd restart

sudo service nmbd restart

Por último, dé permiso para compartir la carpeta:

sudo chown user:smbusers /mnt/share

Paso 3. Conexión del cliente Samba

Todos los nodos de Flamenco utilizan un directorio compartido ubicado en /mnt/flamenco. Debe montar este directorio en cada nodo antes de ejecutar los scripts flamenco-client o flamenco-manager. En este ejemplo, utilizamos un nodo trabajador alojado en LeaderGPU con el nombre de usuario usergpu. Por favor, sustituye estos datos por los tuyos si difieren.

Crea un archivo oculto donde puedas almacenar las credenciales del recurso compartido SMB:

nano /home/usergpu/.smbcredentials

Escriba estas dos cadenas:

username=user # your Samba username
password=password # your Samba password

Guarda este archivo y sal. Luego, asegure este archivo cambiando los permisos de acceso:

sudo chmod 600 /home/usergpu/.smbcredentials

Cree un nuevo directorio que pueda utilizarse como punto de montaje para adjuntar el almacenamiento remoto:

sudo mkdir /mnt/flamenco

Y haz al usuario propietario de este directorio:

sudo chown usergpu:users /mnt/flamenco

Lo único que falta es que el directorio de red se monte automáticamente:

sudo nano /etc/systemd/system/mnt-flamenco.mount

[Unit]
Description=Mount Remote Storage
[Mount]
What=//10.0.0.4/private
Where=/mnt/flamenco
Type=cifs
Options=mfsymlinks,credentials=/home/usergpu/.smbcredentials,uid=usergpu,gid=users
[Install]
WantedBy=multi-user.target

Añade dos líneas a tu configuración VPN en la sección [Interface]:

sudo -i

nano /etc/wireguard/wg0.conf

…
PostUp = ping 10.0.0.4 -c 4 && systemctl start mnt-flamenco.mount
PostDown = systemctl stop mnt-flamenco.mount
…

Reinicie el servidor:

sudo shutdown -r now

Compruebe que los servicios se han cargado y que el directorio compartido se ha montado correctamente:

df -h

Filesystem          Size  Used Avail Use% Mounted on
tmpfs                35G  3.3M   35G   1% /run
/dev/sda2            99G   18G   77G  19% /
tmpfs               174G     0  174G   0% /dev/shm
tmpfs               5.0M     0  5.0M   0% /run/lock
tmpfs                35G  8.0K   35G   1% /run/user/1000
//10.0.0.4/private   40G  9.0G   31G  23% /mnt/flamenco

Paso 4. Nodo gestor

Configure una conexión VPN siguiendo la guía del Paso 1. Detenga el servicio VPN antes de continuar:

sudo systemctl stop wg-quick@wg0.service

Preparémonos. El montaje automático requiere utilidades para el protocolo CIFS:

sudo apt -y install cifs-utils

El siguiente paso importante es instalar Blender. Puede hacerlo utilizando el gestor de paquetes estándar de APT, pero lo más probable es que instale una de las versiones más antiguas (inferior a la v3.6.4). Utilicemos Snap para instalar la última versión:

sudo snap install blender --classic

Compruebe la versión instalada usando el siguiente comando:

blender --version

Blender 4.4.3
build date: 2025-04-29
build time: 15:12:13
build commit date: 2025-04-29
build commit time: 14:09
build hash: 802179c51ccc
build branch: blender-v4.4-release
build platform: Linux
build type: Release
…

Si recibe un mensaje de error indicando que faltan bibliotecas, simplemente instálelas. Todas estas bibliotecas están incluidas en el paquete XOrg:

sudo apt -y install xorg

Descargue la aplicación:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Descomprime el archivo descargado:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Vaya al directorio creado:

cd flamenco-3.7-linux-amd64/

E inicie Flamenco por primera vez:

./flamenco-manager

Abra la siguiente dirección en su navegador: http://10.0.0.3:8080/. Haga clic en el botón Let's go. Escriba /mnt/flamenco en el campo correspondiente y, a continuación, haga clic en Next:

Flamenco intentará localizar el archivo ejecutable de Blender. Si ha instalado Blender desde Snap, la ruta será /snap/bin/blender. Compruebe este punto y haga clic en Next:

Compruebe el resumen y haga clic en Confirm:

Vuelva a la sesión SSH y utilice el atajo de teclado Ctrl + C para interrumpir la aplicación. El primer lanzamiento genera el archivo de configuración flamenco-manager.yaml. Vamos a añadir algunas opciones a las secciones variables y blenderArgs:

nano flamenco-manager.yaml

# Configuration file for Flamenco.
# For an explanation of the fields, refer to flamenco-manager-example.yaml
#
# NOTE: this file will be overwritten by Flamenco Manager's web-based configuration system.
#
# This file was written on 2023-10-17 12:41:28 +00:00 by Flamenco 3.7
_meta:
  version: 3
manager_name: Flamenco Manager
database: flamenco-manager.sqlite
listen: :8080
autodiscoverable: true
local_manager_storage_path: ./flamenco-manager-storage
shared_storage_path: /mnt/flamenco
shaman:
  enabled: true
  garbageCollect:
    period: 24h0m0s
    maxAge: 744h0m0s
    extraCheckoutPaths: []
task_timeout: 10m0s
worker_timeout: 1m0s
blocklist_threshold: 3
task_fail_after_softfail_count: 3
variables:
  blender:
    values:
    - platform: linux
      value: blender
    - platform: windows
      value: blender
    - platform: darwin
      value: blender
  storage:
    values:
    is_twoway: true
    values:
    - platform: linux
      value: /mnt/flamenco
    - platform: windows
      value: Z:\
    - platform: darwin
      value: /Volumes/shared/flamenco
  blenderArgs:
    values:
    - platform: all
      value: -b -y -E CYCLES -P gpurender.py

El primer bloque adicional describe variables Two-way adicionales, necesarias para granjas multiplataforma. Esto resuelve el principal problema con las barras oblicuas y las rutas. En Linux, utilizamos el símbolo de la barra oblicua (/) como separador, pero en Windows, utilizamos el símbolo de la barra invertida (\). Aquí, creamos la regla de sustitución para todas las alternativas disponibles: Linux, Windows y macOS (Darwin).

Cuando se monta un recurso compartido de red en Windows, es necesario elegir una letra de unidad. Por ejemplo, nuestro Storage se monta con la letra Z:. La regla de sustitución indica al sistema que para la plataforma Windows, la ruta /mnt/flamenco se ubicará en Z:\. Para macOS, esta ruta será /Volumes/shared/flamenco.

Mire el segundo bloque añadido. Esto instruye a Blender a usar el motor de renderizado Cycles y llama a un simple script Python, gpurender.py, cuando Blender se ejecuta. Este es un simple truco para seleccionar la GPU en lugar de la CPU. No hay una opción estándar para hacer esto directamente. No puedes invocar blender --use-gpu o algo similar. Sin embargo, puedes invocar cualquier script externo de Python usando la opción -P. Este comando ordena a Worker que busque un script en el directorio local y lo ejecute cuando el trabajo asignado invoque al ejecutable de Blender.

Ahora, podemos delegar el control de la aplicación al subsistema systemd init. Informemos al sistema sobre la ubicación del directorio de trabajo, el archivo ejecutable y los privilegios de usuario necesarios para el lanzamiento. Crea un nuevo archivo:

sudo nano /etc/systemd/system/flamenco-manager.service

Llénalo con las siguientes cadenas:

[Unit]
Description=Flamenco Manager service
[Service]
User=user
WorkingDirectory=/home/user/flamenco-3.7-linux-amd64
ExecStart=/home/user/flamenco-3.7-linux-amd64/flamenco-manager
Restart=always
[Install]
WantedBy=multi-user.target

Guarde el archivo y salga del editor de texto nano.

sudo systemctl daemon-reload

sudo systemctl start flamenco-manager.service

sudo systemctl status flamenco-manager.service

● flamenco-manager.service - Flamenco Manager service
Loaded: loaded (/etc/systemd/system/flamenco-manager.service; disabled; vendor preset: enabled)
Active: active (running) since Tue 2023-10-17 11:03:50 UTC; 7s ago
Main PID: 3059 (flamenco-manage)
 Tasks: 7 (limit: 4558)
  Memory: 28.6M
     CPU: 240ms
CGroup: /system.slice/flamenco-manager.service
        └─3059 /home/user/flamenco-3.7-linux-amd64/flamenco-manager

Habilite el inicio automático al arrancar el sistema:

sudo systemctl enable flamenco-manager.service

Paso 5. Nodo trabajador

Conéctese al servidor VPN utilizando la guía del Paso 1 y monte el recurso compartido del Paso 3. Detenga el servicio VPN antes de continuar:

sudo snap install blender --classic

Los archivos *.blend modernos se comprimen con el algoritmo Zstandard. Para evitar errores, es esencial incorporar soporte para este algoritmo:

sudo apt -y install python3-zstd

Descargue la aplicación:

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Descomprime el archivo descargado:

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Navegue hasta el directorio creado:

cd flamenco-3.7-linux-amd64/

Cree un script adicional que habilite el renderizado GPU cuando se ejecuten trabajos de Flamenco:

nano gpurender.py

import bpy
def enable_gpus(device_type, use_cpus=False):
    preferences = bpy.context.preferences
    cycles_preferences = preferences.addons["cycles"].preferences
    cycles_preferences.refresh_devices()
    devices = cycles_preferences.devices
    if not devices:
        raise RuntimeError("Unsupported device type")
    activated_gpus = []
    for device in devices:
        if device.type == "CPU":
            device.use = use_cpus
        else:
            device.use = True
            activated_gpus.append(device.name)
            print('activated gpu', device.name)
    cycles_preferences.compute_device_type = device_type
    bpy.context.scene.cycles.device = "GPU"
    return activated_gpus
enable_gpus("CUDA")

Guarde el archivo y salga. A continuación, cree un servicio independiente para ejecutar Flamenco desde systemd:

sudo nano /etc/systemd/system/flamenco-worker.service

[Unit]
Description=Flamenco Worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu/flamenco-3.7-linux-amd64
ExecStart=/home/usergpu/flamenco-3.7-linux-amd64/flamenco-worker
Restart=always
[Install]
WantedBy=multi-user.target

Recarga la configuración e inicia el nuevo servicio:

sudo systemctl daemon-reload

sudo systemctl start flamenco-worker.service

sudo systemctl status flamenco-worker.service

● flamenco-worker.service - Flamenco Worker service
Loaded: loaded (/etc/systemd/system/flamenco-worker.service; enabled; preset: enabled)
Active: active (running) since Tue 2023-10-17 13:56:18 EEST; 47s ago
Main PID: 636 (flamenco-worker)
 Tasks: 5 (limit: 23678)
Memory: 173.9M
   CPU: 302ms
CGroup: /system.slice/flamenco-worker.service
        └─636 /home/user/flamenco-3.7-linux-amd64/flamenco-worker

Activar el inicio automático al arrancar el sistema:

sudo systemctl enable flamenco-worker.service

Paso 6. Nodo de usuario

El nodo de usuario se puede gestionar con cualquier sistema operativo. Para esta guía, mostramos cómo configurar un nodo con Windows 11 y 4 componentes necesarios:

Conexión VPN
Directorio remoto montado
Blender instalado
Complemento Flamenco

Descargue e instale Wireguard desde el sitio web oficial. Crea un nuevo archivo de texto y pega la configuración, generada para el cliente en el Paso 1. Cambie el nombre del archivo a flamenco.conf y añádalo en Wireguard utilizando el botón Add tunnel:

Conéctese a su servidor pulsando el botón Activate:

Vamos a montar un directorio remoto. Haz clic con el botón derecho en This PC y selecciona Map network drive…

Elige Z: como letra de unidad, escribe la dirección del recurso compartido Samba \\10.0.0.4\private y no olvides marcar Connect using different credentials. A continuación, haz clic en Finish. El sistema te pedirá que introduzcas un nombre de usuario y una contraseña para el recurso compartido. A continuación, el directorio de red se montará como unidad Z:.

Descarga e instala Blender desde el sitio web oficial. A continuación, abra la URL http://10.0.0.3:8080/flamenco3-addon.zip e instale el complemento Flamenco. Actívalo en preferencias: Edit > Preferences > Add-ons. Marque System: Flamenco 3, introduzca la URL del Gestor http://10.0.0.3:8080, y pulse el botón actualizar. El sistema se conectará al nodo gestor y cargará la configuración de almacenamiento automáticamente:

Abra el archivo que necesita renderizar. En la pestaña Scene, seleccione Cycles de la lista desplegable Renderizar Engine. No olvides guardar el archivo, ya que estos ajustes se almacenan directamente en el archivo *.blend:

Desplázate hacia abajo y encuentra la sección Flamenco 3. Haz clic en Fetch job types para obtener una lista de los tipos disponibles. Selecciona Simple Blender Render en la lista desplegable y configura otras opciones, como el número de fotogramas, el tamaño de los trozos y la carpeta de salida. Por último, haz clic en Submit to Flamenco:

El complemento Flamenco crea un nuevo trabajo y carga un archivo de mezcla en el almacenamiento compartido. El sistema enviará el trabajo a un trabajador disponible e iniciará el proceso de renderizado:

Si compruebas la carga de la GPU con nvtop o utilidades similares, mostrará que todas las GPUs tienen tareas de computación:

Encontrarás el resultado en el directorio que hayas seleccionado en el paso anterior. Ejemplo aquí (Ripple Dreams por James Redmond)

Véase también:

Fotogrametría con Meshroom

Tue, 21 Jan 2025 09:38:44 +0100

La fotogrametría es un método de transformación de objetos físicos en modelos digitales tridimensionales que pueden editarse con software 3D. En este proceso se suelen utilizar dispositivos especializados llamados escáneres 3D, que son de dos tipos principales: ópticos y láser.

Los escáneres ópticos suelen utilizar una o varias cámaras digitales e iluminación especial para iluminar uniformemente el objeto durante el escaneado. Esto permite crear un modelo 3D. Los escáneres láser, por su parte, utilizan rayos láser. Estos dispositivos emiten múltiples rayos láser y miden el tiempo que tarda cada rayo en rebotar en el objeto. A partir de estos datos, junto con la información de los sensores de posición, el escáner calcula la distancia a cada punto del objeto. Así se crea una "nube de puntos" que constituye la base del modelo 3D.

Nube de puntos

Para construir el futuro marco de un objeto, el sistema necesita conocer las coordenadas de cada vértice en el espacio tridimensional. El conjunto de vértices se denomina nube de puntos. Cuantos más vértices haya, más detallado será el objeto. Crear una nube de puntos es el primer paso, y uno de los más cruciales, para recrear un modelo 3D a partir de fotografías.

Es importante tener en cuenta que cada vértice de la nube de puntos está inicialmente desconectado de otros vértices. Esto permite un filtrado sencillo: mantener los puntos necesarios y eliminar el resto, antes de empezar a recrear la malla del objeto.

Objetos de malla

Un objeto de malla es un tipo de modelo 3D formado por primitivas geométricas triangulares, a menudo denominadas mallas o polimallas. Una vez formados los puntos del objeto, la aplicación puede componer independientemente primitivas triangulares a partir de ellos. Conectando estas primitivas, es posible crear un modelo 3D de casi cualquier forma. En esta fase, el modelo carece de color y permanece sin pintar.

La etapa de texturizado posterior resuelve este problema.

Texturizado

La última etapa consiste en aplicar la textura de la imagen extraída de las fotos al objeto de malla preparado. La calidad de las fotos tomadas y su resolución desempeñan aquí un papel fundamental. Si es baja, el resultado final no tendrá el mejor aspecto. Pero si se ha tomado un número suficiente de fotos de buena calidad, entonces a la salida recibirás un modelo 3D totalmente listo para usar de un objeto real. A continuación daremos algunos consejos útiles para preparar las fotos originales.

Ajustes de la cámara

Para evitar decepciones en tus primeros intentos de crear un modelo 3D a partir de fotografías, ten en cuenta estas sencillas reglas básicas. Cada regla ayudará a evitar problemas que suelen surgir durante la fase de creación del objeto de malla.

En primer lugar, no confíes en los ajustes automáticos de tu cámara digital. Las cámaras modernas intentan equilibrar cuatro parámetros clave de forma independiente:

ISO,
el balance de blancos,
velocidad de obturación,
apertura.

En modo automático, incluso pequeños cambios en las condiciones externas pueden hacer que estos ajustes varíen entre fotogramas. Estas variaciones pueden provocar incoherencias notables durante la fase de texturizado.

Para mantener parámetros consistentes entre fotogramas, utilice el modo Manual (M). La apertura es un ajuste crucial aquí. Dependiendo de tu objetivo, busca una posición en la que esté casi cerrado. Esto ayuda a conseguir la máxima profundidad de campo: cuanto menos abierto esté el diafragma, mejor. Sin embargo, evita los valores extremos. Si tu objetivo puede acercarse a f/22, obtendrás buenos resultados utilizando valores entre f/11 y f/20.

^{Izquierda f/11, derecha f/22}

Cerrar el diafragma, sin embargo, crea otro problema: luz insuficiente. Esto se puede solucionar de dos formas: aumentando la sensibilidad ISO o alargando la velocidad de obturación. Ambos métodos afectarán al resultado final, aunque de forma diferente. Aumentar la ISO a 6400 introduce ruido digital en la imagen, por lo que es mejor utilizar los valores más bajos posibles. Para obtener unos resultados casi ideales, tiene sentido ajustar el ISO a 100. Sin embargo, esto significa que persiste el problema de la iluminación insuficiente:

^{Izquierda ISO 100, derecha ISO 6400}

La forma más eficaz de aumentar la luz que pasa a través del sensor de la cámara en condiciones de poca luz es alargar la velocidad de obturación. Cuanto más tiempo permanezca abierto el obturador, más fotones llegarán al sensor, lo que se traducirá en una mejor calidad de imagen. Sin embargo, este enfoque presenta un reto: sin trípode, una velocidad de obturación de 1/50 segundos o más puede desenfocar la imagen. El uso de un trípode elimina este problema.

El balance de blancos es el último parámetro crucial. Es importante desactivar el ajuste automático y elegir un perfil preestablecido (como "Día soleado") o un valor personalizado en Kelvin. Por ejemplo, 5200K es un ajuste habitual. Los valores más bajos desplazan el tono hacia el amarillo, mientras que los más altos se inclinan hacia el azul. Para evitar correcciones de color en el post-procesado, utiliza el mismo perfil de balance de blancos para todas las fotos de una serie.

^{Perfiles de balance de blancos. Izquierda "Día soleado", derecha "Auto".}

En resumen, para capturar fotos de alta calidad para fotogrametría:

Utilice un trípode cuando no haya suficiente luz.
Cierre el diafragma casi al mínimo.
Ajusta el ISO a su valor mínimo.
Elija una velocidad de obturación que le proporcione el resultado deseado (o utilice el exposímetro integrado de su cámara).
Utiliza el mismo preajuste de balance de blancos.

Hacer fotos

Hablemos de cuántas fotos hay que hacer y desde qué ángulos. El tipo de objeto y su fondo influyen significativamente en el resultado final. Los objetos sin superficies brillantes, transparentes o reflectantes son ideales para la fotogrametría. En la práctica, objetos como ventanas y cristales suelen requerir correcciones posteriores en un editor 3D. Sin embargo, la técnica general de toma sigue siendo la misma.

Para objetos pequeños situados sobre una superficie, imagine una esfera alrededor del objeto. Haz fotos como si tu cámara rodeara el objeto tres veces: una desde abajo, otra en el centro y otra desde arriba.

Es fundamental que el objeto ocupe al menos la mitad, preferiblemente las tres cuartas partes de cada fotograma. En lugar de utilizar el zoom, intenta acercarte físicamente al objeto. Al crear un punto de nube, el software necesita tantos píxeles como sea posible.

Al disparar, recuerda que el software combina los fotogramas en un único objeto para obtener una geometría correcta. Ten por norma tomar al menos tres fotogramas desde cada ángulo. Una vez que hayas centrado el objeto en el encuadre, divídelo mentalmente en vertical en tres partes iguales. Tome tres fotografías, cada una enfocando un tercio del objeto. Esto proporciona el solapamiento necesario para que la aplicación calcule con precisión la ubicación de cada punto en el espacio 3D. Después de fotografiar el objeto desde todos los lados y ángulos posibles, puede empezar a preparar el software.

Instalar Meshroom

Meshroom es una aplicación gratuita y multiplataforma que realiza secuencialmente todas las etapas de procesamiento, utilizando los recursos de la CPU y la GPU. Aunque puede ejecutarse en un ordenador doméstico estándar, cada etapa puede llevar mucho tiempo. Para proyectos a gran escala que impliquen la reconstrucción 3D de numerosos objetos, como la creación de una impresionante escena 3D, alquilar un servidor GPU dedicado puede ser una solución práctica.

Consideremos un servidor LeaderGPU con la siguiente configuración: 2 x NVIDIA® RTX™ 3090, 2 x Intel® Xeon® Silver 4210 (3.20 GHz), 128GB RAM. Utilizaremos Windows Server 2022 como sistema operativo. Antes de instalar Meshroom, necesitarás realizar algunos pasos preliminares:

Visita la web oficial del proyecto para descargar Meshroom. Descomprime el archivo resultante para encontrar una aplicación lista para usar que no requiere instalación adicional. Inicia Meshroom.exe para comenzar.

Cargar imágenes

La ventana principal de la aplicación está dividida en dos partes: superior e inferior. La parte superior contiene la Galería de imágenes, el Visor de imágenes y el Visor 3D. La sección inferior alberga el Editor de gráficos y el Administrador de tareas. Para empezar, arrastre y suelte las fotos capturadas en el área designada. Se admiten tanto formatos de archivo comprimidos (por ejemplo, JPG) como RAW. Se recomienda utilizar archivos RAW porque contienen muchos más datos por cada fotograma.

Tenga en cuenta que, por defecto, ya dispone de una canalización estándar preparada, que se muestra esquemáticamente en el Editor de gráficos. Este es uno de los controles más importantes que ayuda a configurar todos los aspectos del procesamiento de imágenes en cada etapa. Puede ejecutar manualmente cada etapa haciendo clic con el botón derecho del ratón y seleccionando Compute en el menú desplegable.

Pero por primera vez, puede simplemente hacer clic en el botón verde Start, y la aplicación lo hará todo por usted. Le pedirá que guarde el proyecto, para que no pierda accidentalmente los resultados del cálculo. Haga clic en Save, especifique un nombre y un directorio y guarde el proyecto:

A continuación, la aplicación transfiere todas las etapas de procesamiento del Editor de Gráficos al Administrador de Tareas, que se encarga de su ejecución en un orden específico. Para comprobar el estado de cada etapa, seleccione el bloque correspondiente en el Editor gráfico y haga clic en el botón Log situado en la esquina inferior derecha de la pantalla. También puede ver en tiempo real qué etapa se está procesando en ese momento:

A la derecha, puedes ver la nube de puntos que has construido. El resultado final, generado utilizando el pipeline estándar, está disponible en el directorio:

[Your_Project_Path]\MeshroomCache\Texturing\[Random_Symbols]\texturedMesh.obj

Por supuesto, si fijas de antemano la ruta de salida en el nodo final del pipeline, el objeto acabará en la ruta que hayas especificado. Luego puedes importarlo a cualquier editor de texto para arreglar superficies, añadir fuentes de luz y otros efectos antes de renderizarlo.

Integración

Aunque el resultado inicial pueda parecer impresionante, a menudo es necesario refinarlo en un editor 3D. Meshroom simplifica este proceso permitiéndole importar no sólo el modelo, sino también la nube de puntos y las posiciones de la cámara en editores de terceros como Houdini o Blender. En la siguiente sección exploraremos cómo hacerlo.

Houdini

De hecho, Meshroom es una interfaz fácil de usar para el motor AliceVision, que se encarga de todas las operaciones relacionadas con el cálculo. Esta interfaz implementa el correspondiente pipeline y el gestor de tareas. Si utilizas Houdini, puedes crear tu propio pipeline directamente dentro de la aplicación y utilizarlo junto con otras herramientas, eliminando la necesidad de lanzar Meshroom por separado.

Para empezar, lo mejor es descargar e instalar un lanzador dedicado que gestione las actualizaciones y plugins de Houdini. A continuación, añade el plugin SideFX Labs, que ofrece numerosas herramientas adicionales, incluyendo nodos específicos para AliceVision. Para ello, haga clic en el botón +, a continuación, seleccione Shelves:

Desplázate hacia abajo en la lista y selecciona SideFX Labs, luego haz clic en el botón Update Toolset:

Para instalar un plugin, siga estos pasos: Haga clic en el botón Start Launcher, vaya a la sección Labs/Packages del menú de la izquierda y seleccione Install packages. Se abrirá una ventana en la que podrá elegir los paquetes que desee instalar:

Elija el Production Build para su versión de Houdini y haga clic en Install. Después, reinicia la aplicación para asegurarte de que los nuevos iconos de efectos aparecen en la parte superior:

Es crucial tener en cuenta que aquí no encontrarás ninguna mención a AliceVision o Meshlab. Esto se debe a que el plugin correspondiente sólo funciona dentro del pipeline de contexto de geometría. Para comprobarlo, haz clic en el icono +, luego selecciona New Pane Tab Type, y elige Network View:

Pulse la tecla Tab y añada un nodo Geometry:

Haga doble clic para abrir el nodo creado y escriba av en su teclado. El sistema mostrará instantáneamente una lista de nodos disponibles que comienzan con los símbolos Labs AV. Estos nodos te permiten controlar el motor AliceVision e integrarlo en tus propios pipelines:

Para crear un pipeline adecuado, consulta la documentación oficial del plugin. Además, considera añadir el directorio AliceVision a la lista de variables de entorno en el archivo houdini.env. Para una instalación estándar utilizando el lanzador, este archivo se encuentra normalmente en el directorio C:\Users\Administrator\Documents\houdini20.5\

Abra el archivo houdini.env con cualquier editor de texto y añada la siguiente línea:

ALICEVISION_PATH = [path to alicevision directory in Meshroom folder]

Por ejemplo, si instalaste Meshroom en el directorio raíz de la unidad D:, tu ruta podría tener este aspecto:

ALICEVISION_PATH = D:\Meshroom\aliceVision

Guarde el archivo, a continuación, reinicie la aplicación Houdini.

Blender

Para los usuarios de Blender, recomendamos el plugin Meshroom2Blender. Aunque funciona de forma diferente al plugin de Houdini, permite exportar nubes de puntos y posiciones de cámara calculadas por Meshroom a Blender. Para acceder al código del plugin, abra el enlace en su navegador:

https://raw.githubusercontent.com/tibicen/meshroom2blender/master/view3d_point_cloud_visualizer.py

Guarde el código como view3d_point_cloud_visualizer.py en un directorio conveniente. A continuación, abra Blender y navegue hasta Edit - Preferences. Desde allí, selecciona la pestaña Add-ons:

Haga clic en la flecha hacia abajo y seleccione Install from Disk:

En la ventana recién abierta, navega hasta el directorio donde guardaste el plugin. Seleccione el archivo del plugin y haga clic en Install from Disk button:

El plugin ya está instalado. Se recomienda reiniciar la aplicación. Después de reiniciar, verá el elemento Point Cloud Visualizer en el modo de visualización. El plugin requiere que especifique la ruta a un archivo con la extensión .ply:

Por defecto, Meshroom no genera este tipo de archivo. Para crearlo, abra el pipeline y añada el nodo ConvertSfMFormat. Utilice como entrada el SfMData del nodo StructureFromMotion. Para la salida, especifique el Images Folder del nodo Texturing.

El último paso es especificar el formato. Haga clic en SfM File Format en el nodo ConvertSfMFormat y seleccione ply en la lista desplegable:

Haga clic con el botón derecho del ratón en el nodo creado y seleccione Compute:

Una vez finalizado el proceso, encontrarás el archivo necesario en el directorio:

[Your_Project_Path]\MeshroomCache\ConvertSfMFormat\[Random_Symbols]\sfm.ply

Puede cargarlo en Blender de dos formas: a través del plugin mencionado o mediante el proceso de importación estándar File - Import - Stanford PLY (.ply):

Para más información sobre el uso de este plugin, sugerimos consultar el repositorio del proyecto o en algún recurso web especializado.

Conclusión

La fotogrametría es un amplio campo de conocimiento, en el que hemos intentado contar sólo algunas técnicas básicas para convertir imágenes 2D en un modelo 3D. Se utiliza en muchas industrias, desde la arquitectura hasta la creación de juegos de ordenador.

Una vez adquirida la primera experiencia en la toma de un conjunto de datos y su transformación coherente en un modelo 3D, podrás mejorar tus habilidades y transferir objetos físicos a un espacio 3D virtual. Pues bien, LeaderGPU te ayudará con la potencia de cálculo, reduciendo el tiempo de cálculo y liberando tu estación de trabajo para otras tareas, a menudo más prioritarias.

Ver también:

Open WebUI: Todo en uno

Mon, 20 Jan 2025 15:21:46 +0100

Open WebUI fue desarrollado originalmente para Ollama, de la que hablamos en uno de nuestros artículos. Anteriormente, se llamaba Ollama WebUI, pero con el tiempo, el enfoque cambió a la universalidad de la aplicación, y el nombre fue cambiado a Open WebUI. Este software resuelve el problema clave de trabajar cómodamente con grandes modelos de redes neuronales colocados localmente o en servidores controlados por el usuario.

Instalación

El método de instalación principal y más preferido es desplegar un contenedor Docker. Esto le permite no pensar en la presencia de dependencias u otros componentes que aseguren el correcto funcionamiento del software. Sin embargo, puedes instalar Open WebUI clonando el repositorio del proyecto desde GitHub y construyéndolo desde el código fuente. En este artículo, consideraremos ambas opciones.

Antes de empezar, asegúrate de que los controladores GPU están instalados en el servidor. Nuestra instrucción Instalar controladores NVIDIA® en Linux te ayudará a hacerlo.

Usando Docker

Si acabas de encargar un servidor, no dispondrás del motor Docker ni del conjunto de herramientas necesarias para pasar las GPU al contenedor. No recomendamos instalar Docker desde el repositorio estándar de Ubuntu, ya que puede estar desactualizado y no soportar todas las opciones modernas. Sería mejor utilizar el script de instalación publicado en el sitio web oficial:

curl -sSL https://get.docker.com/ | sh

Además de Docker, necesitas instalar el NVIDIA® Container Toolkit, así que activa el repositorio de Nvidia:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualiza tu caché de paquetes e instala NVIDIA® Container Toolkit:

sudo apt update && sudo apt -y install nvidia-container-toolkit

Para que la cadena de herramientas funcione, tendrás que reiniciar el demonio Docker:

sudo systemctl restart docker

Ahora puedes ejecutar el contenedor deseado. Tenga en cuenta que el siguiente comando no aísla los contenedores de la red host porque más tarde puede habilitar opciones adicionales, tales como la generación de imágenes utilizando la WebUI de Stable Diffusion. Este comando descargará y ejecutará automáticamente todas las capas de la imagen:

sudo docker run -d --network=host --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Usando Git

Ubuntu 22.04

Primero, necesitas clonar el contenido del repositorio:

git clone https://github.com/open-webui/open-webui.git

Abre el directorio descargado:

cd open-webui/

Copia la configuración de ejemplo (puedes modificarla si es necesario), que establecerá las variables de entorno para la compilación:

cp -RPp .env.example .env

Instala el instalador NVM, que te ayudará a instalar la versión necesaria de Node.js en el servidor:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Después de eso, es necesario cerrar y volver a abrir la sesión SSH para que el siguiente comando funcione correctamente.

Instalar Node Package Manager:

sudo apt -y install npm

Instala Node.js versión 22 (actual en el momento de escribir este artículo):

npm install 22

Instalar las dependencias necesarias para el posterior montaje:

npm install

Comencemos la compilación. Tenga en cuenta que requiere más de 4 GB de RAM libre:

npm run build

El frontend está listo; ahora es el momento de preparar el backend. Ve al directorio con el mismo nombre:

cd ./backend

Instala los paquetes pip y ffmpeg:

sudo apt -y install python3-pip ffmpeg

Antes de la instalación, es necesario añadir una nueva ruta a la variable de entorno:

sudo nano ~/.bashrc

Añada la siguiente línea al final del archivo:

export PATH="/home/usergpu/.local/bin:$PATH"

Actualicémoslo a la última versión:

python3 -m pip install --upgrade pip

Ahora puedes instalar las dependencias:

pip install -r requirements.txt -U

Instalar Ollama:

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

Todo está listo para lanzar la aplicación:

bash start.sh

Ubuntu 24.04 / 24.10

Cuando instales OpenWebUI en Ubuntu 24.04/24.10, te enfrentarás a un reto clave: el sistema operativo usa Python 3.12 por defecto, mientras que OpenWebUI solo soporta la versión 3.11. No puedes simplemente downgradear Python, hacerlo rompería el sistema operativo. Como el paquete python3.11 no está disponible en los repositorios estándar, necesitarás crear un entorno virtual para usar la versión correcta de Python.

La mejor solución es utilizar el sistema de gestión de paquetes Conda. Conda funciona como pip pero añade soporte de entorno virtual similar a venv. Dado que sólo necesitas una funcionalidad básica, utilizarás Miniconda, una distribución ligera. Descarga la última versión desde GitHub:

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

Ejecuta el script:

bash Miniforge3-$(uname)-$(uname -m).sh

Creemos un entorno virtual llamado pyenv y especifiquemos la versión 3.11 de Python:

conda create -n pyenv python=3.11

Activemos el entorno creado:

conda activate pyenv

Ahora puedes proceder con los pasos estándar de instalación de OpenWebUI para Ubuntu 22.04. El entorno virtual asegura que todos los scripts de instalación se ejecutarán sin problemas y sin conflictos de versiones de paquetes.

Modelos

Biblioteca Ollama

Open WebUI le permite cargar modelos directamente desde la interfaz web, especificando únicamente el nombre en el formato model:size. Para ello, vaya a http://192.168.88.20:8080/admin/settings y haga clic en Connections. A continuación, haga clic en el icono de llave inglesa situado frente a la cadena http://localhost:11434. Después de ver los nombres de los modelos de la biblioteca, introduzca su nombre y haga clic en el icono de carga:

A continuación, el sistema descargará automáticamente el modelo deseado, que quedará inmediatamente disponible para su uso. Dependiendo del tamaño seleccionado, la descarga puede tardar un tiempo diferente. Antes de realizar la descarga, asegúrese de que hay espacio suficiente en la unidad de disco. Para más información, consulte el artículo Particionamiento del disco en Linux.

Modelos personalizados

Si necesita integrar un modelo de red neuronal que no se encuentra en la biblioteca Ollama, puede utilizar la función experimental y cargar cualquier modelo arbitrario en formato GGUF. Para ello, vaya a Settings - Admin Settings - Connections y haga clic en el icono de llave inglesa situado frente a http://localhost:11434. Haga clic en Show en la sección Experimental. Por defecto, está activado el modo archivo, que permite cargar un archivo desde el ordenador local. Si hace clic en File Mode, cambiará a URL Mode, que le permite especificar la URL del archivo modelo, y el servidor lo descargará automáticamente:

RAG

Además de una interfaz web cómoda y funcional, Open WebUI ayuda a ampliar las capacidades de los distintos modelos, garantizando su uso conjunto. Por ejemplo, es fácil cargar documentos para formar una base de datos vectorial RAG (Retrieval-augmented generation). En el proceso de generación de una respuesta al usuario, LLM podrá basarse no sólo en los datos obtenidos directamente como resultado del entrenamiento, sino también en los colocados en una base de datos vectorial similar.

Documentos

Por defecto, Open WebUI escanea el directorio /data/docs en busca de archivos que puedan ser colocados en el espacio vectorial de la base de datos y realiza la transformación utilizando el modelo incorporado all-MiniLM-L6-v2. Este no es el único modelo adecuado para esta tarea, por lo que tiene sentido probar otras opciones, por ejemplo, de esta lista.

Los documentos de texto, sin etiquetas ni otros caracteres especiales, son los más adecuados para el GAR. Por supuesto, puede cargar documentos tal cual, pero esto puede afectar en gran medida a la precisión de las respuestas generadas. Por ejemplo, si tienes una base de conocimientos en formato Markdown, primero puedes limpiarla de formato y sólo después subirla a /data/docs.

Búsqueda web

Además de los documentos locales, se puede ordenar al modelo de red neuronal que utilice cualquier sitio web como fuente de datos. Esto le permitirá responder a preguntas utilizando no sólo los datos con los que fue entrenado, sino también datos alojados en sitios web especificados por el usuario.

De hecho, se trata de un tipo de RAG, que recibe páginas HTML como entrada y luego las transforma de una manera especial, ocupando su lugar en una base de datos vectorial. La búsqueda en dicha base de datos será muy rápida; por lo tanto, el modelo de red neuronal podrá generar rápidamente una respuesta basada en sus resultados. Open WebUI soporta diferentes motores de búsqueda, pero sólo puede trabajar con uno a la vez, que se especifica en la configuración.

Para incluir los resultados de la búsqueda web en las respuestas de la red neuronal, haz clic en + (símbolo más) y desliza el interruptor de Búsqueda web:

Generación de imágenes

Lo más destacado de Open WebUI es que este software permite combinar varias redes neuronales con diferentes tareas para resolver un mismo problema. Por ejemplo, Llama 3.1 dialoga perfectamente con el usuario en varios idiomas, pero sus respuestas serán exclusivamente texto. No puede generar imágenes, por lo que no hay forma de ilustrar sus respuestas.

Stable Diffusion, sobre la que hemos escrito a menudo, es lo contrario: esta red neuronal genera imágenes perfectamente, pero no puede trabajar con textos en absoluto. Los desarrolladores de Open WebUI intentaron combinar los puntos fuertes de ambas redes neuronales en un diálogo e implementaron el siguiente esquema de trabajo.

Cuando realizas un diálogo en Open WebUI, aparece un botón especial junto a cada respuesta de la red neuronal. Al hacer clic en él, recibirás una ilustración de esta respuesta directamente en el chat:

Esto se consigue llamando a la API de Difusión Estable WebUI, y por el momento, están disponibles una conexión con versiones de Automatic1111 y una conexión con ComfyUI. También puede generar imágenes a través de la red neuronal Dall-E, pero no se puede implementar localmente - se trata de un servicio de generación de imágenes de pago con código fuente cerrado.

Esta característica sólo funcionará si, además de Open WebUI con Ollama, Stable Diffusion WebUI está instalado en el servidor. Puedes encontrar las instrucciones de instalación aquí. Lo único que vale la pena mencionar es que al ejecutar el script ./webui.sh, tendrá que especificar una clave adicional para habilitar la API:

./webui.sh --listen --api --gradio-auth user:password

Otro escollo puede surgir debido a la falta de memoria de vídeo. Si te encuentras con esto, puedes utilizar dos claves útiles: --medvram y --lowvram. Esto evitará el error Out-of-memory al iniciar la generación.

Ver también:

¿Cómo funciona Ollama?

Mon, 20 Jan 2025 15:16:02 +0100

Ollama es una herramienta para ejecutar localmente grandes modelos de redes neuronales. El uso de servicios públicos suele ser percibido por las empresas como un riesgo potencial de fuga de datos confidenciales y sensibles. Por ello, desplegar LLM en un servidor controlado permite gestionar de forma independiente los datos depositados en él, al tiempo que se aprovechan los puntos fuertes de LLM.

Esto también ayuda a evitar la desagradable situación de "vendor lock-in", en la que cualquier servicio público puede dejar de prestar servicios unilateralmente. Por supuesto, el objetivo inicial es permitir el uso de redes neuronales generativas en lugares donde no hay acceso a Internet o éste es difícil (por ejemplo, en un avión).

La idea era simplificar el lanzamiento, control y puesta a punto de las LLM. En lugar de complejas instrucciones de varios pasos, Ollama permite ejecutar un simple comando y recibir el resultado final al cabo de un tiempo. Se presentará simultáneamente en forma de modelo de red neuronal local, con el que podrá comunicarse mediante una interfaz web y una API para integrarlo fácilmente en otras aplicaciones.

Para muchos desarrolladores, esto se convirtió en una herramienta muy útil, ya que en la mayoría de los casos era posible integrar Ollama con el IDE utilizado y recibir recomendaciones o código ya escrito directamente mientras se trabajaba en la aplicación.

En un principio, Ollama estaba destinado únicamente a ordenadores con el sistema operativo macOS, pero más tarde fue portado a Linux y Windows. También se ha lanzado una versión especial para trabajar en entornos contenerizados como Docker. Actualmente, funciona igual de bien tanto en ordenadores de sobremesa como en cualquier servidor dedicado con una GPU. Ollama admite la posibilidad de cambiar entre distintos modelos de forma inmediata y maximiza todos los recursos disponibles. Por supuesto, estos modelos pueden no rendir tan bien en un escritorio normal, pero funcionan bastante adecuadamente.

Cómo instalar Ollama

Ollama puede instalarse de dos maneras: sin utilizar la contenedorización, mediante un script de instalación, y como un contenedor Docker ya preparado. El primer método facilita la gestión de los componentes del sistema y los modelos instalados, pero es menos tolerante a fallos. El segundo método es más tolerante a fallos, pero al utilizarlo hay que tener en cuenta todos los aspectos inherentes a los contenedores: una gestión algo más compleja y un enfoque diferente del almacenamiento de datos.

Independientemente del método elegido, se necesitan varios pasos adicionales para preparar el sistema operativo.

Requisitos previos

Actualizar el repositorio caché de paquetes y los paquetes instalados:

sudo apt update && sudo apt -y upgrade

Instale todos los controladores de GPU necesarios utilizando la función de instalación automática:

sudo ubuntu-drivers autoinstall

Reinicie el servidor:

sudo shutdown -r now

Instalación mediante script

El siguiente script detecta la arquitectura actual del sistema operativo e instala la versión adecuada de Ollama:

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

Durante la operación, el script creará un usuario ollama separado, bajo el cual se lanzará el demonio correspondiente. Por cierto, el mismo script funciona bien en WSL2, permitiendo la instalación de la versión Linux de Ollama en Windows Server.

Instalación mediante Docker

Existen varios métodos para instalar el motor Docker en un servidor. La forma más sencilla es utilizar un script específico que instale la versión actual de Docker. Este método es eficaz para Ubuntu Linux, desde la versión 20.04 (LTS) hasta la última versión, Ubuntu 24.04 (LTS):

curl -sSL https://get.docker.com/ | sh

Para que los contenedores Docker interactúen correctamente con la GPU, es necesario instalar un kit de herramientas adicional. Dado que no está disponible en los repositorios básicos de Ubuntu, es necesario añadir primero un repositorio de terceros mediante el siguiente comando:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Actualizar el repositorio caché de paquetes:

sudo apt update

E instala el paquete nvidia-container-toolkit:

sudo apt install nvidia-container-toolkit

No olvides reiniciar el demonio docker a través de systemctl:

sudo systemctl restart docker

Es hora de descargar y ejecutar Ollama con la interfaz web Open-WebUI:

sudo docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Abra el navegador web y navegue a http://[server-ip]:3000:

Descargar y ejecutar los modelos

A través de la línea de comandos

Basta con ejecutar el siguiente comando:

ollama run llama3

A través de WebUI

Abra Settings > Models, escriba el nombre del modelo necesario, por ejemplo, llama3 y haga clic en el botón con el símbolo de descarga:

El modelo se descargará e instalará automáticamente. Una vez completada, cierra la ventana de configuración y selecciona el modelo descargado. A continuación, podrás iniciar un diálogo con él:

Integración de VSCode

Si ha instalado Ollama utilizando el script de instalación, podrá ejecutar cualquiera de los modelos soportados casi al instante. En el siguiente ejemplo, ejecutaremos el modelo por defecto esperado por la extensión Ollama Autocoder (openhermes2.5-mistral:7b-q4_K_M):

ollama run openhermes2.5-mistral:7b-q4_K_M

Por defecto, Ollama permite trabajar a través de una API, permitiendo únicamente conexiones desde el host local. Por lo tanto, antes de instalar y utilizar la extensión para Visual Studio Code, es necesario redireccionar puertos. En concreto, es necesario redirigir el puerto remoto 11434 al equipo local. Puede encontrar un ejemplo de cómo hacerlo en nuestro artículo sobre Easy Diffusion WebUI.

Escriba Ollama Autocoder en el campo de búsqueda y haga clic en Install:

Después de instalar la extensión, un nuevo elemento titulado Autocomplete with Ollama estará disponible en la paleta de comandos. Comience a codificar e inicie este comando.

La extensión se conectará al servidor LeaderGPU utilizando el reenvío de puertos y, en unos segundos, el código generado aparecerá en su pantalla:

Puede asignar este comando a una tecla de acceso rápido. Utilízalo siempre que quieras complementar tu código con un fragmento generado. Éste es sólo un ejemplo de las extensiones VSCode disponibles. El principio del reenvío de puertos desde un servidor remoto a un ordenador local permite configurar un único servidor con un LLM en ejecución para todo un equipo de desarrolladores. Esta garantía impide que terceras empresas o piratas informáticos utilicen el código enviado.

Ver también:

PrivateGPT: IA para documentos

Mon, 20 Jan 2025 12:01:00 +0100

Los grandes modelos lingüísticos han evolucionado mucho en los últimos años y se han convertido en herramientas eficaces para muchas tareas. El único problema de su uso es que la mayoría de los productos basados en estos modelos utilizan servicios ya preparados de terceras empresas. Este uso tiene el potencial de filtrar datos sensibles, por lo que muchas empresas evitan cargar documentos internos en servicios LLM públicos.

Un proyecto como PrivateGPT podría ser una solución. En principio, está diseñado para un uso totalmente local. Su punto fuerte es que puedes enviar varios documentos como entrada, y la red neuronal los leerá por ti y proporcionará sus propios comentarios en respuesta a tus peticiones. Por ejemplo, puedes "alimentarla" con textos extensos y pedirle que saque algunas conclusiones basadas en la petición del usuario. Esto le permite ahorrar mucho tiempo en la corrección de textos.

Esto es especialmente cierto en campos profesionales como la medicina. Por ejemplo, un médico puede hacer un diagnóstico y pedir a la red neuronal que lo confirme basándose en el conjunto de documentos cargados. Esto permite obtener una opinión independiente adicional, reduciendo así el número de errores médicos. Como las solicitudes y los documentos no salen del servidor, se puede estar seguro de que los datos recibidos no aparecerán en el dominio público.

Hoy le mostraremos cómo desplegar una red neuronal en servidores LeaderGPU dedicados con el sistema operativo Ubuntu 22.04 LTS en tan sólo 20 minutos.

Preparación del sistema

Empieza por actualizar tus paquetes a la última versión:

sudo apt update && sudo apt -y upgrade

Ahora, instala paquetes adicionales, bibliotecas y el controlador gráfico de NVIDIA®. Todos ellos serán necesarios para compilar correctamente el software y ejecutarlo en la GPU:

sudo apt -y install build-essential git gcc cmake make openssl libssl-dev libbz2-dev libreadline-dev libsqlite3-dev zlib1g-dev libncursesw5-dev libgdbm-dev libc6-dev zlib1g-dev libsqlite3-dev tk-dev libssl-dev openssl libffi-dev lzma liblzma-dev libbz2-dev

Instalación de CUDA® 12.4

Además del controlador, es necesario instalar el kit de herramientas NVIDIA® CUDA®. Estas instrucciones se han probado en CUDA® 12.4, pero todo debería funcionar también en CUDA® 12.2. Sin embargo, ten en cuenta que tendrás que indicar la versión que tienes instalada cuando especifiques la ruta a los archivos ejecutables.

Ejecute el siguiente comando secuencialmente:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-ubuntu2204.pin

sudo mv cuda-ubuntu2204.pin /etc/apt/preferences.d/cuda-repository-pin-600

wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo dpkg -i cuda-repo-ubuntu2204-12-4-local_12.4.0-550.54.14-1_amd64.deb

sudo cp /var/cuda-repo-ubuntu2204-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/

sudo apt-get update && sudo apt-get -y install cuda-toolkit-12-4

Puede encontrar más información sobre la instalación de CUDA® en nuestra Base de conocimientos. Ahora, reinicie el servidor:

sudo shutdown -r now

PyEnv install

Es hora de instalar una sencilla utilidad de control de versiones de Python llamada PyEnv. Este es un fork significativamente mejorado del proyecto similar para Ruby (rbenv), configurado para trabajar con Python. Se puede instalar con un script de una línea:

curl https://pyenv.run | bash

Ahora, necesitas añadir algunas variables al final del archivo script, que se ejecuta al iniciar sesión. Las tres primeras líneas son responsables del correcto funcionamiento de PyEnv, y la cuarta es necesaria para Poetry, que se instalará más tarde:

nano .bashrc

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
export PATH="/home/usergpu/.local/bin:$PATH"

Aplica la configuración que has hecho:

source .bashrc

Instala la versión 3.11 de Python:

pyenv install 3.11

Crear un entorno virtual para Python 3.11:

pyenv local 3.11

Instalación de poesía

La siguiente pieza del puzzle es Poetry. Se trata de un análogo de pip para la gestión de dependencias en proyectos Python. El autor de Poetry estaba cansado de lidiar constantemente con diferentes métodos de configuración, como setup.cfg, requirements.txt, MANIFEST.ini, y otros. Esto se convirtió en el motor para el desarrollo de una nueva herramienta que utiliza un archivo pyproject.toml, que almacena toda la información básica acerca de un proyecto, no sólo una lista de dependencias.

Instalar Poesía:

curl -sSL https://install.python-poetry.org | python3 -

PrivateGPT install

Ahora que todo está listo, puede clonar el repositorio PrivateGPT:

git clone https://github.com/imartinez/privateGPT

Ve al repositorio descargado:

cd privateGPT

Ejecute la instalación de dependencias utilizando Poetry mientras habilita los componentes adicionales:

ui - añade una interfaz web de gestión basada en Gradio a la aplicación backend;
embedding-huggingface - habilita el soporte para incrustar modelos descargados de HuggingFace;
llms-llama-cpp - añade soporte para la inferencia directa de modelos en formato GGUF;
vector-stores-qdrant - añade la base de datos vectorial qdrant.

poetry install --extras "ui embeddings-huggingface llms-llama-cpp vector-stores-qdrant"

Establezca su token de acceso a Hugging Face. Para más información, lea este artículo:

export HF_TOKEN="YOUR_HUGGING_FACE_ACCESS_TOKEN"

Ahora, ejecuta el script de instalación, que descargará automáticamente el modelo y los pesos (Meta Llama 3.1 8B Instruct por defecto):

poetry run python scripts/setup

El siguiente comando recompilar llms-llama-cpp por separado para habilitar el soporte de NVIDIA® CUDA®, con el fin de descargar las cargas de trabajo a la GPU:

CUDACXX=/usr/local/cuda-12/bin/nvcc CMAKE_ARGS="-DGGML_CUDA=on -DCMAKE_CUDA_ARCHITECTURES=native" FORCE_CMAKE=1 pip install llama-cpp-python --no-cache-dir --force-reinstall --upgrade

Si aparece un error como nvcc fatal : Unsupported gpu architecture 'compute_', especifique la arquitectura exacta de la GPU que está utilizando. Por ejemplo DCMAKE_CUDA_ARCHITECTURES=86 para NVIDIA® RTX™ 3090.

El último paso antes de empezar es instalar el soporte para llamadas asíncronas (async/await):

pip install asyncio

PrivateGPT run

Ejecuta PrivateGPT utilizando un único comando:

make run

Abra su navegador web y vaya a la página http://[LeaderGPU_server_IP_address]:8001

Ver también:

Qwen 2 vs Llama 3

Mon, 20 Jan 2025 11:27:11 +0100

Los grandes modelos lingüísticos (LLM) han tenido un gran impacto en nuestras vidas. A pesar de comprender su estructura interna, estos modelos siguen siendo un foco de atención para los científicos, que a menudo los comparan con una "caja negra". El resultado final depende no sólo del diseño del LLM, sino también de su entrenamiento y de los datos utilizados para éste.

Mientras que los científicos encuentran oportunidades de investigación, a los usuarios finales les interesan sobre todo dos cosas: la velocidad y la calidad. Estos criterios desempeñan un papel crucial en el proceso de selección. Para comparar con precisión dos LLM, es necesario estandarizar muchos factores aparentemente no relacionados.

El equipo utilizado para las interferencias y el entorno de software, incluidos el sistema operativo, las versiones de los controladores y los paquetes de software, son los que más influyen. Es esencial seleccionar una versión de LLM que funcione en varios equipos y elegir una métrica de velocidad que sea fácilmente comprensible.

Como métrica hemos seleccionado "tokens por segundo" (tokens/s). Es importante tener en cuenta que un token ≠ una palabra. El LLM descompone las palabras en componentes más simples, típicos de un idioma concreto, denominados tokens.

La predictibilidad estadística del siguiente carácter varía de un idioma a otro, por lo que la tokenización será diferente. Por ejemplo, en inglés, de cada 75 palabras se obtienen aproximadamente 100 tokens. En las lenguas que utilizan el alfabeto cirílico, el número de fichas por palabra puede ser mayor. Así, 75 palabras en una lengua cirílica, como el ruso, podrían equivaler a 120-150 tokens.

Puedes comprobarlo con la herramienta Tokenizer de OpenAI. Muestra en cuántos tokens se divide un fragmento de texto, lo que convierte a los 'tokens por segundo' en un buen indicador de la velocidad y el rendimiento del procesamiento del lenguaje natural de un LLM.

Cada prueba se realizó en el sistema operativo Ubuntu 22.04 LTS con los controladores de NVIDIA® versión 535.183.01 y el kit de herramientas NVIDIA® CUDA® 12.5 instalados. Se formularon preguntas para evaluar la calidad y velocidad del LLM. La velocidad de procesamiento de cada respuesta se registró y contribuirá al valor medio de cada configuración probada.

Comenzamos probando varias GPU, desde los modelos más recientes hasta los más antiguos. Una condición crucial para la prueba era que midiéramos el rendimiento de una sola GPU, aunque hubiera varias en la configuración del servidor. Esto se debe a que el rendimiento de una configuración con varias GPU depende de factores adicionales como la presencia de una interconexión de alta velocidad entre ellas (NVLink).

Además de la velocidad, también intentamos evaluar la calidad de las respuestas en una escala de 5 puntos, donde 5 representa el mejor resultado. Esta información se facilita aquí únicamente para una comprensión general. Cada vez, plantearemos las mismas preguntas a la red neuronal e intentaremos discernir con qué precisión comprende cada una lo que el usuario quiere de ella.

Qwen 2

Recientemente, un equipo de desarrolladores de Alibaba Group presentó la segunda versión de su red neuronal generativa Qwen. Entiende 27 idiomas y está bien optimizada para ellos. Qwen 2 se presenta en distintos tamaños para facilitar su implantación en cualquier dispositivo (desde sistemas embebidos con recursos muy limitados hasta un servidor dedicado con GPU):

0,5B: adecuado para IoT y sistemas embebidos;
1,5B: versión ampliada para sistemas embebidos, utilizada cuando las capacidades de 0,5B no son suficientes;
7B: modelo de tamaño medio, muy adecuado para el procesamiento del lenguaje natural;
57B: modelo grande de alto rendimiento, adecuado para aplicaciones exigentes;
72B: el modelo Qwen 2 definitivo, diseñado para resolver los problemas más complejos y procesar grandes volúmenes de datos.

Las versiones 0.5B y 1.5B se entrenaron en conjuntos de datos con una longitud de contexto de 32K. Las versiones 7B y 72B se entrenaron ya con el contexto de 128K. El modelo de compromiso 57B se entrenó en conjuntos de datos con una longitud de contexto de 64K. Los creadores posicionan Qwen 2 como un análogo de Llama 3 capaz de resolver los mismos problemas, pero mucho más rápido.

Llama 3

La tercera versión de la red neuronal generativa de la familia MetaAI Llama se presentó en abril de 2024. Fue lanzada, a diferencia de Qwen 2, sólo en dos versiones: 8B y 70B. Estos modelos se posicionaron como una herramienta universal para resolver muchos problemas en diversos casos. Continuaba la tendencia hacia el multilingüismo y la multimodalidad, al tiempo que se hacía más rápida que las versiones anteriores y admitía una mayor longitud de contexto.

Los creadores de Llama 3 intentaron afinar los modelos para reducir el porcentaje de alucinaciones estadísticas y aumentar la variedad de respuestas. Así, Llama 3 es muy capaz de dar consejos prácticos, ayudar a redactar una carta comercial o especular sobre un tema especificado por el usuario. Los conjuntos de datos en los que se entrenaron los modelos de Llama 3 tenían una longitud de contexto de 128K y más del 5% incluían datos en 30 idiomas. Sin embargo, como se afirma en el comunicado de prensa, el rendimiento de la generación en inglés será significativamente mayor que en cualquier otro idioma.

Comparación

NVIDIA® RTX™ A6000

Empecemos nuestras mediciones de velocidad con la GPU NVIDIA® RTX™ A6000, basada en la arquitectura Ampere (no confundir con la NVIDIA® RTX™ A6000 Ada). Esta tarjeta tiene unas características muy modestas, pero al mismo tiempo dispone de 48 GB de VRAM, lo que le permite funcionar con modelos de redes neuronales bastante grandes. Por desgracia, la baja velocidad de reloj y el escaso ancho de banda son las razones de la baja velocidad de inferencia de los LLM de texto.

Inmediatamente después de su lanzamiento, la red neuronal Qwen 2 empezó a superar a Llama 3. Al responder a las mismas preguntas, la diferencia media de velocidad fue del 24% a favor de Qwen 2. La velocidad de generación de respuestas se situó en el rango de 11-16 tokens por segundo. Esto es 2-3 veces más rápido que intentar ejecutar la generación incluso en una CPU potente, pero en nuestra clasificación, este es el resultado más modesto.

NVIDIA® RTX™ 3090

La siguiente GPU también se basa en la arquitectura Ampere, tiene 2 veces menos memoria de vídeo, pero al mismo tiempo, funciona a una frecuencia más alta (19500 MHz frente a 16000 Mhz). El ancho de banda de la memoria de vídeo también es mayor (936,2 GB/s frente a 768 GB/s). Ambos factores aumentan considerablemente el rendimiento de la RTX™ 3090, incluso teniendo en cuenta que tiene 256 núcleos CUDA® menos.

Aquí se ve claramente que Qwen 2 es mucho más rápida (hasta un 23%) que Llama 3 al realizar las mismas tareas. En cuanto a la calidad de la generación, el soporte multilingüe de Qwen 3 es realmente digno de elogio, y el modelo siempre responde en el mismo idioma en el que se formuló la pregunta. Con Llama 3, en este sentido, ocurre a menudo que el modelo entiende la pregunta en sí, pero prefiere formular las respuestas en inglés.

NVIDIA® RTX™ 4090

Ahora lo más interesante: veamos cómo la NVIDIA® RTX™ 4090, construida sobre la arquitectura Ada Lovelace, llamada así por la matemática inglesa Augusta Ada King, condesa de Lovelace, se enfrenta a la misma tarea. Se hizo famosa por ser la primera programadora de la historia de la humanidad, y en el momento de escribir su primer programa no existía ningún ordenador ensamblado que pudiera ejecutarlo. Sin embargo, se reconoció que el algoritmo descrito por Ada para calcular los números de Bernoulli fue el primer programa del mundo escrito para ser ejecutado en un ordenador.

El gráfico muestra claramente que la RTX™ 4090 hizo frente a la inferencia de ambos modelos casi el doble de rápido. Es interesante que en una de las iteraciones Llama 3 consiguiera superar a Qwen 2 en un 1,2%. Sin embargo, teniendo en cuenta las demás iteraciones, Qwen 2 mantuvo su liderazgo, siendo un 7% más rápido que Llama 3. En todas las iteraciones, la calidad de las respuestas de ambas redes neuronales fue alta, con un número mínimo de alucinaciones. El único defecto es que en contadas ocasiones se mezclaron uno o dos caracteres chinos en las respuestas, lo que no afectó en absoluto al significado global.

NVIDIA® RTX™ A40

La siguiente tarjeta NVIDIA® RTX™ A40, con la que realizamos pruebas similares, se basa de nuevo en la arquitectura Ampere y cuenta con 48 GB de memoria de vídeo en la placa base. Comparada con la RTX™ 3090, esta memoria es ligeramente más rápida (20000 MHz frente a 19500 MHz), pero tiene menor ancho de banda (695,8 GB/s frente a 936,2 GB/s). La situación se compensa con el mayor número de núcleos CUDA® (10752 frente a 10496), lo que en conjunto permite a la RTX™ A40 rendir ligeramente más rápido que la RTX™ 3090.

En cuanto a la comparación de la velocidad de los modelos, aquí Qwen 2 también está por delante de Llama 3 en todas las iteraciones. Cuando se ejecuta en RTX™ A40, la diferencia de velocidad es de aproximadamente un 15% con las mismas respuestas. En algunas tareas, Qwen 2 dio un poco más de información importante, mientras que Llama 3 fue lo más específico posible y dio ejemplos. A pesar de ello, hay que comprobarlo todo dos veces, ya que a veces ambos modelos empiezan a dar respuestas controvertidas.

NVIDIA® L20

La última participante en nuestras pruebas fue la NVIDIA® L20. Esta GPU está construida como la RTX™ 4090, sobre la arquitectura Ada Lovelace. Se trata de un modelo bastante nuevo, presentado en otoño de 2023. A bordo, tiene 48 GB de memoria de vídeo y 11776 núcleos CUDA®. El ancho de banda de memoria es inferior al de la RTX™ 4090 (864 GB/s frente a 936,2 GB/s), al igual que la frecuencia efectiva. Por tanto, las puntuaciones de inferencia NVIDIA® L20 de ambos modelos estarán más cerca de la 3090 que de la 4090.

La prueba final no trajo sorpresas. Qwen 2 resultó ser más rápido que Llama 3 en todas las iteraciones.

Conclusión

Combinemos todos los resultados recogidos en un gráfico. Qwen 2 fue entre un 7% y un 24% más rápido que Llama 3 dependiendo de la GPU utilizada. Basándonos en esto, podemos concluir claramente que si necesitas obtener inferencia de alta velocidad de modelos como Qwen 2 o Llama 3 en configuraciones de una sola GPU, entonces el líder indiscutible será la RTX™ 3090. Una posible alternativa podría ser la A40 o la L20. Pero no merece la pena ejecutar la inferencia de estos modelos en tarjetas Ampere de la generación A6000.

Deliberadamente no mencionamos en las pruebas las tarjetas con una cantidad menor de memoria de vídeo, por ejemplo, NVIDIA® RTX™ 2080Ti, ya que no es posible encajar allí los modelos 7B u 8B antes mencionados sin cuantización. Pues bien, el modelo Qwen 2 de 1,5B, por desgracia, no tiene respuestas de alta calidad y no puede servir como sustituto completo del 7B.

Ver también:

Tu propio Qwen usando HF

Mon, 20 Jan 2025 09:43:46 +0100

Los modelos de grandes redes neuronales, con sus extraordinarias capacidades, están firmemente arraigados en nuestras vidas. Reconociendo esto como una oportunidad de desarrollo futuro, las grandes corporaciones empezaron a desarrollar sus propias versiones de estos modelos. El gigante chino Alibaba no se quedó de brazos cruzados. Crearon su propio modelo, QWen (Tongyi Qianwen), que se convirtió en la base de muchos otros modelos de redes neuronales.

Requisitos previos

Actualizar caché y paquetes

Actualicemos la caché de paquetes y actualicemos nuestro sistema operativo antes de empezar a configurar Qwen. Además, necesitamos añadir Python Installer Packages (PIP), si no está ya presente en el sistema. Ten en cuenta que para esta guía, estamos utilizando Ubuntu 22.04 LTS como sistema operativo:

sudo apt update && sudo apt -y upgrade && sudo apt install python3-pip

Instalar controladores NVIDIA®

Puede utilizar la utilidad automatizada que se incluye por defecto en las distribuciones de Ubuntu:

sudo ubuntu-drivers autoinstall

Alternativamente, puedes instalar los controladores NVIDIA® manualmente usando nuestra guía paso a paso. No olvides reiniciar el servidor:

sudo shutdown -r now

Interfaz web de generación de texto

Clonar el repositorio

Abra el directorio de trabajo en el SSD:

cd /mnt/fastdisk

Clona el repositorio del proyecto:

git clone https://github.com/oobabooga/text-generation-webui.git

Instalar requisitos

Abra el directorio descargado:

cd text-generation-webui

Compruebe e instale todos los componentes que faltan:

pip install -r requirements.txt

Añadir clave SSH a HF

Antes de empezar, necesita configurar el reenvío de puertos (puerto remoto 7860 a 127.0.0.1:7860) en su cliente SSH. Puede encontrar información adicional en el siguiente artículo: Conectarse al servidor Linux.

Actualice el repositorio caché de paquetes y los paquetes instalados:

sudo apt update && sudo apt -y upgrade

Genera y añade una clave SSH que puedas utilizar en Hugging Face:

cd ~/.ssh && ssh-keygen

Cuando se genera el par de claves, puede mostrar la clave pública en el emulador de terminal:

cat id_rsa.pub

Copie toda la información empezando por ssh-rsa y terminando por usergpu@gpuserver como se muestra en la siguiente captura de pantalla:

Abre un navegador web, escribe https://huggingface.co/ en la barra de direcciones y pulsa Enter. Accede a tu cuenta HF y abre Profile settings. A continuación, seleccione SSH and GPG Keys y pulse el botón Add SSH Key:

Rellena el Key name y pega el SSH Public key copiado del terminal. Guarda la clave pulsando Add key:

cd ~/

Descargue y ejecute el script de shell. Este script instala un nuevo repositorio de terceros con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ahora, puedes instalarlo usando el gestor de paquetes estándar:

sudo apt-get install git-lfs

Vamos a configurar git para utilizar nuestro apodo HF:

git config --global user.name "John"

Y vinculado a la cuenta de correo de HF:

git config --global user.email "john.doe@example.com"

Descargar el modelo

El siguiente paso consiste en descargar el modelo mediante la técnica de clonación de repositorios utilizada habitualmente por los desarrolladores de software. La única diferencia es que el Git-LFS previamente instalado procesará automáticamente los ficheros punteros marcados y descargará todo el contenido. Abre el directorio necesario (/mnt/fastdisk en nuestro ejemplo):

cd /mnt/fastdisk

Este comando puede tardar algún tiempo en completarse:

git clone git@hf.co:Qwen/Qwen1.5-32B-Chat-GGUF

Ejecutar el modelo

Ejecute un script que iniciará el servidor web y especificará /mnt/fastdisk como directorio de trabajo con los modelos. Este script puede descargar algunos componentes adicionales en el primer lanzamiento.

./start_linux.sh --model-dir /mnt/fastdisk

Abra su navegador web y seleccione llama.cpp en la lista desplegable Model loader:

Asegúrese de configurar el parámetro n-gpu-layers. Es el responsable de qué porcentaje de cálculos se descargarán a la GPU. Si dejas el número en 0, todos los cálculos se realizarán en la CPU, lo cual es bastante lento. Una vez configurados todos los parámetros, haz clic en el botón Load. Después, vaya a la pestaña Chat y seleccione Instruct mode. Ahora, puede introducir cualquier pregunta y recibir una respuesta:

El procesamiento se realizará por defecto en todas las GPUs disponibles, teniendo en cuenta los parámetros especificados previamente:

Ver también:

Tu propia Vicuña en Linux

Mon, 20 Jan 2025 09:25:01 +0100

Este artículo te guiará a través del proceso de despliegue de una alternativa LLaMA básica en un servidor LeaderGPU. Para ello utilizaremos el proyecto FastChat y el modelo Vicuna de libre acceso.

El modelo que utilizaremos está basado en la arquitectura LLaMA de Meta pero ha sido optimizado para un despliegue eficiente en hardware de consumo. Esta configuración proporciona un buen equilibrio entre el rendimiento y los requisitos de recursos, por lo que es adecuado tanto para pruebas como para entornos de producción.

Preinstalación

Preparémonos para instalar FastChat actualizando el repositorio caché de paquetes:

sudo apt update && sudo apt -y upgrade

Instala los drivers de NVIDIA® automáticamente usando el siguiente comando:

sudo ubuntu-drivers autoinstall

También puede instalar estos controladores manualmente con nuestra guía paso a paso. A continuación, reinicie el servidor:

sudo shutdown -r now

El siguiente paso es instalar PIP (Package Installer for Python):

sudo apt install python3-pip

Instalar FastChat

Desde PyPi

Hay dos formas posibles de instalar FastChat. Puedes instalarlo directamente desde PyPi:

pip3 install "fschat[model_worker,webui]"

Desde GitHub

Alternativamente, puedes clonar el repositorio de FastChat desde GitHub e instalarlo:

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

No olvides actualizar PIP antes de continuar:

pip3 install --upgrade pip

pip3 install -e ".[model_worker,webui]"

Ejecutar FastChat

Primer inicio

Para garantizar el éxito del primer inicio, se recomienda llamar manualmente a FastChat directamente desde la línea de comandos:

python3 -m fastchat.serve.cli --model-path lmsys/vicuna-7b-v1.5

Esta acción recupera y descarga automáticamente el modelo designado de su elección, que debe especificarse mediante el parámetro --model-path. El 7b representa un modelo con 7.000 millones de parámetros. Se trata del modelo más ligero, adecuado para GPUs con 16 GB de memoria de vídeo. En el archivo Léame del proyecto encontrarás enlaces a modelos con un mayor número de parámetros.

Ahora tienes la opción de entablar una conversación con el chatbot directamente dentro de la interfaz de línea de comandos o puedes configurar una interfaz web. Contiene tres componentes:

Controlador
Trabajadores
Servidor web de Gradio

Configurar servicios

Transformemos cada componente en un servicio systemd independiente. Crea 3 archivos separados con el siguiente contenido:

sudo nano /etc/systemd/system/vicuna-controller.service

[Unit]
Description=Vicuna controller service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.controller
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-worker.service

[Unit]
Description=Vicuna worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.model_worker --model-path lmsys/vicuna-7b-v1.5
Restart=always
[Install]
WantedBy=multi-user.target

sudo nano /etc/systemd/system/vicuna-webserver.service

[Unit]
Description=Vicuna web server
[Service]
User=usergpu
WorkingDirectory=/home/usergpu
ExecStart=python3 -m fastchat.serve.gradio_web_server
Restart=always
[Install]
WantedBy=multi-user.target

Systemd suele actualizar su base de datos de demonios durante el proceso de arranque del sistema. Sin embargo, puede hacerlo manualmente utilizando el siguiente comando:

sudo systemctl daemon-reload

Ahora, agreguemos tres nuevos servicios al inicio y lancémoslos inmediatamente usando la opción --now:

sudo systemctl enable vicuna-controller.service --now && sudo systemctl enable vicuna-worker.service --now && sudo systemctl enable vicuna-webserver.service --now

Sin embargo, si intenta abrir una interfaz web en http://[DIRECCIÓN_IP]:7860, se encontrará con una interfaz completamente inutilizable y sin modelos disponibles. Para resolver este problema, detenga el servicio de interfaz web:

sudo systemctl stop vicuna-webserver.service

Ejecute el servicio web manualmente:

python3 -m fastchat.serve.gradio_web_server

Añadir una autenticación

Esta acción llama a otro script, que registrará el modelo previamente descargado en una base de datos interna de Gradio. Espera unos segundos e interrumpe el proceso utilizando el acceso directo Ctrl + C. También nos ocuparemos de la seguridad y activaremos un sencillo mecanismo de autenticación para acceder a la interfaz web. Abre el siguiente archivo si instalaste FastChat desde PyPI:

sudo nano /home/usergpu/.local/lib/python3.10/site-packages/fastchat/serve/gradio_web_server.py

sudo nano /home/usergpu/FastChat/fastchat/serve/gradio_web_server.py

Desplácese hasta el final. Encuentra esta línea:

auth=auth,

Cámbiala poniendo el nombre de usuario o la contraseña que quieras:

auth=(“username”,”password”),

Guarde el archivo y salga, usando el acceso directo Ctrl + X. Por último, inicie la interfaz web:

sudo systemctl start vicuna-webserver.service

Abre http://[IP_ADDRESS]:7860 en tu navegador y disfruta de FastChat con Vicuña:

Ver también:

Tu propia LLaMa 2 en Linux

Mon, 20 Jan 2025 09:13:25 +0100

Paso 1. Preparar el sistema operativo

Actualizar caché y paquetes

Vamos a actualizar la caché de paquetes y actualizar tu sistema operativo antes de empezar a configurar LLaMa 2. Ten en cuenta que para esta guía, estamos utilizando Ubuntu 22.04 LTS como sistema operativo:

sudo apt update && sudo apt -y upgrade

Además, necesitamos añadir Python Installer Packages (PIP), si no está ya presente en el sistema:

sudo apt install python3-pip

Instalar controladores NVIDIA®

Puedes utilizar la utilidad automatizada que se incluye por defecto en las distribuciones de Ubuntu:

sudo ubuntu-drivers autoinstall

Alternativamente, puedes instalar los controladores NVIDIA® manualmente usando nuestra guía paso a paso. No olvides reiniciar el servidor:

sudo shutdown -r now

Paso 2. Obtener modelos de MetaAI

Solicitud oficial

Abra la siguiente dirección en su navegador: https://ai.meta.com/resources/models-and-libraries/llama-downloads/

Rellene todos los campos necesarios, lea el acuerdo de usuario y haga clic en el botón Agree and Continue. Al cabo de unos minutos (horas, días), recibirá una URL de descarga especial, que le concede permiso para descargar modelos durante un periodo de 24 horas.

Clonar el repositorio

Antes de descargar, comprueba el almacenamiento disponible:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs            38G  3.3M   38G   1% /run
/dev/sda2        99G   24G   70G  26% /
tmpfs           189G     0  189G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/nvme0n1    1.8T   26G  1.7T   2% /mnt/fastdisk
tmpfs            38G  8.0K   38G   1% /run/user/1000

Si tiene discos locales desmontados, por favor siga las instrucciones en Particionado de discos en Linux. Esto es importante porque los modelos descargados pueden ser muy grandes, y es necesario planificar su ubicación de almacenamiento de antemano. En este ejemplo, tenemos un SSD local montado en el directorio /mnt/fastdisk. Vamos a abrirlo:

cd /mnt/fastdisk

Crea una copia del repositorio original de LLaMa:

git clone https://github.com/facebookresearch/llama

Si encuentra un error de permiso, simplemente conceda permisos al usuarioergpu:

sudo chown -R usergpu:usergpu /mnt/fastdisk/

Descarga mediante script

Abra el directorio descargado:

cd llama

Ejecute el script:

./download.sh

Pega la URL proporcionada desde MetaAI y selecciona todos los modelos necesarios. Recomendamos descargar todos los modelos disponibles para evitar solicitar permiso de nuevo. Sin embargo, si necesitas un modelo específico, descarga solo ese.

Prueba rápida a través de una aplicación de ejemplo

Para empezar, podemos comprobar si falta algún componente. Si faltan bibliotecas o aplicaciones, el gestor de paquetes las instalará automáticamente:

pip install -e .

El siguiente paso es añadir nuevos binarios al PATH:

export PATH=/home/usergpu/.local/bin:$PATH

Ejecute el ejemplo de demostración:

torchrun --nproc_per_node 1 /mnt/fastdisk/llama/example_chat_completion.py --ckpt_dir /mnt/fastdisk/llama-2-7b-chat/ --tokenizer_path /mnt/fastdisk/llama/tokenizer.model --max_seq_len 512 --max_batch_size 6

La aplicación creará un proceso de cálculo en la primera GPU y simulará un diálogo sencillo con peticiones típicas, generando respuestas utilizando LLaMa 2.

Paso 3. Obtener llama.cpp

LLaMa C++ es un proyecto creado por el físico y desarrollador de software búlgaro Georgi Gerganov. Tiene muchas utilidades que facilitan el trabajo con este modelo de red neuronal. Todas las partes de llama.cpp son software de código abierto y se distribuyen bajo la licencia MIT.

Clonar el repositorio

Abre el directorio de trabajo en el SSD:

cd /mnt/fastdisk

Clona el repositorio del proyecto:

git clone https://github.com/ggerganov/llama.cpp.git

Compilar aplicaciones

Abre el directorio clonado:

cd llama.cpp

Inicia el proceso de compilación con el siguiente comando:

make

Paso 4. Obtener text-generation-webui

Clonar el repositorio

Abra el directorio de trabajo en el SSD:

cd /mnt/fastdisk

Clona el repositorio del proyecto:

git clone https://github.com/oobabooga/text-generation-webui.git

Instalar requisitos

Abra el directorio descargado:

cd text-generation-webui

Compruebe e instale todos los componentes que faltan:

pip install -r requirements.txt

Paso 5. Convertir PTH en GGUF

Formatos comunes

PTH (Python TorcH) - Un formato consolidado. Esencialmente, es un archivo ZIP estándar con un diccionario de estado PyTorch serializado. Sin embargo, este formato tiene alternativas más rápidas como GGML y GGUF.

GGML (Georgi Gerganov’s Machine Learning) - Este es un formato de archivo creado por Georgi Gerganov, el autor de llama.cpp. Se basa en una biblioteca del mismo nombre, escrita en C++, que ha aumentado considerablemente el rendimiento de los modelos lingüísticos de gran tamaño. Ahora ha sido sustituido por el moderno formato GGUF.

GGUF (Georgi Gerganov’s Unified Format) - Se trata de un formato de archivo ampliamente utilizado para los LLM, compatible con diversas aplicaciones. Ofrece mayor flexibilidad, escalabilidad y compatibilidad para la mayoría de los casos de uso.

llama.cpp convert.py script

Edita los parámetros del modelo antes de convertirlo:

nano /mnt/fastdisk/llama-2-7b-chat/params.json

Corrige "vocab_size": -1 a "vocab_size": 32000. Guarda el archivo y sal. A continuación, abra el directorio llama.cpp:

cd /mnt/fastdisk/llama.cpp

Ejecuta el script que convertirá el modelo al formato GGUF:

python3 convert.py /mnt/fastdisk/llama-2-7b-chat/ --vocab-dir /mnt/fastdisk/llama

Si todos los pasos anteriores son correctos, recibirás un mensaje como este:

Wrote /mnt/fastdisk/llama-2-7b-chat/ggml-model-f16.gguf

Paso 6. WebUI

Cómo iniciar WebUI

Abre el directorio:

cd /mnt/fastdisk/text-generation-webui/

Ejecuta el script de inicio con algunos parámetros útiles:

--model-dir indica la ruta correcta a los modelos
--share crea un enlace público temporal (si no quieres reenviar un puerto a través de SSH)
--gradio-auth añade autorización con un nombre de usuario y una contraseña (sustituye usuario:contraseña por los tuyos)

./start_linux.sh --model-dir /mnt/fastdisk/llama-2-7b-chat/ --share --gradio-auth user:password

Tras el lanzamiento con éxito, recibirás un enlace local y un enlace compartido temporal para acceder:

Running on local URL:  http://127.0.0.1:7860
Running on public URL: https://e9a61c21593a7b251f.gradio.live

Este enlace expira en 72 horas.

Cargar el modelo

Autorízate en la WebUI utilizando el nombre de usuario y la contraseña seleccionados y sigue estos 5 sencillos pasos:

Vaya a la pestaña Model.
Selecciona ggml-model-f16.gguf en el menú desplegable.
Elige cuántas capas quieres calcular en la GPU (n-gpu-layers).
Elige cuántos subprocesos quieres iniciar (threads).
Haz clic en el botón Load.

Inicia el diálogo

Cambie la pestaña a Chat, escriba su pregunta y haga clic en Generate:

Ver también:

Llama 3 usando Hugging Face

Mon, 20 Jan 2025 09:05:10 +0100

El 18 de abril de 2024 se lanzó el último gran modelo lingüístico de MetaAI, Llama 3. Se presentaron dos versiones a los usuarios: 8B y 70B. La primera versión contiene más de 15.000 tokens y fue entrenada con datos válidos hasta marzo de 2023. La segunda versión, más amplia, se entrenó con datos válidos hasta diciembre de 2023.

Paso 1. Preparar el sistema operativo Preparar el sistema operativo

Actualizar caché y paquetes

Vamos a actualizar la caché de paquetes y actualizar tu sistema operativo antes de empezar a configurar LLaMa 3. Ten en cuenta que para esta guía, estamos utilizando Ubuntu 22.04 LTS como sistema operativo:

sudo apt update && sudo apt -y upgrade

Además, necesitamos añadir Python Installer Packages (PIP), si no está ya presente en el sistema:

sudo apt install python3-pip

Instalar controladores NVIDIA®

Puedes utilizar la utilidad automatizada que se incluye por defecto en las distribuciones de Ubuntu:

sudo ubuntu-drivers autoinstall

Alternativamente, puedes instalar los controladores NVIDIA® manualmente. No olvides reiniciar el servidor:

sudo shutdown -r now

Paso 2. Obtener el modelo

Inicia sesión en Hugging Face con tu nombre de usuario y contraseña. Vaya a la página correspondiente a la versión de LLM deseada: Meta-Llama-3-8B o Meta-Llama-3-70B. En el momento de la publicación de este artículo, el acceso al modelo se proporciona de forma individual. Rellene un breve formulario y haga clic en el botón Submit:

Solicitar acceso a HF

A continuación recibirá un mensaje indicándole que su solicitud ha sido enviada:

Obtendrá acceso al cabo de 30-40 minutos y se le notificará por correo electrónico.

Añadir clave SSH a HF

Genera y añade una clave SSH que puedas utilizar en Hugging Face:

cd ~/.ssh && ssh-keygen

Cuando se genere el par de claves, podrá visualizar la clave pública en el emulador de terminal:

cat id_rsa.pub

Copie toda la información empezando por ssh-rsa y terminando por usergpu@gpuserver como se muestra en la siguiente captura de pantalla:

Abra la configuración del perfil de Hugging Face. A continuación, seleccione SSH and GPG Keys y haga clic en el botón Añadir clave SSH:

Rellene el Key name y pegue el SSH Public key copiado del terminal. Guarde la clave pulsando Add key:

Ahora, tu cuenta HF está vinculada con la clave SSH pública. La segunda parte (clave privada) se almacena en el servidor. El siguiente paso es instalar una extensión específica de Git LFS (Large File Storage), que se utiliza para descargar archivos de gran tamaño, como los modelos de redes neuronales. Abre tu directorio de inicio:

cd ~/

Descargue y ejecute el script de shell. Este script instala un nuevo repositorio de terceros con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ahora, puedes instalarlo usando el gestor de paquetes estándar:

sudo apt-get install git-lfs

Vamos a configurar git para utilizar nuestro apodo HF:

git config --global user.name "John"

Y vinculado a la cuenta de correo de HF:

git config --global user.email "john.doe@example.com"

Descargar el modelo

Abra el directorio de destino:

cd /mnt/fastdisk

E inicia la descarga del repositorio. Para este ejemplo elegimos la versión 8B:

git clone git@hf.co:meta-llama/Meta-Llama-3-8B

Este proceso tarda hasta 5 minutos. Puede monitorizarlo ejecutando el siguiente comando en otra consola SSH:

watch -n 0.5 df -h

Aquí verás cómo se reduce el espacio libre en el disco montado, asegurando que la descarga avanza y los datos se guardan. El estado se actualizará cada medio segundo. Para detener manualmente la visualización, pulse la combinación de teclas Ctrl + C.

También puedes instalar btop y supervisar el proceso con esta utilidad:

sudo apt -y install btop && btop

Para salir de la utilidad btop, pulse la tecla Esc y seleccione Quit.

Paso 3. Ejecutar el modelo Ejecutar el modelo

Abra el directorio:

cd /mnt/fastdisk

Descarga el repositorio de Llama 3:

git clone https://github.com/meta-llama/llama3

Cambia el directorio:

cd llama3

Ejecuta el ejemplo:

torchrun --nproc_per_node 1 example_text_completion.py \
--ckpt_dir /mnt/fastdisk/Meta-Llama-3-8B/original \
--tokenizer_path /mnt/fastdisk/Meta-Llama-3-8B/original/tokenizer.model \
--max_seq_len 128 \
--max_batch_size 4

Ahora puedes utilizar Llama 3 en tus aplicaciones.

Ver también:

StarCoder: su asistente local de codificación

Fri, 17 Jan 2025 14:52:58 +0100

Microsoft CoPilot ha supuesto una revolución en el campo del desarrollo de software. Este asistente de IA ayuda enormemente a los desarrolladores con diversas tareas de codificación, facilitándoles la vida. Sin embargo, un inconveniente es que no es una aplicación independiente, sino un servicio basado en la nube. Esto significa que los usuarios deben aceptar los términos y condiciones del servicio y pagar una suscripción.

Afortunadamente, el mundo del software de código abierto nos ofrece numerosas alternativas. En el momento de escribir este artículo, la alternativa más notable a CoPilot es StarCoder, desarrollada por el proyecto BigCode. StarCoder es un extenso modelo de red neuronal con 15,5B de parámetros, entrenado en más de 80 lenguajes de programación.

Este modelo se distribuye en Hugging Face (HF) utilizando un modelo gated bajo el acuerdo de licencia BigCode OpenRAIL-M v1. Puedes descargar y utilizar este modelo de forma gratuita, pero necesitas tener una cuenta en HF con una clave SSH vinculada. Antes de poder descargarlo, hay algunos pasos adicionales que debes seguir.

Añadir clave SSH a HF

Antes de empezar, tienes que configurar el reenvío de puertos (puerto remoto 7860 a 127.0.0.1:7860) en tu cliente SSH. Puedes encontrar información adicional en los siguientes artículos:

Actualice el repositorio caché de paquetes y los paquetes instalados:

sudo apt update && sudo apt -y upgrade

Vamos a instalar el gestor de paquetes del sistema Python (PIP):

sudo apt install python3-pip

Genera y añade una clave SSH que puedas usar en Hugging Face:

cd ~/.ssh && ssh-keygen

Cuando se genera el par de claves, puede mostrar la clave pública en el emulador de terminal:

cat id_rsa.pub

Copie toda la información empezando por ssh-rsa y terminando por usergpu@gpuserver como se muestra en la siguiente captura de pantalla:

Rellena el Key name y pega el SSH Public key copiado del terminal. Guarda la clave pulsando Add key:

cd ~/

Descargue y ejecute el script de shell. Este script instala un nuevo repositorio de terceros con git-lfs:

curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash

Ahora, puedes instalarlo usando el gestor de paquetes estándar:

sudo apt-get install git-lfs

Vamos a configurar git para utilizar nuestro apodo HF:

git config --global user.name "John"

Y vinculado a la cuenta de correo de HF:

git config --global user.email "john.doe@example.com"

Descargar el modelo

Ten en cuenta que StarCoder en formato binario puede ocupar una cantidad significativa de espacio en disco (>75 GB). No olvides consultar este artículo para asegurarte de que estás utilizando la partición montada correcta.

Todo está listo para la descarga del modelo. Abre el directorio de destino:

cd /mnt/fastdisk

Y empieza a descargar el repositorio:

git clone git@hf.co:bigcode/starcoder

Este proceso tarda hasta 15 minutos. Por favor, sea paciente. Puede monitorizarlo ejecutando el siguiente comando en otra consola SSH:

watch -n 0.5 df -h

Aquí, verás cómo se reduce el espacio libre en el disco montado, asegurando que la descarga está progresando y los datos se están guardando. El estado se actualizará cada medio segundo. Para detener manualmente la visualización, pulse el acceso directo Ctrl + C.

Ejecutar el modelo completo con WebUI

Clona el repositorio del proyecto:

git clone https://github.com/oobabooga/text-generation-webui.git

Abre el directorio descargado:

cd text-generation-webui

Ejecute el script de inicio:

./start_linux.sh --model-dir /mnt/fastdisk

El script comprobará la presencia de las dependencias necesarias en el servidor. Las dependencias que falten se instalarán automáticamente. Cuando se inicie la aplicación, abra su navegador web y escriba la siguiente dirección:

http://127.0.0.1:7860

Abra la pestaña Model y seleccione el modelo descargado starcoder de la lista desplegable. Haga clic en la lista Model loader y seleccione Transformers. Ajusta el deslizador de memoria máxima de la GPU para cada GPU instalada. Esto es muy importante, ya que ponerlo a 0 restringe el uso de VRAM e impide que el modelo se cargue correctamente. También tienes que establecer el uso máximo de RAM. Ahora, haz click en el botón Load y espera a que el proceso de carga se complete:

Cambia a la pestaña Chat y prueba la conversación con el modelo. Ten en cuenta que Starcoder no está pensado para diálogos como ChatGPT. Sin embargo, puede ser útil para comprobar si hay errores en el código y sugerir soluciones.

Si quieres obtener un modelo de diálogo completo, puedes probar otros dos modelos: starchat-alpha y starchat-beta. Estos modelos fueron afinados para conducir un diálogo tal como lo hace ChatGPT. Los siguientes comandos ayudan a descargar y ejecutar estos modelos:

Para starchat-alpha:

git clone git@hf.co:HuggingFaceH4/starchat-alpha

Para starchat-beta:

git clone git@hf.co:HuggingFaceH4/starchat-beta

El procedimiento de carga es el mismo que el descrito anteriormente. Además, puedes encontrar la implementación en C++ de starcoder, que será eficaz para la inferencia en CPU.

Ver también:

Modelos de Stable Diffusion: personalización y opciones

Mon, 25 Nov 2024 13:30:16 +0100

El tuning es una forma excelente de mejorar cualquier coche o aparato. Las redes neuronales generativas también se pueden tunear. Hoy no queremos profundizar en la estructura de la Difusión Estable, pero pretendemos conseguir mejores resultados que con una configuración estándar.

Hay dos formas sencillas de hacerlo: instalando modelos personalizados y utilizando las opciones de optimización estándar. En este artículo, aprenderemos cómo instalar nuevos modelos en Stable Diffusion y qué opciones nos permiten utilizar el hardware de forma más eficaz.

Si quieres compartir fotos divertidas de gatos monos o comida de aspecto estupendo, lo normal es que las publiques en Instagram. Si desarrollas aplicaciones y quieres poner el código a disposición de todo el mundo, lo publicas en GitHub. Pero si entrenas un modelo gráfico de IA y quieres compartirlo, deberías prestar atención a CivitAI. Se trata de una gran plataforma para compartir conocimientos y resultados con los miembros de la comunidad.

Antes de empezar a descargar, necesitas cambiar el directorio de trabajo. Todos los modelos de IA en Stable Diffusion están ubicados en el directorio "models":Antes de empezar a descargar, necesitas cambiar el directorio de trabajo. Todos los modelos de IA de Stable Diffusion se encuentran en el directorio "models":

cd stable-diffusion-webui/models/Stable-diffusion

Comprobemos qué modelos se proporcionan por defecto:

ls -a

'Put Stable Diffusion checkpoints here.txt'
v1-5-pruned-emaonly.safetensors

Sólo hay un modelo con el nombre "v1-5-pruned-emaonly" y la extensión "safetensors". Este modelo es un buen punto de partida, pero tenemos cinco modelos más interesantes. Vamos a descargarlos y compararlos con el modelo estándar.

Avisos de difusión estable

Para mostrar visualmente la diferencia entre ellos, hemos ideado unas sencillas indicaciones:

princess, magic, fairy tales, portrait, 85mm, colorful

Para muchos modelos, representar con precisión la geometría y los rasgos faciales puede ser un reto importante. Para ello, añada indicaciones negativas que garanticen la generación de imágenes sin estas características:

poorly rendered face, poorly drawn face, poor facial details, poorly drawn hands, poorly rendered hands, low resolution, bad composition, mutated body parts, blurry image, disfigured, oversaturated, bad anatomy, deformed body features

Ajuste el valor máximo de pasos de muestreo (150) para obtener más detalles en el resultado.

Modelo estándar

El modelo estándar funciona bien en este tipo de tareas. Sin embargo, algunos detalles no son del todo precisos. Por ejemplo, hay un problema con los ojos: están claramente desproporcionados:

Si nos fijamos en la diadema, también está torcida y es asimétrica. El resto de los detalles están bien ejecutados y corresponden a las indicaciones dadas. El fondo está borroso porque hemos puesto la indicación "85 mm". Se trata de una distancia focal muy utilizada para retratos en fotografía profesional.

Visión realista

Este modelo es ideal para retratos. La imagen parece tomada con un objetivo de calidad con la distancia focal especificada. Las proporciones del rostro y el cuerpo son exactas, el vestido se ajusta perfectamente y la diadema de la cabeza resulta estéticamente agradable:

Por cierto, el autor recomienda utilizar la siguiente plantilla para las indicaciones negativas:

deformed iris, deformed pupils, semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.4), text, close up, cropped, out of frame, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck

Pero incluso con nuestras sencillas indicaciones, el resultado es excelente.

Descargue el modelo aquí: Visión realista

Deliberado

Otro modelo sorprendente para estos fines. Los detalles también están bien trabajados aquí, pero ten cuidado y vigila el número de dedos. Este es un problema muy común con las redes neuronales: a menudo pueden dibujar dedos de más o incluso extremidades enteras.

Crear líneas visuales es una de las técnicas favoritas de las películas. Así, este modelo también eligió dibujar a una persona sobre el fondo de un camino forestal.

Descargue el modelo aquí: Deliberate

OpenJourney

Entre las redes neuronales generativas, Midjourney (MJ) ha recibido especial atención. MJ fue pionera en este campo y a menudo se pone como ejemplo para otras. Las imágenes que crea tienen un estilo único. OpenJourney se inspira en el estilo de MJ y es una Stable Diffusion convenientemente ajustada.

Genera imágenes que parecen dibujos animados. Son vibrantes y brillantes. Para obtener mejores resultados, añada el indicador de estilo mdjrny-v4

Descarga el modelo aquí: OpenJourney

Cualquier cosa

Este modelo crea imágenes parecidas a las de un dibujante profesional de manga (una persona que dibuja cómics). Así, tenemos una princesa de estilo anime.

Este modelo está entrenado en imágenes con una resolución de 768x768. Puede ajustar esta resolución para obtener mejores resultados que el estándar 512x512.

Descarga el modelo aquí: Cualquier cosa

Memphis corporativo

Este estilo de imágenes ganó gran popularidad a principios de la década de 2020 y se utilizó ampliamente como estilo corporativo en diferentes empresas de alta tecnología. A pesar de las críticas, se encuentra a menudo en presentaciones y sitios web.

La princesa resultó ser minimalista, pero bastante bonita. Especialmente divertidos fueron los detalles que la modelo colocó en el fondo.

Descargue el modelo aquí: Corporate Memphis

Opciones de difusión estable

La difusión estable consume muchos recursos, por lo que se han desarrollado muchas opciones para ella. La más popular de ellas es --xformers. Esta opción habilita dos mecanismos de optimización. El primero reduce el consumo de memoria y el segundo se utiliza para aumentar la velocidad.

Si intentas añadir --xformers sin pasos adicionales, obtendrás un error diciendo que los paquetes(torch y torchvision) están compilados para diferentes versiones de CUDA®. Para solucionar esto, tenemos que entrar en el entorno virtual Python (venv) que se utiliza para Stable Diffusion. Después de eso, instalar los paquetes para la versión deseada de CUDA® (v1.18).

Primero debemos actualizar la caché de paquetes apt e instalar el instalador de paquetes para Python (pip). El siguiente paso es activar Python venv con el script activate:

source stable-diffusion-webui/venv/bin/activate

Después de eso, la línea de comandos cambia a (venv) username@hostname:~$ Vamos a instalar los paquetes torch y torchvision con CUDA® 11.8:

pip install torch==2.0.0+cu118 torchvision==0.15.1+cu118 --index-url https://download.pytorch.org/whl/cu118

Este proceso puede tardar varios minutos porque los paquetes son bastante grandes. Tendrás el tiempo justo para servirte un café. Por último, puedes desactivar el entorno virtual e iniciar Stable Diffusion con la opción --xformers (sustituye [user] y [password] por tus propios valores):

deactivate

./webui --xformers --listen --gradio-auth [user]:[password]

La alternativa más rápida para --xformers es --opt-sdp-no-mem-attention. Consume más memoria pero funciona un poco más rápido. Puede utilizar esta opción sin pasos adicionales.

Conclusión

Hoy hemos examinado las capacidades de la Difusión Estable cuando se combina con otros modelos añadidos y opciones de optimización. Recuerde, aumentando o disminuyendo el número de pasos de muestreo, puede ajustar el nivel de detalle de la imagen final.

Por supuesto, esto es sólo una pequeña parte de lo que se puede hacer con una red neuronal generativa de este tipo. Así que pide ahora mismo un servidor GPU y empieza a experimentar. Te esperan muchos más descubrimientos y oportunidades. Las tarjetas de vídeo potentes y de alta velocidad te ayudarán a ahorrar tiempo y a generar imágenes geniales.

Véase también:

Stable Diffusion WebUI

Mon, 25 Nov 2024 13:24:45 +0100

Las redes neuronales generativas parecen mágicas. Responden a preguntas, crean imágenes e incluso escriben código en varios lenguajes de programación. El éxito de estas redes tiene dos componentes: modelos preentrenados y aceleradores de hardware. Ciertamente, es posible utilizar núcleos de CPU para esta carga de trabajo, pero sería como una carrera de caracoles. Generar una imagen pequeña puede llevar mucho tiempo, decenas de minutos. Generar la misma imagen en una GPU llevaría cientos de veces menos.

El primer secreto reside en el número de núcleos. Los núcleos de la CPU son universales y pueden manejar instrucciones complejas. Sin embargo, los procesadores de servidor convencionales tienen un máximo de 64 núcleos. Incluso en los sistemas multiprocesador, el número de núcleos rara vez supera los 256. Los núcleos de las GPU son más sencillos, pero como resultado caben muchos más en el chip. Por ejemplo, una NVIDIA® RTX™ 4090 tiene 16.384 núcleos.

El segundo secreto es que la carga de trabajo puede dividirse en muchas tareas sencillas, que pueden ejecutarse en subprocesos paralelos en núcleos de GPU dedicados. Este truco acelera considerablemente el procesamiento de datos. Hoy veremos cómo funciona y desplegaremos una red neuronal generativa Stable Diffusion Web UI en la infraestructura LeaderGPU. Tomemos, por ejemplo, un servidor con una NVIDIA® RTX™ 4090 que tiene 16.384 núcleos de GPU. Como sistema operativo, seleccionamos la actual versión LTS de Ubuntu 22.04 y elegimos la opción "Instalar controladores NVIDIA® y CUDA® 11.8".

Preparación del sistema

Antes de empezar, vamos a considerar la memoria. Stable Diffusion es un sistema grande que puede ocupar hasta 13G en tu disco duro. El disco virtual estándar en una instalación de LeaderGPU es de 100G. El sistema operativo ocupa 25G. Si desplegamos Stable Diffusion sin ampliar la partición de inicio, agotaremos toda la memoria libre y nos encontraremos con un error de "No queda espacio en el dispositivo". Es una buena idea extender nuestro directorio home.

Ampliar el directorio de inicio

Primero, necesitamos comprobar todos los discos disponibles.

sudo fdisk -l

Disk /dev/sda: 447.13 GiB, 480103981056 bytes, 937703088 sectors
Disk model: INTEL SSDSC2KB48
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

Disk /dev/sdb: 50 GiB, 53687091200 bytes, 104857600 sectors
Disk model: VIRTUAL-DISK
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: gpt
Disk identifier: 9D4C1F0C-D4A7-406E-AECB-BF57E4726437

Luego necesitamos crear una nueva partición Linux en nuestro disco SSD físico, /dev/sda:

sudo fdisk /dev/sda

Pulsa las siguientes teclas, una a una: g → n → Enter → Enter → Enter → w. Esto resultará en una nueva partición /dev/sda1 sin sistema de archivos. Ahora, crea un sistema de archivos ext4 en ella:

sudo mkfs.ext4 /dev/sda1

Cuando termine el proceso, pasamos al siguiente paso.

Atención. Por favor, proceda con la siguiente operación con sumo cuidado. Cualquier error cometido al modificar el archivo fstab puede provocar que su servidor no pueda arrancar con normalidad y puede requerir un reinicio completo del sistema operativo.

sudo blkid

/dev/sdb2: UUID="6b17e542-0934-4dba-99ca-a00bd260c247" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="70030755-75d8-4339-a4e0-26a97f1d1c5d"
/dev/loop1: TYPE="squashfs"
/dev/sdb1: PARTUUID="63ff1714-bd29-4062-be04-21af32423c0a"
/dev/loop4: TYPE="squashfs"
/dev/loop0: TYPE="squashfs"
/dev/sda1: UUID="fb2ba455-2b8d-4da0-8719-ce327d0026bc" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="6e0108df-b000-5848-8328-b187daf37a4f"
/dev/loop5: TYPE="squashfs"
/dev/loop3: TYPE="squashfs"

Copie UUID (fb2ba455-2b8d-4da0-8719-ce327d0026bc en el ejemplo) de la partición /dev/sda1. A continuación, daremos instrucciones al sistema para que monte automáticamente esta unidad por su UUID en el arranque:

sudo nano /etc/fstab

Introduzca esta línea antes de /swap.img... string:

/dev/disk/by-uuid/ /home/usergpu ext4 defaults defaults

Ejemplo:

# /etc/fstab: static file system information.
#
# Use 'blkid' to print the universally unique identifier for a
# device; this may be used with UUID= as a more robust way to name devices
# that works even if disks are added and removed. See fstab(5).
#
#                
# / was on /dev/sdb2 during curtin installation
/dev/disk/by-uuid/6b17e542-0934-4dba-99ca-a00bd260c247 / ext4 defaults,_netdev 0 1
/dev/disk/by-uuid/fb2ba455-2b8d-4da0-8719-ce327d0026bc /home/usergpu ext4 defaults defaults
/swap.img       none    swap    sw      0       0

Salga con el atajo de teclado Ctrl + X y confirme el guardado del archivo pulsando Enter. La nueva configuración se aplicará en el próximo arranque del sistema. Vamos a reiniciar el servidor:

sudo shutdown -r now

Después de reiniciar, podemos comprobar todos los directorios montados con el siguiente comando:

df -h

Filesystem      Size  Used Avail Use% Mounted on
tmpfs           6.3G  1.7M  6.3G   1% /run
/dev/sdb2        49G   23G   24G  50% /
tmpfs            32G     0   32G   0% /dev/shm
tmpfs           5.0M     0  5.0M   0% /run/lock
/dev/sda1       440G   28K  417G   1% /home/usergpu
tmpfs           6.3G  4.0K  6.3G   1% /run/user/1000

¡Magnífico! Pero ahora no tenemos acceso para escribir algo en nuestro directorio home porque fue cambiado por el archivo de configuración fstab. Es hora de recuperar la propiedad del directorio:

sudo chown -R usergpu /home/usergpu

¡Buen trabajo! Pasemos al siguiente paso.

Instalar paquetes básicos

Actualiza la caché de software desde los repositorios oficiales de Ubuntu y actualiza algunos paquetes:

sudo apt update && sudo apt -y upgrade

El sistema ha informado de que se ha instalado un nuevo kernel y estará operativo tras el reinicio del sistema. Seleccione OK dos veces.

A continuación, tenemos que resolver las dependencias, que requieren Stable Diffusion. El primer paquete añade la funcionalidad de entorno virtual Python:

sudo apt install python3-venv

El segundo paquete añade una implementación de la función malloc() del lenguaje de programación C personalizada por Google. Evita el error “Cannot locate TCMalloc” y mejora el uso de la memoria de la CPU.

sudo apt install -y --no-install-recommends google-perftools

Por último, reinicia el servidor de nuevo:

sudo shutdown -r now

Difusión estable automática 1111: instalar script

La forma más fácil de instalar Stable Diffusion con WebUI es utilizando el script preconfigurado escrito por el usuario de GitHub AUTOMATIC1111. Este script descarga e instala estas dos partes mientras resuelve todas las dependencias necesarias.

Vamos a descargar el script:

wget https://raw.githubusercontent.com/AUTOMATIC1111/stable-diffusion-webui/master/webui.sh

A continuación, démosle acceso a los datos de modificación y ejecutémoslo como un programa:

chmod a+x webui.sh

Ejecuta el script descargado:

./webui.sh

Este proceso puede tardar un par de minutos. Todo está listo para crear imágenes perfectas con Stable Diffusion.

Solución de problemas

Si se encuentra con el error "Torch is not able to use GPU", puede solucionarlo reinstalando a través de apt:

sudo apt -y install nvidia-driver-535

Es necesario reiniciar el sistema operativo para habilitar el controlador:

sudo shutdown -r now

Generar

El script de instalación ./webui.sh tiene otra función. Sirve simultáneamente a la parte del servidor de Stable Diffusion y WebUI. Sin embargo, si lo utiliza sin argumentos, el servidor estará disponible como un demonio local en http://127.0.0.1:7860. Esto puede resolverse de dos maneras: reenviando puertos a través de un túnel SSH o permitiendo conexiones desde IPs externas.

La segunda forma es más simple: simplemente añade la opción --listen y podrás conectarte a la interfaz web en http://[YOUR_LEADERGPU_SERVER_IP_ADDRESS]:7860. Sin embargo, esto es completamente inseguro, ya que cualquier usuario de Internet tendrá acceso. Para evitar el uso no autorizado, añada la opción --gradio-auth junto al nombre de usuario y la contraseña, separados por dos puntos:

./webui.sh --listen --gradio-auth user:password

Esto añade una página de login a tu instancia WebUI.El script descargará los modelos básicos y las dependencias requeridas por primera vez:

Puedes disfrutar del resultado. Sólo tienes que introducir algunos datos, separarlos por comas, y hacer clic en el botón Generar. Después de unos segundos, se mostrará una imagen generada por la red neuronal.

Conclusión

Hemos recorrido todo el camino desde un servidor LeaderGPU vacío con sólo un sistema operativo preinstalado hasta una instancia lista con Stable Diffusion y una interfaz WebUI. La próxima vez, aprenderemos más sobre el ajuste del rendimiento del software y cómo mejorar adecuadamente tu instancia de Stable Diffusion con nuevas versiones de controladores y paquetes.

Vea también: