@icyfenix-dmla/cli 2026.5.2-7 → 2026.5.3-821

package/shared_modules/bayesian/simple_bayesian_network.py

@@ -0,0 +1,99 @@
+# SimpleBayesianNetwork 类定义
+# 从文档自动提取生成
+
+class SimpleBayesianNetwork:
+    """
+    简单贝叶斯网络实现
+    支持离散变量和精确推断（枚举法）
+    """
+    def __init__(self):
+        self.nodes = {}  # 节点信息：{name: {'parents': [], 'values': []}}
+        self.cpts = {}   # 条件概率表：{name: {parent_values: {value: prob}}}
+        self.topo_order = []  # 拓扑排序
+    
+    def add_node(self, name, values, parents=None):
+        """添加节点"""
+        if parents is None:
+            parents = []
+        self.nodes[name] = {'parents': parents, 'values': values}
+        self._update_topo_order()
+    
+    def set_cpt(self, name, cpt):
+        """
+        设置条件概率表
+        
+        cpt格式：{parent_value_tuple: {value: prob}}
+        对于无父节点的变量：{(): {value: prob}}
+        """
+        self.cpts[name] = cpt
+    
+    def _update_topo_order(self):
+        """计算拓扑排序"""
+        visited = set()
+        order = []
+        
+        def visit(node):
+            if node in visited:
+                return
+            visited.add(node)
+            for parent in self.nodes[node]['parents']:
+                visit(parent)
+            order.append(node)
+        
+        for node in self.nodes:
+            visit(node)
+        
+        self.topo_order = order
+    
+    def get_prob(self, name, value, parent_values):
+        """获取条件概率 P(name=value | parent_values)"""
+        parent_key = tuple(parent_values) if parent_values else ()
+        return self.cpts[name].get(parent_key, {}).get(value, 0)
+    
+    def joint_prob(self, assignment):
+        """计算联合概率 P(X1, X2, ...)"""
+        prob = 1.0
+        for node in self.topo_order:
+            parents = self.nodes[node]['parents']
+            parent_values = [assignment[p] for p in parents]
+            value = assignment[node]
+            prob *= self.get_prob(node, value, parent_values)
+        return prob
+    
+    def enumerate_inference(self, query, evidence):
+        """
+        枚举推断：计算 P(query | evidence)
+        
+        query: {node: '?'} 返回分布
+        evidence: {node: value}
+        """
+        query_nodes = list(query.keys())
+        hidden = [n for n in self.nodes if n not in query_nodes and n not in evidence]
+        
+        def enumerate_assignments(variables, current):
+            if not variables:
+                yield current.copy()
+                return
+            var = variables[0]
+            for value in self.nodes[var]['values']:
+                current[var] = value
+                yield from enumerate_assignments(variables[1:], current)
+            del current[var]
+        
+        query_values = {}
+        total = 0.0
+        
+        query_node = query_nodes[0]
+        for qv in self.nodes[query_node]['values']:
+            prob_sum = 0.0
+            for assignment in enumerate_assignments(hidden, {}):
+                assignment.update(evidence)
+                assignment[query_node] = qv
+                prob_sum += self.joint_prob(assignment)
+            query_values[qv] = prob_sum
+            total += prob_sum
+        
+        # 归一化
+        for k in query_values:
+            query_values[k] /= total
+        return query_values

package/shared_modules/bayesian/simple_bayesiannetwork.py

