How to Build an Offline AI Image Generator in Node.js with QVAC and Socket.io

如何使用 QVAC 和 Socket.io 在 Node.js 中构建离线 AI 图像生成器

2026年6月18日

/

#AI

Djibril-M🍀

几年前，当我第一次终于能够使用 AI 图像生成器时，我非常兴奋，立刻坐下来写了一篇文章（使用 Node.js 和 OpenAI 的 DALL-E）。将想法直接转化为数字像素的魔力，感觉就像握着一根真正的魔法棒。

但当时，访问这些模型并不是一件容易的事。我们主要的选项是 Midjourney，这意味着你必须在 Discord 上苦苦等待，有时甚至因为速率限制和服务器繁忙而无法做任何事情。

当时访问图像生成服务，感觉就像在快闪活动中点咖啡一样困难。

幸运的是，局面已经完全改变了。如今，我们不仅可以在消费级硬件上运行像 Stable Diffusion 这样的先进模型，而且还可以在本地、离线、完全免费的情况下运行。我们不需要任何 API 密钥，也没有订阅速率限制，也不需要处理任何 Discord 频道。

在本教程中，我们将使用 Node.js、Express、Socket.io 和 QVAC SDK 来构建一个本地 Web 应用程序，运行量化后的 Stable Diffusion 2.1 模型。

目录

• 先决条件

• 什么是 QVAC？

• Stable Diffusion 的内部工作原理

• GPU 限制：Metal、AMD 和 Intel Mac 的陷阱

• 图像生成流程

• 完整实现

• 代码库分析

• 结论

• 资源和进一步阅读

先决条件

为了充分利用本教程，你应该具备扎实的 Web 前端和后端基础知识：

• Node.js 和 ES 模块：对现代 JavaScript 模块（import / export）、异步循环和事件监听器的基本了解。

• Express 和 WebSockets：熟悉使用 socket.io 在 WebSockets 上路由静态文件和发送实时消息。

• HTML 和原生 CSS：理解基本的 DOM 操作和样式绑定。

• 开发环境：安装了 Node.js 的本地机器。

什么是 QVAC？

由 Tether 开发，QVAC 是一组本地推理工具，旨在直接在客户端硬件上执行机器学习模型。

与将推理请求路由到昂贵的云托管 API（如 DALL-E 或 Midjourney）不同，QVAC 将预编译的机器学习运行时（如用于文本的 llama.cpp、用于转录的 whisper.cpp 和自定义扩散后端）直接打包到 Node.js、移动和桌面运行时中。

使用 QVAC 运行本地 AI 模型具有几个实际优势：

• 零 API 成本：无需重复成本，即可生成你的硬件能够处理的尽可能多的图像。

• 以隐私为先：提示和生成的图像完全保留在本地机器的内存中。

• 离线独立性：在隔离网络、飞行途中或没有互联网访问的地区运行你的应用。

但这个实际的图像生成过程在概念上是如何运作的呢？让我们先明确一点：这并不是一篇科学论文。我们不会深入探讨背后的多变量微积分、概率分布或随机微分方程，因为我并不是低层次的机器学习研究人员（而且说实话，我们都不想盯着屏幕上的希腊符号和线性代数公式，而放弃编写干净的JavaScript代码）。

相反，让我们用一些直观的开发者类比来理解这些模型在概念上是如何运作的。

世界级雕塑家的类比

从根本上说，现代AI图像生成将随机性转化为现实。与人类画家用画笔逐像素地“绘画”图像不同，AI更像是一个世界级的雕塑家，从一块数字静态中雕刻出图像。

目前，这项技术最主导的力量是扩散（Diffusion），它驱动了Stable Diffusion、Midjourney和Google的Imagen系列等模型。

以下是这个静态块如何转化为艺术的概念性步骤分解：

#### 1. 训练阶段（学习模式）

在模型能够生成任何内容之前，它必须查看数十亿张图像及其对应的文本描述。在这个阶段，开发者会做一些反直觉的事情：他们故意破坏这些图像。

