大模型应用：混合专家模型（MoE）：大模型性能提升的关键技术拆解.37

import torch

# 1. 模拟参数：2个专家、输入1个任务（向量维度=3）
num_experts = 2  # 2个骑手
input_vec = torch.tensor([1.2, 3.4, 5.6])  # 任务向量（比如“猫的加速度”转的向量）
expert1 = torch.tensor([[0.1], [0.2], [0.3]])  # 专家1（科普骑手）的简单参数
expert2 = torch.tensor([[0.4], [0.5], [0.6]])  # 专家2（物理骑手）的简单参数

# 2. 门控网络：给专家打分（模拟调度员）
gate_scores = torch.softmax(torch.tensor([0.6, 0.3]), dim=0)  # 分数：专家1=0.6，专家2=0.3

# 3. 专家干活+整合结果：加权求和
output = gate_scores[0] * torch.matmul(input_vec, expert1) + gate_scores[1] * torch.matmul(input_vec, expert2)

print("最终输出：", output.item())  

import torch
import torch.nn as nn

# 1. 定义单个专家（正经的小神经网络）
class SimpleExpert(nn.Module):
    def __init__(self, input_dim=3, output_dim=1):
        super().__init__()
        # 简单两层网络：输入→隐藏层→输出
        self.net = nn.Sequential(
            nn.Linear(input_dim, 10),  # 输入层（3维）→隐藏层（10维）
            nn.ReLU(),  # 激活函数，让网络能学复杂规律
            nn.Linear(10, output_dim)  # 隐藏层→输出层（1维）
        )
    
    def forward(self, x):
        return self.net(x)  # 专家“干活”：输入→输出

# 2. 定义MoE整体（门控+2个专家+整合）
class BasicMoE(nn.Module):
    def __init__(self):
        super().__init__()
        self.expert1 = SimpleExpert()  # 专家1（科普）
        self.expert2 = SimpleExpert()  # 专家2（物理）
        self.gate = nn.Linear(3, 2)  # 门控网络：输入3维→输出2个分数（对应2个专家）
    
    def forward(self, x):
        # 步骤1：门控打分
        gate_scores = torch.softmax(self.gate(x), dim=1)  # 分数归一化（总和=1）
        # 步骤2：专家干活
        out1 = self.expert1(x)
        out2 = self.expert2(x)
        # 步骤3：整合结果（加权求和）
        output = gate_scores[:, 0:1] * out1 + gate_scores[:, 1:2] * out2
        return output

# 3. 测试运行
if __name__ == "__main__":
    moe = BasicMoE()  # 初始化MoE
    test_input = torch.tensor([[1.2, 3.4, 5.6]])  # 测试任务（1个样本）
    result = moe(test_input)
    print("MoE输出结果：", result.item())  

import torch
import torch.nn as nn

# 1. 定义通用专家类（可复用）
class Expert(nn.Module):
    def __init__(self, input_dim=4, hidden_dim=8, output_dim=2):
        super().__init__()
        # 专家网络：输入4维→隐藏层8维→输出2维（更复杂的任务）
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim)
        )
    
    def forward(self, x):
        return self.net(x)

# 2. 进阶MoE：4个专家，每次选2个，支持批量处理（一次处理多个任务）
class AdvancedMoE(nn.Module):
    def __init__(self, num_experts=4, top_k=2):
        super().__init__()
        self.num_experts = num_experts  # 4个专家（覆盖更多任务）
        self.top_k = top_k  # 每次选2个
        
        # 初始化4个专家（用ModuleList管理，方便训练）
        self.experts = nn.ModuleList([Expert() for _ in range(num_experts)])
        # 门控网络：输入4维→输出4个分数（对应4个专家）
        self.gate = nn.Linear(4, num_experts)
    
    def forward(self, x):
        # x: 批量输入，shape=(批量大小, 输入维度)，比如(2,4)代表2个任务
        batch_size = x.shape[0]
        
        # 步骤1：门控打分（给每个任务的4个专家打分）
        gate_scores = torch.softmax(self.gate(x), dim=1)  # shape=(2,4)
        # 步骤2：选每个任务分数最高的2个专家（Top-K）
        top_k_scores, top_k_indices = torch.topk(gate_scores, self.top_k, dim=1)
        
        # 步骤3：专家干活+整合结果（批量处理）
        output = torch.zeros(batch_size, 2).to(x.device)  # 初始化输出（2个任务，每个输出2维）
        for i in range(batch_size):  # 遍历每个任务
            for k in range(self.top_k):  # 遍历选中的2个专家
                expert_idx = top_k_indices[i, k]  # 第i个任务的第k个专家索引
                expert_score = top_k_scores[i, k]  # 对应的分数
                # 加权求和：分数×专家输出
                output[i] += expert_score * self.experts[expert_idx](x[i:i+1]).squeeze(0)
        
        return output

