@icyfenix-dmla/cli 2026.5.6-1126 → 2026.5.13-1007

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.5.6-1126",
+  "version": "2026.5.13-1007",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",

package/shared/__init__.py

@@ -3,8 +3,10 @@
 
 from .bayesian import *
 from .cnn import *
+from .gan import *
 from .linear import *
 from .neural import *
+from .sequence_models import *
 from .svm import *
 from .tree import *
 from .unsupervised import *

package/shared/gan/__init__.py

@@ -0,0 +1,6 @@
+# GAN 模块
+from .dcgan_discriminator import DCGANDiscriminator
+from .dcgan_generator import DCGANGenerator
+from .image_vae import ImageVAE
+
+__all__ = ['DCGANDiscriminator', 'DCGANGenerator', 'ImageVAE']

package/shared/gan/dcgan_discriminator.py

@@ -0,0 +1,44 @@
+import torch
+import torch.nn as nn
+
+
+class DCGANDiscriminator(nn.Module):
+    """
+    DCGAN 判别器
+
+    输入: 64×64×3 RGB 图像 (值域 [-1, 1])
+    输出: 真假概率 [0, 1]
+
+    架构: 卷积逐步下采样
+    64×64 → 32×32 → 16×16 → 8×8 → 4×4 → 1×1
+    """
+    def __init__(self, img_channels=3):
+        super(DCGANDiscriminator, self).__init__()
+
+        self.main = nn.Sequential(
+            # 3 × 64 × 64 → 64 × 32 × 32 (无 BatchNorm)
+            nn.Conv2d(img_channels, 64, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.LeakyReLU(0.2, inplace=True),
+
+            # 64 × 32 × 32 → 128 × 16 × 16
+            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.LeakyReLU(0.2, inplace=True),
+
+            # 128 × 16 × 16 → 256 × 8 × 8
+            nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(256),
+            nn.LeakyReLU(0.2, inplace=True),
+
+            # 256 × 8 × 8 → 512 × 4 × 4
+            nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+            nn.LeakyReLU(0.2, inplace=True),
+
+            # 512 × 4 × 4 → 1 × 1 × 1
+            nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=0, bias=False),
+            nn.Sigmoid()
+        )
+
+    def forward(self, img):
+        return self.main(img).view(-1)

package/shared/gan/dcgan_generator.py