• 添加噪声：系统会从一张清晰的图片（例如，一张猫的图片）开始，逐步逐像素地添加随机的数字静态（噪声），直到原始图像完全无法辨认。

• 学习逆转：AI的任务是观察一张有噪声的图像，并预测在该特定步骤中添加了多少噪声。通过数十亿次的重复，它成为去噪的专家——即把混乱重新转化为秩序。

#### 2. 连接文字与视觉（CLIP）

为了确保AI知道“戴着礼帽的猫”看起来像什么，它使用一个文本到图像的桥梁，通常由一个名为CLIP（Contrastive Language-Image Pre-training）的系统提供支持。

• CLIP将人类语言转化为一个数学映射（称为嵌入，embedding）。

• 在这个映射中，“猫”这个词和实际的猫的像素非常接近。这确保了当你输入提示时，AI知道应该从其记忆中提取哪些视觉概念。

#### 3. 生成阶段（反向扩散循环）

当你输入一个提示并点击“生成”时，魔法在反向发生：

• 空白画布：AI从一个完全随机的数字噪声画布开始（看起来像是老式电视的雪花噪点）。

• 提示引导：AI查看你的提示，并使用其文本嵌入来引导它的“视线”。它观察这些随机的噪点，并问：“在这片混乱中，我从哪里开始看到一只猫？”

• 逐步去噪：AI减去一点噪声，使图像稍微清晰一些。它重复这个循环20到50次。每一步，模糊的形状逐渐变成粗糙的轮廓，纹理出现，最终，一张清晰、干净、全新的图像诞生了。

关于种子的一个有趣事实：由于每次过程都从完全随机的静态开始，即使你两次输入完全相同的提示，也会得到完全不同的图像（除非你使用一个称为“种子”（Seed）的特定数字锁定初始的随机性）。

以下是使用扩散模型进行去噪的示意图：

潜在扩散：保持速度（VAE）

逐像素生成高分辨率图像需要巨大的计算能力。如果我们直接在消费级硬件的像素空间中进行操作，计算机可能会过热，单次生成可能需要数小时。

为了解决这个问题，现代模型使用潜在扩散（Latent Diffusion）。

与其处理完整尺寸的图像，一个称为编码器（encoder）的组件会将图像压缩到一个更小、抽象的数学空间（即“潜在空间”）。可以将其想象成一个缩小后的游乐场，所有噪声去除和去噪的数学运算都在这里进行。由于这个游乐场非常小，因此计算速度非常快。

一旦在潜在空间中完成去噪循环，另一个称为解码器（decoder，具体来说是变分自编码器，即 VAE）的组件会将图像重新放大，生成清晰的高分辨率图像供你查看。

QVAC 支持的架构

当你使用 QVAC 进行本地推理时，SDK 会连接到优化过的、由社区维护的 C++ 后端。QVAC 管理不同人工智能模态的硬件绑定和模型生命周期：

• 文本生成（llama.cpp）：用于大型语言模型（LLMs），如 Llama 3 或 Mistral，执行自回归的令牌预测。

• 音频转录（whisper.cpp）：用于高度优化的语音转文本转录。

• 图像生成（stable-diffusion.cpp / sdcpp-generation）：本教程的重点。QVAC 根据你选择的模型架构，支持两种不同的图像生成方法：

• 打包模型方法（Stable Diffusion 1.5/2.1/XL）：传统方法，整个流程（文本编码器、VAE 和主扩散 UNet）都被封装到一个统一的 GGUF 文件中（例如 SD_V2_1_1B_Q8_0）。这种方法对于本地部署非常方便，因为你只需管理并加载一个文件即可开始生成图像。

