如何用深度学习输入两向量输出预测矩阵？神经网络数据输入遇阻求助

一、数据输入处理 #

首先解决数据加载的问题，你需要将两个向量作为独立输入，配合对应的矩阵标签构建数据集。以PyTorch为例，自定义Dataset来封装数据：

import torch
from torch.utils.data import Dataset, DataLoader

class MatrixPredDataset(Dataset):
    def __init__(self, vec1_data, vec2_data, mat_labels):
        # vec1_data: (样本数N, 2048)
        # vec2_data: (N, 91)
        # mat_labels: (N, 2048, 91)
        self.vec1 = vec1_data
        self.vec2 = vec2_data
        self.labels = mat_labels

    def __len__(self):
        return len(self.vec1)

    def __getitem__(self, idx):
        # 转为(1,2048)和(1,91)的张量，匹配输入形状要求
        return (torch.tensor(self.vec1[idx], dtype=torch.float32).unsqueeze(0),
                torch.tensor(self.vec2[idx], dtype=torch.float32).unsqueeze(0),
                torch.tensor(self.labels[idx], dtype=torch.float32))

# 示例数据构建
N = 100
vec1_samples = torch.randn(N, 2048)
vec2_samples = torch.randn(N, 91)
mat_labels = torch.randn(N, 2048, 91)

dataset = MatrixPredDataset(vec1_samples, vec2_samples, mat_labels)
dataloader = DataLoader(dataset, batch_size=8, shuffle=True)

Dataloader会自动将批量数据打包为(batch_size,1,2048)、(batch_size,1,91)的输入张量，以及(batch_size,2048,91)的标签张量。

二、网络结构设计与实现 #

核心是让两个向量进行特征交互，最终映射为目标矩阵，这里提供两种实用方案：

方案1：特征编码+外积交互（推荐，更贴合向量逻辑） #

先对两个向量分别做特征变换，再通过批量外积实现维度扩张，最后用轻量层微调输出：

import torch.nn as nn

class MatrixPredictor(nn.Module):
    def __init__(self):
        super().__init__()
        # 对1×2048向量做特征变换，保持维度不变
        self.vec1_encoder = nn.Sequential(
            nn.Linear(2048, 2048),
            nn.ReLU(),
            nn.Linear(2048, 2048)
        )
        # 对1×91向量做特征变换，保持维度不变
        self.vec2_encoder = nn.Sequential(
            nn.Linear(91, 91),
            nn.ReLU(),
            nn.Linear(91, 91)
        )
        # 1×1卷积微调交互后的特征（可选，按需调整）
        self.adjust_layer = nn.Conv2d(1, 1, kernel_size=1, bias=True)

    def forward(self, vec1, vec2):
        # 压缩中间维度，得到(batch_size,2048)和(batch_size,91)
        vec1 = vec1.squeeze(1)
        vec2 = vec2.squeeze(1)
        # 特征编码
        vec1_encoded = self.vec1_encoder(vec1)
        vec2_encoded = self.vec2_encoder(vec2)
        # 批量外积：得到(batch_size,2048,91)的初始矩阵
        interaction = torch.bmm(vec1_encoded.unsqueeze(2), vec2_encoded.unsqueeze(1))
        # 增加通道维度适配卷积，微调后压缩回目标形状
        interaction = interaction.unsqueeze(1)
        output = self.adjust_layer(interaction).squeeze(1)
        return output

方案2：拼接向量+全连接映射（简单直接） #

将两个向量拼接后，用全连接层直接输出展开后的矩阵元素，再reshape为目标形状：

class MatrixPredictorSimple(nn.Module):
    def __init__(self):
        super().__init__()
        # 拼接后向量长度=2048+91=2139，目标矩阵元素数=2048×91=186368
        self.fc_stack = nn.Sequential(
            nn.Linear(2139, 4096),
            nn.ReLU(),
            nn.Linear(4096, 186368)
        )

    def forward(self, vec1, vec2):
        vec1 = vec1.squeeze(1)
        vec2 = vec2.squeeze(1)
        # 拼接两个向量
        concat_vec = torch.cat([vec1, vec2], dim=1)
        # 输出展开的矩阵并reshape
        flat_output = self.fc_stack(concat_vec)
        output = flat_output.view(-1, 2048, 91)
        return output

注意：方案2的全连接层参数规模极大，仅适合数据量充足或任务简单的场景，否则容易过拟合。

三、基本训练流程 #

以回归任务为例，使用MSE损失函数的训练代码：

# 初始化组件
model = MatrixPredictor()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
loss_fn = nn.MSELoss()

# 训练循环
for epoch in range(50):
    model.train()
    total_loss = 0.0
    for vec1_batch, vec2_batch, label_batch in dataloader:
        optimizer.zero_grad()
        pred_batch = model(vec1_batch, vec2_batch)
        loss = loss_fn(pred_batch, label_batch)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * vec1_batch.size(0)
    avg_loss = total_loss / len(dataset)
    print(f"Epoch {epoch+1}, Avg Loss: {avg_loss:.4f}")

内容的提问来源于stack exchange，提问作者Simone Liu