@icyfenix-dmla/cli 2026.5.10-1505 → 2026.5.13-1007

package/package.json

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

package/shared/__init__.py

@@ -6,6 +6,7 @@ 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

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

package/shared/gan/dcgan_generator.py

@@ -1,47 +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))
+        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

@@ -61,6 +61,15 @@ const DATASETS = [
     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)'
   }
 ]
 

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-10T07:07:46.886Z",
-  "cliVersion": "2026.5.10-1505"
+  "buildTime": "2026-05-13T02:08:13.257Z",
+  "cliVersion": "2026.5.13-1007"
 }