• 模块化多模型方法（Flux）：现代架构如 FLUX.1 使用了更加复杂的设置。与单个文件不同，Flux 将其计算大脑拆分为多个组件。你加载一个核心扩散变换器（DiT）模型，但你还需要分别加载大型文本编码器（如 T5-v1.1-xxl 和 CLIP-L）和一个独立的 VAE 模型。虽然这需要更复杂的协调来同时加载多个 GGUF 文件，但通过使用专门的、大规模的文本理解模型，可以显著提高提示的遵循度和照片的真实性。

• 语音合成（TTS）：专用架构，如 Chatterbox（基于变换器的零样本语音克隆）和 Supertonic（基于扩散的语音去噪）。

GPU 限制：Metal、AMD 与 Intel Mac 陷阱

在 Apple Mac 硬件上本地运行机器学习模型时，QVAC 会尝试通过为 Metal API 编译计算管道来自动加速执行，从而利用系统 GPU。

如果你使用的是 Apple Silicon Mac（M1、M2、M3、M4 或 M5 芯片），这会无缝运行，生成过程会在 Apple Neural Engine 和统一 GPU 内存中几秒钟内完成。

但如果你使用的是较旧的基于 Intel 的 Mac，搭载独立的 AMD Radeon GPU（如 16 英寸 MacBook Pro 常见的 AMD Radeon Pro 5500M），你将遇到一个重大的驱动程序级别限制：

• macOS 上较旧 AMD 独立 GPU 的 Metal 驱动程序不支持 stable-diffusion.cpp 使用的现代机器学习计算着色器和矩阵约简操作符。

• 当推理工作线程尝试运行这些不支持的操作时，驱动程序将无法编译流水线，并在 ggml-metal-ops.cpp 的着色器编码器中触发一个硬性 C++ 崩溃（SIGABRT），导致后台工作进程突然退出。

如果你遇到这个硬件限制，每次触发图像生成时，默认的 GPU 配置都会导致应用程序崩溃。

为了解决这个问题，你应该将模型配置为在 CPU 上运行，通过将模型配置参数 device 设置为 "cpu"，并指定线程数（例如 threads: 4）。虽然在 CPU 上生成图像比在 GPU 上耗时更长，但它可以在任何机器上成功运行，无论其 GPU 多么老旧或性能有限。

图像生成流水线

为了协调本地执行生命周期，我们的应用程序设置了一个实时事件流水线：

[浏览器客户端]                                  [Node.js 服务器]
       |                                                 |
       | ------ 1. 连接并检查模型 --------->               |
       | <----- 2. 下载并加载模型 ----------               | (模型本地缓存)
       |                                                 |
       | ------ 3. 提交提示（"温馨的小屋..."） ->         |
       |                                                 |
       |                                                 | === [ QVAC 推理引擎 ] ===
       |                                                 | 
       | <----- 4. 去噪步骤更新（例如 5/20） --           | (实时流式传输步骤)
       |                                                 |
       | <----- 5. 发送最终图像（Base64 DataURL） --      | (直接内存负载)
       |                                                 |

完整实现

让我们来看一下实现。你可以克隆完整的项目仓库来跟随操作，或者从头开始构建，通过创建一个项目文件夹，运行 npm init -y，安装依赖项（@qvac/sdk、express、socket.io、concurrently），并在 package.json 中配置 "type": "module"。

1. 服务器配置（server.js）

创建一个名为 server.js 的文件，并粘贴以下实现：

import express from 'express';
import path from 'path';
import http from 'http';
import { Server } from 'socket.io';
import fs from 'fs';
import { fileURLToPath } from 'url';
import { loadModel, unloadModel, getLoadedModelInfo, diffusion, SD_V2_1_1B_Q8_0 } from "@qvac/sdk";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
const server = http.createServer(app);
const io = new Server(server);

const PORT = process.env.PORT || 3000;

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

const CONFIG_PATH = path.join(__dirname, '.device-preference.json');

function getPreferredDevice() {
  try {
    if (fs.existsSync(CONFIG_PATH)) {
      const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
      return data.device || null;
    }
  } catch (err) {
    console.error('Failed to read device preference:', err.message);
  }
  return null;
}