@@ -0,0 +1,49 @@
+# DCGANGenerator 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+
+class DCGANGenerator(nn.Module):
+    """
+    DCGAN 生成器
+    
+    输入: 噪声向量 z (latent_dim 维)
+    输出: 64×64×3 RGB 图像 (值域 [-1, 1])
+    
+    架构: 转置卷积逐步上采样
+    1×1 → 4×4 → 8×8 → 16×16 → 32×32 → 64×64
+    """
+    def __init__(self, latent_dim=100, img_channels=3):
+        super(DCGANGenerator, self).__init__()
+        self.latent_dim = latent_dim
+        
+        self.main = nn.Sequential(
+            # 输入: latent_dim × 1 × 1 → 512 × 4 × 4
+            nn.ConvTranspose2d(latent_dim, 512, kernel_size=4, stride=1, padding=0, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(True),
+            
+            # 512 × 4 × 4 → 256 × 8 × 8
+            nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(True),
+            
+            # 256 × 8 × 8 → 128 × 16 × 16
+            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(True),
+            
+            # 128 × 16 × 16 → 64 × 32 × 32
+            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(True),
+            
+            # 64 × 32 × 32 → 3 × 64 × 64
+            nn.ConvTranspose2d(64, img_channels, kernel_size=4, stride=2, padding=1, bias=False),
+            nn.Tanh()
+        )
+    
+    def forward(self, z):
+        # 将噪声向量 reshape 为 4D 张量: (batch, latent_dim, 1, 1)
+        return self.main(z.view(z.size(0), z.size(1), 1, 1))

package/shared/gan/image_vae.py

@@ -0,0 +1,67 @@
+# ImageVAE 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+from PIL import Image
+
+class ImageVAE(nn.Module):
+    """
+    用于 MNIST 图像生成的 VAE
+
+    网络结构:
+    - 编码器: 784 → 512 → 256 → (μ, σ)
+    - 解码器: z → 256 → 512 → 784
+
+    潜在空间维度: 20
+    """
+    def __init__(self, latent_dim=20):
+        super().__init__()
+
+        # 编码器（更深的网络，提取更丰富的特征）
+        self.encoder = nn.Sequential(
+            nn.Linear(784, 512),
+            nn.ReLU(),
+            nn.Linear(512, 256),
+            nn.ReLU()
+        )
+        self.fc_mu = nn.Linear(256, latent_dim)
+        self.fc_logvar = nn.Linear(256, latent_dim)
+
+        # 解码器（对称结构）
+        self.decoder = nn.Sequential(
+            nn.Linear(latent_dim, 256),
+            nn.ReLU(),
+            nn.Linear(256, 512),
+            nn.ReLU(),
+            nn.Linear(512, 784),
+            nn.Sigmoid()  # 输出像素概率
+        )
+
+        self.latent_dim = latent_dim
+
+    def encode(self, x):
+        """编码过程"""
+        h = self.encoder(x)
+        return self.fc_mu(h), self.fc_logvar(h)
+
+    def reparameterize(self, mu, logvar):
+        """重参数化"""
+        std = torch.exp(logvar / 2)
+        eps = torch.randn_like(std)
+        return mu + std * eps
+
+    def decode(self, z):
+        """解码过程"""
+        return self.decoder(z)
+
+    def forward(self, x):
+        """完整流程"""
+        mu, logvar = self.encode(x)
+        z = self.reparameterize(mu, logvar)
+        return self.decode(z), mu, logvar
+
+    def generate(self, num_samples):
+        """生成新样本"""
+        z = torch.randn(num_samples, self.latent_dim)
+        return self.decode(z)

package/shared/sequence_models/__init__.py

@@ -0,0 +1,4 @@
+# SEQUENCE_MODELS 模块
+from .poetry_lstm import PoetryLSTM
+
+__all__ = ['PoetryLSTM']

package/shared/sequence_models/poetry_lstm.py

@@ -0,0 +1,63 @@
+# PoetryLSTM 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+
+class PoetryLSTM(nn.Module):
+    """LSTM 语言模型（用于古诗词生成）
+
+    架构: Embedding -> LSTM -> Linear -> Softmax
+    """
+    def __init__(self, vocab_size, embedding_dim=256, hidden_dim=256, num_layers=2, dropout=0.3):
+        super(PoetryLSTM, self).__init__()
+
+        self.vocab_size = vocab_size
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+
+        # 嵌入层：字符索引 -> 稠密向量
+        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)
+
+        # LSTM 层
+        self.lstm = nn.LSTM(
+            input_size=embedding_dim,
+            hidden_size=hidden_dim,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0
+        )
+
+        # 输出层：隐藏状态 -> 词汇表概率分布
+        self.fc = nn.Linear(hidden_dim, vocab_size)
+
+        # Dropout 层
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x, hidden=None):
+        """
+        参数:
+            x: 输入序列 (batch_size, seq_len)
+            hidden: 初始隐藏状态 (可选)
+
+        返回:
+            output: 输出 logits (batch_size, seq_len, vocab_size)
+            hidden: 最终隐藏状态
+        """
+        # 嵌入: (batch_size, seq_len) -> (batch_size, seq_len, embedding_dim)
+        embedded = self.embedding(x)
+        embedded = self.dropout(embedded)
+
+        # LSTM: (batch_size, seq_len, embedding_dim) -> (batch_size, seq_len, hidden_dim)
+        lstm_out, hidden = self.lstm(embedded, hidden)
+
+        # 输出: (batch_size, seq_len, hidden_dim) -> (batch_size, seq_len, vocab_size)
+        output = self.fc(lstm_out)
+
+        return output, hidden
+
+    def init_hidden(self, batch_size, device):
+        """初始化隐藏状态"""
+        h0 = torch.zeros(self.num_layers, batch_size, self.hidden_dim, device=device)
+        c0 = torch.zeros(self.num_layers, batch_size, self.hidden_dim, device=device)
+        return (h0, c0)

package/src/commands/data.js