@@ -0,0 +1,99 @@
+# SimpleBayesianNetwork 类定义
+# 从文档自动提取生成
+
+class SimpleBayesianNetwork:
+    """
+    简单贝叶斯网络实现
+    支持离散变量和精确推断（枚举法）
+    """
+    def __init__(self):
+        self.nodes = {}  # 节点信息：{name: {'parents': [], 'values': []}}
+        self.cpts = {}   # 条件概率表：{name: {parent_values: {value: prob}}}
+        self.topo_order = []  # 拓扑排序
+    
+    def add_node(self, name, values, parents=None):
+        """添加节点"""
+        if parents is None:
+            parents = []
+        self.nodes[name] = {'parents': parents, 'values': values}
+        self._update_topo_order()
+    
+    def set_cpt(self, name, cpt):
+        """
+        设置条件概率表
+        
+        cpt格式：{parent_value_tuple: {value: prob}}
+        对于无父节点的变量：{(): {value: prob}}
+        """
+        self.cpts[name] = cpt
+    
+    def _update_topo_order(self):
+        """计算拓扑排序"""
+        visited = set()
+        order = []
+        
+        def visit(node):
+            if node in visited:
+                return
+            visited.add(node)
+            for parent in self.nodes[node]['parents']:
+                visit(parent)
+            order.append(node)
+        
+        for node in self.nodes:
+            visit(node)
+        
+        self.topo_order = order
+    
+    def get_prob(self, name, value, parent_values):
+        """获取条件概率 P(name=value | parent_values)"""
+        parent_key = tuple(parent_values) if parent_values else ()
+        return self.cpts[name].get(parent_key, {}).get(value, 0)
+    
+    def joint_prob(self, assignment):
+        """计算联合概率 P(X1, X2, ...)"""
+        prob = 1.0
+        for node in self.topo_order:
+            parents = self.nodes[node]['parents']
+            parent_values = [assignment[p] for p in parents]
+            value = assignment[node]
+            prob *= self.get_prob(node, value, parent_values)
+        return prob
+    
+    def enumerate_inference(self, query, evidence):
+        """
+        枚举推断：计算 P(query | evidence)
+        
+        query: {node: '?'} 返回分布
+        evidence: {node: value}
+        """
+        query_nodes = list(query.keys())
+        hidden = [n for n in self.nodes if n not in query_nodes and n not in evidence]
+        
+        def enumerate_assignments(variables, current):
+            if not variables:
+                yield current.copy()
+                return
+            var = variables[0]
+            for value in self.nodes[var]['values']:
+                current[var] = value
+                yield from enumerate_assignments(variables[1:], current)
+            del current[var]
+        
+        query_values = {}
+        total = 0.0
+        
+        query_node = query_nodes[0]
+        for qv in self.nodes[query_node]['values']:
+            prob_sum = 0.0
+            for assignment in enumerate_assignments(hidden, {}):
+                assignment.update(evidence)
+                assignment[query_node] = qv
+                prob_sum += self.joint_prob(assignment)
+            query_values[qv] = prob_sum
+            total += prob_sum
+        
+        # 归一化
+        for k in query_values:
+            query_values[k] /= total
+        return query_values

package/shared_modules/cnn/__init__.py

@@ -0,0 +1,5 @@
+# CNN 模块
+from .alex_net import AlexNet
+from .tiny_imagenet_dataset import TinyImageNetDataset
+
+__all__ = ['AlexNet', 'TinyImageNetDataset']

package/shared_modules/cnn/alex_net.py