function setPreferredDevice(device) {
  try {
    fs.writeFileSync(CONFIG_PATH, JSON.stringify({ device }), 'utf8');
  } catch (err) {
    console.error('Failed to write device preference:', err.message);
  }
}

// 全局模型状态 let loadedModelId = process.modelId || null; let modelLoadPercent = 0; let modelLoadStatus = '等待触发...'; let isModelLoading = false;

const modelSize = (SD_V2_1_1B_Q8_0.expectedSize / (1024 * 1024 * 1024)).toFixed(2) + ' GB';

function broadcastModelProgress(percent, status) { io.emit('model-download-progress', { percent, status, size: modelSize }); }

io.on('connection', (socket) => { console.log('客户端连接:', socket.id);

socket.on('disconnect', () => { console.log('客户端断开连接:', socket.id); });

// 触发模型下载 socket.on('trigger-model-download', async () => { // 如果模型已经加载，验证它是否仍然在 worker 中存活 if (loadedModelId) { try { await getLoadedModelInfo({ modelId: loadedModelId }); socket.emit('model-download-progress', { percent: 100, status: '模型已完全本地加载。', size: modelSize }); return; } catch (err) { console.log('模型 ID 已过期/未找到，重置状态并重新加载...', err.message); loadedModelId = null; process.modelId = null; } }

// 如果当前正在加载，报告当前进度 if (isModelLoading) { socket.emit('model-download-progress', { percent: Math.round(modelLoadPercent), status: modelLoadStatus, size: modelSize }); return; }

isModelLoading = true; modelLoadPercent = 0; modelLoadStatus = '开始模型下载...'; broadcastModelProgress(modelLoadPercent, modelLoadStatus);

try { console.log('开始模型下载...'); const preferredDevice = getPreferredDevice(); const loadConfig = { prediction: "v" }; if (preferredDevice) { loadConfig.device = preferredDevice; if (preferredDevice === 'cpu') { loadConfig.threads = 4; } console.log(使用缓存的设备偏好: ${preferredDevice}); }

loadedModelId = await loadModel({ modelSrc: SD_V2_1_1B_Q8_0, modelType: "sdcpp-generation", modelConfig: loadConfig, onProgress: (p) => { modelLoadPercent = p.percentage; modelLoadStatus = p.percentage >= 100 ? '模型已完全本地加载。' : 正在下载模型权重... (${p.percentage.toFixed(1)}%); broadcastModelProgress(Math.round(modelLoadPercent), modelLoadStatus); } }); process.modelId = loadedModelId;

isModelLoading = false; console.log('模型加载成功。ID:', loadedModelId); } catch (err) { isModelLoading = false; modelLoadPercent = 0; modelLoadStatus = '加载模型失败: ' + err.message; console.error('加载模型失败:', err); broadcastModelProgress(0, modelLoadStatus); socket.emit('error_event', { message: '加载模型失败: ' + err.message }); } });

