解决 'AttributeError: 'DataLoader' object has no attribute 'flatten'' 错误

'DataLoader' 对象本身没有 'flatten' 属性。

以下是经过修正的代码，可以正确划分训练集和验证集并进行训练：

import torch
import torch.optim as optim
import torch.nn.functional as F
import torch.nn as nn
from torch.utils.data import DataLoader, random_split

file_path = r"C:\Users\18105\Desktop\MVSA-Single\MVSA_Single\biaoqian.txt"

# 读取标签数据
tensor_list = []
with open(file_path, 'r') as file:
    lines = file.readlines()
    for line in lines:
        line = line.strip()
        numbers = line.split()
        tensor = torch.tensor([float(num) for num in numbers])
        tensor_list.append(tensor)

# 创建网络实例
class MyNetwork(nn.Module):
    def __init__(self):
        super(MyNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(512 * 256, 256)
        self.fc2 = nn.Linear(256, 4)

    def forward(self, x):
        x = self.flatten(x)
        x = self.fc1(x)
        x = torch.relu(x)
        x = self.fc2(x)
        return x

network = MyNetwork()

# 指定pt文件的路径和训练数据
pt_file_path = r'C:\Users\18105\PycharmProjects\tuwenqingganfenxi\expanded.pt'
data = torch.load(pt_file_path)

# 将数据转换为张量
input_tensors = [torch.tensor(tensor) for tensor in data]

# 划分训练集和验证集
train_size = int(0.8 * len(input_tensors))
val_size = len(input_tensors) - train_size
train_tensors, val_tensors = random_split(input_tensors, [train_size, val_size])

# 创建训练集和验证集的数据加载器
batch_size = 64
train_loader = DataLoader(train_tensors, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_tensors, batch_size=batch_size, shuffle=False)

# 自定义损失函数
def custom_loss(output, label):
    target_similarity = F.cosine_similarity(output, label.unsqueeze(1), dim=1)

    other_similarities = []
    for i, tensor in enumerate(label):
        if i != torch.argmax(label):
            similarity = F.cosine_similarity(output, tensor.unsqueeze(1), dim=1)
            other_similarities.append(similarity)

    other_similarities = torch.cat(other_similarities)
    diff = target_similarity - torch.max(other_similarities)
    loss = 1 - diff

    return loss

# 定义损失函数和优化器
optimizer = optim.Adam(network.parameters(), lr=0.01)

# 训练网络
num_epochs = 100
for epoch in range(num_epochs):
    running_loss = 0.0
    correct = 0
    total = 0

    # 训练阶段
    network.train()
    for i, input_tensor in enumerate(train_loader):
        # 清零梯度
        optimizer.zero_grad()

        # 前向传播
        output = network(input_tensor)

        # 计算损失
        loss = custom_loss(output, tensor_list[i])

        # 反向传播和优化
        loss.backward()
        optimizer.step()

        # 统计准确率
        _, predicted = torch.max(output.data, 1)
        total += input_tensor.size(0)
        correct += (predicted == torch.argmax(tensor_list[i])).sum().item()

        # 累计损失
        running_loss += loss.item()

    # 打印训练信息
    print('Epoch: %d, Train Loss: %.3f, Train Accuracy: %.2f%%' % (epoch+1, running_loss, 100 * correct / total))

    # 验证阶段
    network.eval()
    val_loss = 0.0
    val_correct = 0
    val_total = 0

    with torch.no_grad():
        for j, val_input_tensor in enumerate(val_loader):
            val_output = network(val_input_tensor)
            val_loss += custom_loss(val_output, tensor_list[j]).item()

            _, val_predicted = torch.max(val_output.data, 1)
            val_total += val_input_tensor.size(0)
            val_correct += (val_predicted == torch.argmax(tensor_list[j])).sum().item()

    # 打印验证信息
    print('Epoch: %d, Validation Loss: %.3f, Validation Accuracy: %.2f%%' % (epoch+1, val_loss, 100 * val_correct / val_total))

非常抱歉之前给你带来的困扰，希望这次的回答能够正确满足你的需求。如果还有任何问题，请随时提问。