# 3. 测试批量处理
if __name__ == "__main__":
    moe = AdvancedMoE()
    # 批量输入2个任务：shape=(2,4)（2个任务，每个任务4维向量）
    batch_input = torch.tensor([[1.1, 2.2, 3.3, 4.4], [5.5, 6.6, 7.7, 8.8]])
    batch_result = moe(batch_input)
    print("批量输出结果：")
    print(batch_result)  # 输出2个结果，每个结果2维

import torch
import torch.nn as nn
from PIL import Image
import torchvision.transforms as transforms

# 1. 定义图标特性专用专家（按图标核心特性分工）
class ShapeExpert(nn.Module):
    """专家1：专门识别图标形状特性（圆形、方形、三角形）"""
    def __init__(self, input_channels=3, output_dim=3):
        super().__init__()
        # 用卷积层提取形状边缘特征（形状识别的核心）
        self.conv = nn.Conv2d(input_channels, 8, kernel_size=3, padding=1)
        self.relu = nn.ReLU()
        self.fc = nn.Linear(8*28*28, output_dim)  # 图标统一28x28大小
    
    def forward(self, x):
        # 提取形状特征：边缘越清晰，形状识别越准确
        x = self.relu(self.conv(x))
        x = x.view(x.shape[0], -1)  # 展平特征用于分类
        return self.fc(x)

class ColorExpert(nn.Module):
    """专家2：专门识别图标颜色特性（红色、蓝色、绿色）"""
    def __init__(self, input_channels=3, output_dim=3):
        super().__init__()
        # 用平均池化提取颜色均值（颜色识别的核心）
        self.avg_pool = nn.AdaptiveAvgPool2d(1)  # 输出1x1的颜色均值
        self.fc = nn.Linear(input_channels, output_dim)
    
    def forward(self, x):
        # 提取颜色特征：计算每个通道的颜色均值
        x = self.avg_pool(x).squeeze(-1).squeeze(-1)  #  shape=(批量, 3)
        return self.fc(x)

# 2. 定义图标分类MoE（门控+2个特性专家）
class IconMoE(nn.Module):
    def __init__(self):
        super().__init__()
        self.shape_expert = ShapeExpert()  # 形状专家
        self.color_expert = ColorExpert()  # 颜色专家
        # 门控网络：根据图标整体特征，判断更依赖形状还是颜色
        self.gate = nn.Linear(3*28*28, 2)  # 3通道28x28图标展平维度
    
    def forward(self, x):
        # x: 图标输入，shape=(批量, 3, 28, 28)
        batch_size = x.shape[0]
        x_flat = x.view(batch_size, -1)  # 展平用于门控打分
        
        # 步骤1：门控打分（判断当前图标分类更需要形状还是颜色专家）
        gate_scores = torch.softmax(self.gate(x_flat), dim=1)
        
        # 步骤2：专家干活（分别提取形状和颜色特性）
        shape_out = self.shape_expert(x)  # 形状分类结果（圆/方/三角）
        color_out = self.color_expert(x)  # 颜色分类结果（红/蓝/绿）
        
        # 步骤3：整合特性结果，输出最终分类（比如“红色圆形”）
        final_out = gate_scores[:, 0:1] * shape_out + gate_scores[:, 1:2] * color_out
        return final_out, gate_scores

# 3. 测试：处理单张警告图标，输出特性匹配结果和说明
if __name__ == "__main__":
    # 图标转换配置（适配模型输入）
    transform = transforms.Compose([
        transforms.Resize((28, 28)),  # 图标统一缩放到28x28
        transforms.ToTensor(),  # 转为张量（0-1范围，通道优先）
    ])
    
    # 加载测试图标（假设是“红色圆形警告图标”，路径自行修改）
    # 实际使用时替换为自己的图标路径，比如 “warning_icon.png”
    icon_path = "test_image.jpg"
    icon = Image.open(icon_path).convert("RGB")
    icon_tensor = transform(icon).unsqueeze(0)  # 增加批量维度
    
    # 初始化模型并推理
    icon_moe = IconMoE()
    result, scores = icon_moe(icon_tensor)
    
    # 结果解读：定义形状和颜色类别
    shape_classes = ["圆形", "方形", "三角形"]
    color_classes = ["红色", "蓝色", "绿色"]
    shape_pred = shape_classes[torch.argmax(result, dim=1).item()]
    color_pred = color_classes[torch.argmax(result, dim=1).item()]
    
    # 打印结果和图标特性说明
    print("===== 图标分类结果 =====")
    print(f"识别结果：{color_pred}{shape_pred}图标")
    print(f"门控分数：形状专家={scores[0,0]:.2f}，颜色专家={scores[0,1]:.2f}")