socket.on('generate', async (data) => { const { prompt, ratio } = data; if (!prompt || prompt.trim() === '') { socket.emit('error_event', { message: '需要提示词' }); return; }

if (!loadedModelId) { socket.emit('error_event', { message: '模型尚未加载' }); return; }

const runDiffusion = async (modelIdToUse) => { socket.emit('progress', { percent: 0, status: '开始扩散过程...', sub: '扩散初始化' });

console.log(为提示语 "\(${prompt}" 以比例 \${ratio} 使用模型 ID: \${modelIdToUse} 生成图像);

const { progressStream, outputs, stats } = diffusion({ modelId: modelIdToUse, prompt, });

// 流式传输进度步骤 for await (const { step, totalSteps } of progressStream) { const percent = Math.round((step / totalSteps) * 100); socket.emit('progress', { percent, status: 去噪步骤 \${step}/\${totalSteps}..., sub: 'RUNNING DIFFUSION' }); }

// 解析输出缓冲区 const buffers = await outputs; if (!buffers || buffers.length === 0) { throw new Error('扩散模型未返回图像缓冲区。'); }

// 将图像缓冲区转换为 base64 数据 URL，而不是保存到磁盘 const base64Data = Buffer.from(buffers[0]).toString('base64'); const dataUrl = data:image/png;base64,\${base64Data};

// 发出成功事件 socket.emit('success', { url: dataUrl, prompt, seed: (await stats).seed || -1 });

console.log(图像已成功以 base64 数据 URL 的形式生成并发出。); };

try { await runDiffusion(loadedModelId); } catch (err) { console.error('图像生成失败:', err);

const isCrash = err.code === 50205 || (err.message && err.message.includes('WORKER_CRASHED')); if (isCrash) { console.log('GPU 执行期间工作线程崩溃。尝试切换到 CPU 模式...');

// 保存设备偏好，以便下次直接加载 CPU 模型，避免重复加载 setPreferredDevice('cpu');

// 重置过期模型状态 loadedModelId = null; process.modelId = null;

socket.emit('progress', { percent: 0, status: 'GPU 驱动崩溃。自动切换到 CPU 模式...', sub: 'CPU FALLBACK LOADING' });

try { console.log('正在加载 CPU 模型...'); isModelLoading = true; modelLoadPercent = 0; modelLoadStatus = '加载 CPU 模型权重...'; broadcastModelProgress(modelLoadPercent, modelLoadStatus);

loadedModelId = await loadModel({ modelSrc: SD_V2_1_1B_Q8_0, modelType: "sdcpp-generation", modelConfig: { prediction: "v", device: 'cpu', threads: 4 }, onProgress: (p) => { modelLoadPercent = p.percentage; modelLoadStatus = 加载 CPU 模型权重... (\${p.percentage.toFixed(1)}%); broadcastModelProgress(Math.round(modelLoadPercent), modelLoadStatus); } }); process.modelId = loadedModelId; isModelLoading = false; console.log('CPU 上模型加载成功。ID:', loadedModelId);

// 在 CPU 上重试扩散
await runDiffusion(loadedModelId);
} catch (cpuErr) {
  console.error('CPU 回退执行失败:', cpuErr);
  isModelLoading = false;
  socket.emit('error_event', { message: '在 CPU 上生成图像失败: ' + cpuErr.message });
}
} else {
  if (err.message && (err.message.includes('MODEL_NOT_FOUND') || err.message.includes('not found'))) {
    loadedModelId = null;
    process.modelId = null;
    broadcastModelProgress(0, '模型状态丢失。请重新触发下载。');
  }
  socket.emit('error_event', { message: '图像生成失败: ' + err.message });
}
}
});
});

app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

server.listen(PORT, () => {
  console.log(`服务器正在运行于 http://localhost:${PORT}`);
});

// 清理退出处理程序
async function handleCleanup() {
  const modelId = process.modelId || loadedModelId;
  if (modelId && modelId !== 'mock-model-id') {
    try {
      await unloadModel({ modelId, clearStorage: false });
    } catch (err) {}
  }
  process.exit(0);
}

process.on('SIGINT', handleCleanup);
process.on('SIGTERM', handleCleanup);

2. 前端架构概述

由于我们的应用程序完全在本地运行，前端是一个使用原始 HTML、CSS 和客户端 JavaScript 构建的单页 Web 应用，通过 Socket.io WebSocket 与 Express 服务器进行通信。

为了避免让本教程充斥数百行的 UI 模板和样式表，我们将完全专注于后端的协调工作。你可以从 GitHub 仓库获取完整的 HTML 布局、Tailwind 样式和客户端脚本。

以下是客户端在幕后与服务器通信的摘要：

• 预检同步（trigger-model-download）：页面加载后，客户端立即建立 WebSocket 连接并发出 trigger-model-download 事件。服务器拦截此事件以检查模型是否已缓存或正在加载，并开始广播进度。