@@ -51,6 +51,25 @@ const DATASETS = [
     format: 'git',
     targetDir: 'datasets/mnist',
     source: 'ModelScope (icyfenix)'
+  },
+  {
+    id: 'cartoon-face',
+    name: 'Cartoon Face',
+    url: 'https://www.modelscope.cn/datasets/icyfenix/Cartoon_Face.git',
+    size: '288MB',
+    format: 'git',
+    targetDir: 'datasets/cartoon-face',
+    source: 'ModelScope (icyfenix)',
+    zipFile: 'faces.zip'
+  },
+  {
+    id: 'chinese-poetry',
+    name: 'Chinese Poetry (古诗词)',
+    url: 'https://www.modelscope.cn/datasets/icyfenix/Chinese-Poetry.git',
+    size: '~50MB',
+    format: 'git',
+    targetDir: 'datasets/chinese-poetry',
+    source: 'ModelScope (icyfenix)'
   }
 ]
 
@@ -578,6 +597,8 @@ async function downloadDataset(dataPath, dataset) {
     fs.mkdirSync(parentDir, { recursive: true })
   }
 
+  let hasGitLfs = false  // 在 try 块开头定义，确保整个块内可见
+
   try {
     if (dataset.format === 'git') {
       // 使用 git clone 下载 ModelScope 数据集
@@ -585,7 +606,6 @@ async function downloadDataset(dataPath, dataset) {
       console.log()
 
       // 检查并安装 Git LFS
-      let hasGitLfs = false
       try {
         execSync('git lfs install', { stdio: 'pipe' })
         hasGitLfs = true

package/src/server/kernel_runner.py

@@ -225,11 +225,15 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT, stream: bool = False) ->
         restore_stdout()
         log_debug('stdout restored for code execution')
 
-        # 3. 注入全局变量（数据路径兼容）
-        log_debug('Injecting global variables')
+        # 3. 注入全局变量和数据路径兼容
+        log_debug('Injecting global variables and matplotlib config')
         setup_code = '''
 import os
 DATA_DIR = os.environ.get('DMLA_DATA_PATH', '/data')
+
+# 配置 matplotlib inline 后端（在用户 import matplotlib 之前设置）
+import matplotlib
+matplotlib.use('module://matplotlib_inline.backend_inline')
 '''
         kc.execute(setup_code, allow_stdin=False)
         # 等待 setup 执行完成（读取并丢弃 setup 的输出）

package/src/server/sandbox.js

@@ -891,19 +891,63 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
     })
 
     // 处理日志流数据
+    let totalChunks = 0
+    let totalBytes = 0
+    let jsonBuffer = ''  // 用于累积跨多个帧的 JSON 消息
+    let frameBuffer = Buffer.alloc(0)  // 用于累积不完整的 Docker 日志帧
+
     logStream.on('data', (chunk) => {
+      totalChunks++
+      totalBytes += chunk.length
+      log(`Chunk ${totalChunks}: ${chunk.length} bytes, total: ${totalBytes} bytes`)
+
       if (Buffer.isBuffer(chunk)) {
-        // 解析 Docker 日志格式
-        const lines = parseDockerLogLines(chunk)
+        // 合并帧缓冲和新数据
+        const combinedBuffer = Buffer.concat([frameBuffer, chunk])
+        log(`Combined buffer: ${combinedBuffer.length} bytes (frameBuffer: ${frameBuffer.length}, chunk: ${chunk.length})`)
+
+        // 解析 Docker 日志格式，返回未处理的剩余缓冲
+        const { lines, remainingBuffer } = parseDockerLogLinesWithBuffer(combinedBuffer)
+        frameBuffer = remainingBuffer
+        log(`Parsed ${lines.length} messages, remaining buffer: ${frameBuffer.length} bytes`)
+
         for (const { streamType, text } of lines) {
           if (text && text.trim()) {
-            log(`Stream output (${streamType}): ${text.substring(0, 100)}...`)
+            const preview = text.substring(0, 200)
+            log(`Message (${streamType}): length=${text.length}, preview: ${preview.endsWith('...') ? preview : preview + '...'}`)
+
+            // 检查是否有未完成的 JSON 缓冲
+            if (jsonBuffer) {
+              // 将当前文本追加到缓冲
+              jsonBuffer += text
+              log(`Appending to JSON buffer, total length: ${jsonBuffer.length}`)
+
+              // 检查是否完成（找到闭合括号）
+              if (isJsonComplete(jsonBuffer)) {
+                log(`JSON buffer complete, forwarding: ${jsonBuffer.length} bytes`)
+                res.write(jsonBuffer + '\n')
+                jsonBuffer = ''
+              } else {
+                log(`JSON buffer incomplete, waiting for more data`)
+              }
+              continue
+            }
+
             // kernel_runner.py 已经输出 JSON 格式消息，直接转发
             // 检查是否已经是 JSON 格式（stream, result, progress 等消息）
             if (text.trim().startsWith('{') && text.includes('"type":')) {
-              res.write(text + '\n')
+              // 检查 JSON 是否完整
+              if (isJsonComplete(text)) {
+                log(`Forwarding complete JSON message: ${text.length} bytes`)
+                res.write(text + '\n')
+              } else {
+                // JSON 不完整，存入缓冲等待后续帧
+                log(`JSON message incomplete, buffering: ${text.length} bytes`)
+                jsonBuffer = text
+              }
             } else {
               // 非 JSON 内容（如容器启动日志），包装为 stream 消息
+              log(`Wrapping non-JSON content as stream message`)
               res.write(JSON.stringify({
                 type: 'stream',
                 name: streamType,
@@ -914,6 +958,7 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
         }
       } else {
         // 字符串格式（fallback）
+        log(`Received string chunk: ${chunk.length} chars`)
         const textLines = chunk.toString().split('\n').filter(l => l.trim())
         for (const line of textLines) {
           if (line.trim().startsWith('{') && line.includes('"type":')) {
@@ -929,6 +974,50 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
       }
     })
 
+    logStream.on('end', () => {
+      // 流结束时，处理剩余的帧缓冲
+      if (frameBuffer.length > 0) {
+        log(`Stream ended with frame buffer remaining: ${frameBuffer.length} bytes`)
+        // 尝试解析剩余的帧缓冲（可能不完整）
+        const { lines, remainingBuffer } = parseDockerLogLinesWithBuffer(frameBuffer)
+        frameBuffer = remainingBuffer
+
+        for (const { streamType, text } of lines) {
+          if (text && text.trim()) {
+            log(`Final frame message (${streamType}): length=${text.length}`)
+            // 处理剩余消息（与主循环相同的逻辑）
+            if (jsonBuffer) {
+              jsonBuffer += text
+              if (isJsonComplete(jsonBuffer)) {
+                res.write(jsonBuffer + '\n')
+                jsonBuffer = ''
+              }
+            } else if (text.trim().startsWith('{') && text.includes('"type":')) {
+              if (isJsonComplete(text)) {
+                res.write(text + '\n')
+              } else {
+                jsonBuffer = text
+              }
+            } else {
+              res.write(JSON.stringify({
+                type: 'stream',
+                name: streamType,
+                text: text
+              }) + '\n')
+            }
+          }
+        }
+      }
+
+      // 处理剩余的 JSON 缓冲
+      if (jsonBuffer) {
+        log(`Stream ended with JSON buffer remaining: ${jsonBuffer.length} bytes`)
+        // 尝试转发剩余缓冲（可能不完整但应该发送）
+        res.write(jsonBuffer + '\n')
+        jsonBuffer = ''
+      }
+    })
+
     logStream.on('error', (err) => {
       log(`Log stream error: ${err.message}`)
       const errorMsg = {
@@ -945,11 +1034,29 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
     await container.wait()
     log('Container finished')
 
-    // 等待日志流结束
+    // 等待日志流结束（带超时保护）
     await new Promise((resolve) => {
-      logStream.on('end', resolve)
+      const timeout = setTimeout(() => {
+        log('Log stream timeout, forcing resolve')
+        resolve()
+      }, 5000)  // 最多等待 5 秒
+
+      logStream.on('end', () => {
+        clearTimeout(timeout)
+        log('Log stream end event triggered')
+        resolve()
+      })
+
+      logStream.on('close', () => {
+        clearTimeout(timeout)
+        log('Log stream close event triggered')
+        resolve()
+      })
+
       // 确保流已结束（可能已经结束）
       if (logStream.destroyed || logStream.readableEnded) {
+        clearTimeout(timeout)
+        log('Log stream already ended/destroyed')
         resolve()
       }
     })
@@ -996,6 +1103,106 @@ export async function runPythonCodeStreaming(code, useGpu = false, res, imageOve
   }
 }
 
+/**
+ * 检查 JSON 字符串是否完整（括号是否匹配）
+ * @param {string} jsonStr - JSON 字符串
+ * @returns {boolean} - 是否完整
+ */
+function isJsonComplete(jsonStr) {
+  if (!jsonStr || !jsonStr.trim().startsWith('{')) return false
+
+  let depth = 0
+  let inString = false
+  let escapeNext = false
+
+  for (let i = 0; i < jsonStr.length; i++) {
+    const char = jsonStr[i]
+
+    if (escapeNext) {
+      escapeNext = false
+      continue
+    }
+
+    if (char === '\\' && inString) {
+      escapeNext = true
+      continue
+    }
+
+    if (char === '"' && !escapeNext) {
+      inString = !inString
+      continue
+    }
+
+    if (!inString) {
+      if (char === '{') depth++
+      else if (char === '}') {
+        depth--
+        if (depth === 0) {
+          // 找到闭合括号，JSON 完整
+          return true
+        }
+      }
+    }
+  }
+
+  // 未找到闭合括号
+  return false
+}
+
+/**
+ * 解析 Docker 日志流中的多行数据（带帧缓冲）
+ * Docker 日志格式: [8字节头][数据]
+ * 返回解析的消息和剩余的不完整帧缓冲
+ * @param {Buffer} buffer - Docker 日志 buffer（可能包含之前的帧缓冲）
+ * @returns {{ lines: Array, remainingBuffer: Buffer }} - 解析后的消息和剩余缓冲
+ */
+function parseDockerLogLinesWithBuffer(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    return { lines: [], remainingBuffer: Buffer.alloc(0) }
+  }
+
+  const lines = []
+  let offset = 0
+
+  while (offset < buffer.length) {
+    // 检查是否有完整的头部（8字节）
+    if (offset + 8 > buffer.length) {
+      // 头部不完整，返回剩余部分作为缓冲
+      const remainingBuffer = buffer.slice(offset)
+      return { lines, remainingBuffer }
+    }
+
+    const streamType = buffer[offset]  // 1=stdout, 2=stderr
+    const length = buffer.readUInt32BE(offset + 4)
+
+    offset += 8
+
+    // 检查是否有完整的数据
+    if (offset + length > buffer.length) {
+      // 数据不完整，返回从头部开始的部分作为缓冲
+      // 注意：需要包含头部，所以 offset 要减去 8
+      const remainingBuffer = buffer.slice(offset - 8)
+      return { lines, remainingBuffer }
+    }
+
+    const chunk = buffer.slice(offset, offset + length).toString('utf8')
+    offset += length
+
+    // 不按行分割，保留完整的 chunk（大 JSON 消息可能包含换行符）
+    // 仅处理末尾的换行符（kernel_runner.py 输出时添加的）
+    const text = chunk.endsWith('\n') ? chunk.slice(0, -1) : chunk
+    if (text.trim()) {
+      lines.push({
+        streamType: streamType === 1 ? 'stdout' : 'stderr',
+        text: text
+      })
+    }
+  }
+
+  // 所有数据已解析完成，返回空缓冲
+  return { lines, remainingBuffer: Buffer.alloc(0) }
+}
+
 /**
  * 解析 Docker 日志流中的多行数据
  * Docker 日志格式: [8字节头][数据]
@@ -1023,13 +1230,13 @@ function parseDockerLogLines(buffer) {
     const chunk = buffer.slice(offset, offset + length).toString('utf8')
     offset += length
 
-    // 按行分割（一个 Docker 消息可能包含多行）
-    const chunkLines = chunk.split('\n').filter(l => l.trim())
-    for (const line of chunkLines) {
-      // 返回包含 streamType 的对象
+    // 不按行分割，保留完整的 chunk（大 JSON 消息可能包含换行符）
+    // 仅处理末尾的换行符（kernel_runner.py 输出时添加的）
+    const text = chunk.endsWith('\n') ? chunk.slice(0, -1) : chunk
+    if (text.trim()) {
       lines.push({
         streamType: streamType === 1 ? 'stdout' : 'stderr',
-        text: line
+        text: text
       })
     }
   }

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-06T03:26:55.383Z",
-  "cliVersion": "2026.5.6-1126"
+  "buildTime": "2026-05-13T02:08:13.257Z",
+  "cliVersion": "2026.5.13-1007"
 }