@@ -0,0 +1,65 @@
+# AlexNet 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+from PIL import Image
+
+class AlexNet(nn.Module):
+    """
+    AlexNet 网络结构
+    适配 Tiny ImageNet 200 类分类任务
+    
+    原始 AlexNet 为 1000 类，这里修改最后一层为 200 类
+    使用 AdaptiveAvgPool2d 确保输出尺寸固定为 6x6
+    """
+    def __init__(self, num_classes=200):
+        super(AlexNet, self).__init__()
+        
+        # 特征提取层 (5 个卷积层)
+        self.features = nn.Sequential(
+            # Conv1: 11x11 卷积，步长 4，输出 96 通道
+            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv2: 5x5 卷积，输出 256 通道
+            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv3: 3x3 卷积，输出 384 通道
+            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv4: 3x3 卷积，输出 384 通道
+            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv5: 3x3 卷积，输出 256 通道
+            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # 自适应池化，确保输出固定为 6x6
+            nn.AdaptiveAvgPool2d((6, 6))
+        )
+        
+        # 分类层 (3 个全连接层)
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Dropout(p=0.5),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Linear(4096, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x

package/shared_modules/cnn/alexnet.py

@@ -0,0 +1,65 @@
+# AlexNet 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+from PIL import Image
+
+class AlexNet(nn.Module):
+    """
+    AlexNet 网络结构
+    适配 Tiny ImageNet 200 类分类任务
+    
+    原始 AlexNet 为 1000 类，这里修改最后一层为 200 类
+    使用 AdaptiveAvgPool2d 确保输出尺寸固定为 6x6
+    """
+    def __init__(self, num_classes=200):
+        super(AlexNet, self).__init__()
+        
+        # 特征提取层 (5 个卷积层)
+        self.features = nn.Sequential(
+            # Conv1: 11x11 卷积，步长 4，输出 96 通道
+            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv2: 5x5 卷积，输出 256 通道
+            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv3: 3x3 卷积，输出 384 通道
+            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv4: 3x3 卷积，输出 384 通道
+            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv5: 3x3 卷积，输出 256 通道
+            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # 自适应池化，确保输出固定为 6x6
+            nn.AdaptiveAvgPool2d((6, 6))
+        )
+        
+        # 分类层 (3 个全连接层)
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Dropout(p=0.5),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Linear(4096, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x

package/shared_modules/cnn/t_e_r_m1.py

@@ -0,0 +1,65 @@
+# AlexNet 类定义
+# 从文档自动提取生成
+
+import torch
+import torch.nn as nn
+from PIL import Image
+
+class AlexNet(nn.Module):
+    """
+    AlexNet 网络结构
+    适配 Tiny ImageNet 200 类分类任务
+    
+    原始 AlexNet 为 1000 类，这里修改最后一层为 200 类
+    使用 AdaptiveAvgPool2d 确保输出尺寸固定为 6x6
+    """
+    def __init__(self, num_classes=200):
+        super(AlexNet, self).__init__()
+        
+        # 特征提取层 (5 个卷积层)
+        self.features = nn.Sequential(
+            # Conv1: 11x11 卷积，步长 4，输出 96 通道
+            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv2: 5x5 卷积，输出 256 通道
+            nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # Conv3: 3x3 卷积，输出 384 通道
+            nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv4: 3x3 卷积，输出 384 通道
+            nn.Conv2d(384, 384, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            
+            # Conv5: 3x3 卷积，输出 256 通道
+            nn.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            
+            # 自适应池化，确保输出固定为 6x6
+            nn.AdaptiveAvgPool2d((6, 6))
+        )
+        
+        # 分类层 (3 个全连接层)
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.5),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Dropout(p=0.5),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            
+            nn.Linear(4096, num_classes)
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x

package/shared_modules/cnn/tiny_image_net_dataset.py

@@ -0,0 +1,67 @@
+# TinyImageNetDataset 类定义
+# 从文档自动提取生成
+
+import os
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+
+class TinyImageNetDataset(Dataset):
+    """
+    Tiny ImageNet 200 数据集加载器
+
+    训练集按类别子目录读取，验证集从标注文件解析标签。
+    支持自定义预处理变换，适配 AlexNet 训练需求。
+    """
+    def __init__(self, root_dir, transform=None, is_train=True):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.is_train = is_train
+
+        self.samples = []
+        self.classes = []
+
+        if is_train:
+            train_dir = os.path.join(root_dir, 'train')
+            self.classes = sorted(os.listdir(train_dir))
+            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
+
+            for cls in self.classes:
+                cls_dir = os.path.join(train_dir, cls)
+                images_dir = os.path.join(cls_dir, 'images')
+                if os.path.exists(images_dir):
+                    for img_name in os.listdir(images_dir):
+                        if img_name.endswith('.JPEG'):
+                            self.samples.append((
+                                os.path.join(images_dir, img_name),
+                                self.class_to_idx[cls]
+                            ))
+        else:
+            val_dir = os.path.join(root_dir, 'val')
+            val_images_dir = os.path.join(val_dir, 'images')
+            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
+
+            if os.path.exists(val_annotations):
+                with open(val_annotations, 'r') as f:
+                    for line in f:
+                        parts = line.strip().split('\t')
+                        if len(parts) >= 2:
+                            img_name = parts[0]
+                            cls = parts[1]
+                            if cls not in self.classes:
+                                self.classes.append(cls)
+                            self.samples.append((
+                                os.path.join(val_images_dir, img_name),
+                                self.classes.index(cls)
+                            ))
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        image = Image.open(img_path).convert('RGB')
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label

package/shared_modules/cnn/tiny_imagenet_dataset.py

@@ -0,0 +1,67 @@
+# TinyImageNetDataset 类定义
+# 从文档自动提取生成
+
+import os
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+
+class TinyImageNetDataset(Dataset):
+    """
+    Tiny ImageNet 200 数据集加载器
+
+    训练集按类别子目录读取，验证集从标注文件解析标签。
+    支持自定义预处理变换，适配 AlexNet 训练需求。
+    """
+    def __init__(self, root_dir, transform=None, is_train=True):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.is_train = is_train
+
+        self.samples = []
+        self.classes = []
+
+        if is_train:
+            train_dir = os.path.join(root_dir, 'train')
+            self.classes = sorted(os.listdir(train_dir))
+            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
+
+            for cls in self.classes:
+                cls_dir = os.path.join(train_dir, cls)
+                images_dir = os.path.join(cls_dir, 'images')
+                if os.path.exists(images_dir):
+                    for img_name in os.listdir(images_dir):
+                        if img_name.endswith('.JPEG'):
+                            self.samples.append((
+                                os.path.join(images_dir, img_name),
+                                self.class_to_idx[cls]
+                            ))
+        else:
+            val_dir = os.path.join(root_dir, 'val')
+            val_images_dir = os.path.join(val_dir, 'images')
+            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
+
+            if os.path.exists(val_annotations):
+                with open(val_annotations, 'r') as f:
+                    for line in f:
+                        parts = line.strip().split('\t')
+                        if len(parts) >= 2:
+                            img_name = parts[0]
+                            cls = parts[1]
+                            if cls not in self.classes:
+                                self.classes.append(cls)
+                            self.samples.append((
+                                os.path.join(val_images_dir, img_name),
+                                self.classes.index(cls)
+                            ))
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        image = Image.open(img_path).convert('RGB')
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label

package/shared_modules/cnn/tiny_imagenetdataset.py

@@ -0,0 +1,67 @@
+# TinyImageNetDataset 类定义
+# 从文档自动提取生成
+
+import os
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+
+class TinyImageNetDataset(Dataset):
+    """
+    Tiny ImageNet 200 数据集加载器
+
+    训练集按类别子目录读取，验证集从标注文件解析标签。
+    支持自定义预处理变换，适配 AlexNet 训练需求。
+    """
+    def __init__(self, root_dir, transform=None, is_train=True):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.is_train = is_train
+
+        self.samples = []
+        self.classes = []
+
+        if is_train:
+            train_dir = os.path.join(root_dir, 'train')
+            self.classes = sorted(os.listdir(train_dir))
+            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
+
+            for cls in self.classes:
+                cls_dir = os.path.join(train_dir, cls)
+                images_dir = os.path.join(cls_dir, 'images')
+                if os.path.exists(images_dir):
+                    for img_name in os.listdir(images_dir):
+                        if img_name.endswith('.JPEG'):
+                            self.samples.append((
+                                os.path.join(images_dir, img_name),
+                                self.class_to_idx[cls]
+                            ))
+        else:
+            val_dir = os.path.join(root_dir, 'val')
+            val_images_dir = os.path.join(val_dir, 'images')
+            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
+
+            if os.path.exists(val_annotations):
+                with open(val_annotations, 'r') as f:
+                    for line in f:
+                        parts = line.strip().split('\t')
+                        if len(parts) >= 2:
+                            img_name = parts[0]
+                            cls = parts[1]
+                            if cls not in self.classes:
+                                self.classes.append(cls)
+                            self.samples.append((
+                                os.path.join(val_images_dir, img_name),
+                                self.classes.index(cls)
+                            ))
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        image = Image.open(img_path).convert('RGB')
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label

package/shared_modules/cnn/tinyimagenetdataset.py

@@ -0,0 +1,67 @@
+# TinyImageNetDataset 类定义
+# 从文档自动提取生成
+
+import os
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+
+class TinyImageNetDataset(Dataset):
+    """
+    Tiny ImageNet 200 数据集加载器
+
+    训练集按类别子目录读取，验证集从标注文件解析标签。
+    支持自定义预处理变换，适配 AlexNet 训练需求。
+    """
+    def __init__(self, root_dir, transform=None, is_train=True):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.is_train = is_train
+
+        self.samples = []
+        self.classes = []
+
+        if is_train:
+            train_dir = os.path.join(root_dir, 'train')
+            self.classes = sorted(os.listdir(train_dir))
+            self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
+
+            for cls in self.classes:
+                cls_dir = os.path.join(train_dir, cls)
+                images_dir = os.path.join(cls_dir, 'images')
+                if os.path.exists(images_dir):
+                    for img_name in os.listdir(images_dir):
+                        if img_name.endswith('.JPEG'):
+                            self.samples.append((
+                                os.path.join(images_dir, img_name),
+                                self.class_to_idx[cls]
+                            ))
+        else:
+            val_dir = os.path.join(root_dir, 'val')
+            val_images_dir = os.path.join(val_dir, 'images')
+            val_annotations = os.path.join(val_dir, 'val_annotations.txt')
+
+            if os.path.exists(val_annotations):
+                with open(val_annotations, 'r') as f:
+                    for line in f:
+                        parts = line.strip().split('\t')
+                        if len(parts) >= 2:
+                            img_name = parts[0]
+                            cls = parts[1]
+                            if cls not in self.classes:
+                                self.classes.append(cls)
+                            self.samples.append((
+                                os.path.join(val_images_dir, img_name),
+                                self.classes.index(cls)
+                            ))
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        image = Image.open(img_path).convert('RGB')
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label

package/shared_modules/linear/__init__.py

@@ -0,0 +1,6 @@
+# Linear 模块
+from .logistic_regression import LogisticRegression
+from .ridge_regression import RidgeRegression
+from .lasso_regression import LassoRegression
+
+__all__ = ['LogisticRegression', 'RidgeRegression', 'LassoRegression']