• 去噪流（progress）：在图像生成过程中，服务器持续流式传输包含去噪统计信息的进度事件（例如去噪步骤 12/20...）。客户端相应地更新视觉进度条和状态标签。

• 数据 URL 传输（success）：当扩散步骤完成时，服务器将二进制图像缓冲区转换为 Base64 字符串并发出 success 事件。客户端将此 Base64 数据 URL 直接绑定到 <img> 元素的源，以实现本地直接显示和即时下载。

代码库分解

让我们揭开使我们的本地离线图像生成器顺畅运行的关键机制。

1. 多客户端模型 ID 绑定（process.modelId）

量化权重需要大量内存。每次我们调用 loadModel() 时，QVAC 会启动一个单独的 C++ 后台进程（一个 Bare 工作线程）来托管 GGML 运行时。

为了防止在客户端刷新页面或打开另一个浏览器标签时多次启动进程或多次加载 2.3 GB 的 GGUF 模型，我们在 Node 的 process 对象上全局存储已加载的模型 ID：

let loadedModelId = process.modelId || null;
// ...
process.modelId = loadedModelId;

这在整个进程中充当一个单例注册表。但使用全局变量引入了一个挑战：过时的工作者进程。如果客户端触发模型加载，获取了一个 ID，而之后的后台工作者进程崩溃或被终止，process.modelId 仍会保留一个无效的引用。

为了解决这个问题，每当有新客户端连接并请求模型下载触发时，我们会使用 getLoadedModelInfo 对模型 ID 进行预检查：

if (loadedModelId) {
  try {
    await getLoadedModelInfo({ modelId: loadedModelId });
    socket.emit('model-download-progress', { percent: 100, status: 'Model fully loaded locally.' });
    return;
  } catch (err) {
    console.log('Model ID was stale, resetting state...', err.message);
    loadedModelId = null;
    process.modelId = null;
  }
}

如果后台工作者进程已经死亡，getLoadedModelInfo 会抛出错误。catch 块会拦截这个错误，清除无效的引用，并安全地重新启动加载流程。

[!IMPORTANT] 进程单例完整性：在开始推理之前，始终预检查模型状态的可见性。如果没有验证检查，对一个无效的模型 ID 调用 diffusion() 会立即触发客户端连接超时，并导致后端工作者静默失败。

2. 内存中的图像序列化（零磁盘写入）

将生成的图像写入服务器的硬盘会带来显著的 I/O 开销。这迫使你编写自定义的定时清理脚本来删除旧的图像文件，并且在高用户流量的系统上，存在磁盘空间不足的风险。

由于 QVAC 的 diffusion() 函数直接以内存中的二进制缓冲区（Uint8Array）形式输出生成的 PNG 文件，我们完全绕过了本地文件系统。我们直接在内存中将二进制数组序列化为 Base64 字符串：

const base64Data = Buffer.from(buffers[0]).toString('base64');
const dataUrl = `data:image/png;base64,${base64Data}`;

这个 Data URL 通过 WebSocket 传输到客户端，客户端会立即将其绑定到图像元素：

• 零磁盘开销：服务器不会将任何字节写入硬盘，从而保护 SSD 寿命并防止存储膨胀。

• 瞬时传输：传输完全在内存网络缓冲区中进行，绕过了磁盘序列化的延迟。

• 客户端无缝集成：客户端不需要请求静态图像 URL 路径。它可以直接渲染 Base64 Data URL，使用户能够立即保存或下载图像。

3. GPU 到 CPU 的回退与偏好缓存策略

本地优先 AI 最大的挑战之一是客户端硬件的异构性。例如，带有独立 AMD Radeon GPU 的旧款 Intel Mac 支持 Apple 的 Metal 框架，但缺少 Stable Diffusion 引擎使用的现代张量缩减操作符，这会导致在 ggml-metal-ops.cpp 中发生严重的 C++ 崩溃（SIGABRT）。

为了保持应用程序的运行并确保我们不会触发模型加载两次（一次在启动时的不兼容 GPU 上，一次在首次提示崩溃后的 CPU 回退上），我们使用了一个持久的设备偏好缓存文件（.device-preference.json）和我们的 C++ 工作者崩溃拦截器：

try {
  await runDiffusion(loadedModelId);
} catch (err) {
  const isCrash = err.code === 50205 || err.message.includes('WORKER_CRASHED');
  if (isCrash) {
    // 1. 在磁盘上缓存 CPU 优先级
    setPreferredDevice('cpu');

    // 2. 重置无效引用
    loadedModelId = null;
    process.modelId = null;

// 3. 自动在 CPU 上使用多线程加载模型
loadedModelId = await loadModel({
  modelSrc: SD_V2_1_1B_Q8_0,
  modelType: "sdcpp-generation",
  modelConfig: { prediction: "v", device: "cpu", threads: 4 }
});
process.modelId = loadedModelId;

// 4. 透明地重试生成
await runDiffusion(loadedModelId);
}
}

这种方法采用了一种双重防御机制：

• 动态恢复：如果 GPU 驱动程序错误导致崩溃，应用程序会拦截该错误，将 "device": "cpu" 保存到 .device-preference.json 文件中，动态地将权重重新加载到 CPU 线程中，并重试生成。客户端只需看到状态更新，表明正在发生 CPU 回退，从而避免了原本会导致致命崩溃的情况。

• 优选持久化：下一次服务器启动或页面加载时，预检加载程序会从磁盘读取缓存的偏好设置，并立即加载 CPU 模型：

const preferredDevice = getPreferredDevice(); // 读取 .device-preference.json
const loadConfig = { prediction: "v" };
if (preferredDevice) {
  loadConfig.device = preferredDevice;
  if (preferredDevice === 'cpu') {
    loadConfig.threads = 4;
  }
}
loadedModelId = await loadModel({
  modelSrc: SD_V2_1_1B_Q8_0,
  modelType: "sdcpp-generation",
  modelConfig: loadConfig,
  // ...
});

这可以防止服务器在后续会话中重复尝试加载 GPU，确保模型仅加载一次，并直接加载到正确的硬件执行目标上。

[!WARNING] CPU 回退延迟：虽然 CPU 模式可以保证在较旧的硬件上具有弹性，但它使用的是顺序多线程计算，而不是 GPU 硬件核心。因此，生成时间将显著增加（通常在 CPU 上需要 1 到 2 分钟，而在兼容的 GPU 上只需要 10 到 15 秒）。请确保在 UI 中设计响应式的进度加载器，以管理用户在回退期间的预期。

结论

使用 QVAC 在本地优先运行 Stable Diffusion，可以完全控制您的推理成本和数据隐私。通过将设备上的 GGML 模型与一个简单的 Node.js WebSocket 后端相结合，您可以构建完全离线运行的响应式网络工具，而无需花费任何云 API 的费用。

随着移动和桌面系统芯片架构不断集成更多的神经引擎，本地优先的 AI 架构将为现代开发人员提供越来越强大的选项。

资源和进一步阅读

• QVAC 图像到图像生成文档

• QVAC SDK GitHub 仓库

• Hugging Face 上的 Stable Diffusion GGUF 模型

• Socket.io WebSocket 指南

• 完整代码库

👋 我是 Jibril Mugisho，我是一名专注于使用 AI 和现代后端技术构建智能、可扩展应用的全栈开发人员。我的工作重点是 AI 代理开发、LLM 集成以及创建增强自动化和决策制定的自主系统。我喜欢使用 LangChain 构建 AI 驱动的工作流程，并喜欢摆弄本地推理设置，以探索高效且注重隐私的 AI 解决方案。

如果你读到这里，请感谢作者，以表明你对他们的关心。说声谢谢

免费学习编程。freeCodeCamp 的开源课程已帮助超过 40,000 人成为开发人员。立即开始

ADVERTISEMENT