当前位置：首页 > article >正文

让大模型帮我设计crnn网络及可运行demo，gpt4o豆包qwendeepseek-r1

article 2025/2/25 9:35:58

prompt

使用 crnn 提取图像特征，给出图像好坏的二分类结果，写清楚代码备注，注释清楚向量维度大小，并给出一个可运行的 demo

1、GPT-4o

以下是一个使用 CRNN（Convolutional Recurrent Neural Network）提取图像特征并进行二分类的完整代码示例。我们将使用 PyTorch 框架来实现。代码中会包含详细的注释，解释每一步的操作和向量维度变化。

1. 安装依赖

首先，确保你已经安装了 PyTorch 和 torchvision。如果没有安装，可以使用以下命令安装：

pip install torch torchvision

2. 代码实现

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms, datasets
import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子，确保结果可复现
torch.manual_seed(42)

# 定义一个简单的自定义数据集（用于演示）
class SimpleImageDataset(Dataset):
    def __init__(self, num_samples=1000, img_size=(32, 32)):
        self.num_samples = num_samples
        self.img_size = img_size
        self.data = []
        self.labels = []

        # 生成随机图像数据
        for _ in range(num_samples):
            # 随机生成图像（0-1之间的浮点数）
            img = np.random.rand(*img_size).astype(np.float32)
            # 随机生成标签（0 或 1）
            label = np.random.randint(0, 2)
            self.data.append(img)
            self.labels.append(label)

    def __len__(self):
        return self.num_samples

    def __getitem__(self, idx):
        # 返回图像和标签
        img = self.data[idx]
        label = self.labels[idx]
        # 将图像转换为 PyTorch 张量，并添加通道维度 (1, H, W)
        img = torch.tensor(img).unsqueeze(0)  # (1, H, W)
        label = torch.tensor(label).long()  # 标签为整数
        return img, label


# 定义 CRNN 模型
class CRNN(nn.Module):
    def __init__(self, input_channels=1, num_classes=2):
        super(CRNN, self).__init__()
        # 卷积层
        self.conv = nn.Sequential(
            nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=1),  # (B, 16, H, W)
            nn.ReLU(),
            nn.MaxPool2d(2, 2),  # (B, 16, H/2, W/2)
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),  # (B, 32, H/2, W/2)
            nn.ReLU(),
            nn.MaxPool2d(2, 2)  # (B, 32, H/4, W/4)
        )

        # RNN 层
        self.rnn_input_size = 32 * (img_size[1] // 4)  # RNN 输入大小 = 通道数 * 宽度
        self.rnn = nn.LSTM(self.rnn_input_size, 128, batch_first=True, bidirectional=True)  # 双向 LSTM

        # 全连接层
        self.fc = nn.Linear(128 * 2, num_classes)  # 双向 LSTM 输出大小为 128 * 2

    def forward(self, x):
        # 输入 x 的形状: (B, C, H, W)
        batch_size = x.size(0)

        # 卷积层
        x = self.conv(x)  # (B, 32, H/4, W/4)

        # 调整形状以适配 RNN 输入
        x = x.permute(0, 2, 3, 1)  # (B, H/4, W/4, 32)
        x = x.view(batch_size, -1, self.rnn_input_size)  # (B, H/4, 32 * W/4)

        # RNN 层
        x, _ = self.rnn(x)  # (B, H/4, 128 * 2)

        # 取最后一个时间步的输出
        x = x[:, -1, :]  # (B, 128 * 2)

        # 全连接层
        x = self.fc(x)  # (B, num_classes)
        return x


# 设置超参数
img_size = (32, 32)  # 图像大小
batch_size = 16
num_epochs = 5
learning_rate = 0.001

# 创建数据集和数据加载器
dataset = SimpleImageDataset(num_samples=1000, img_size=img_size)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 初始化模型、损失函数和优化器
model = CRNN(input_channels=1, num_classes=2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    for images, labels in dataloader:
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

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

        total_loss += loss.item()

    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {total_loss/len(dataloader):.4f}")

# 测试模型
model.eval()
with torch.no_grad():
    # 从数据集中取一个样本进行测试
    test_img, test_label = dataset[0]
    test_img = test_img.unsqueeze(0)  # 添加 batch 维度 (1, 1, H, W)
    output = model(test_img)
    predicted_label = torch.argmax(output, dim=1).item()

    print(f"True Label: {test_label}, Predicted Label: {predicted_label}")

    # 可视化测试图像
    plt.imshow(test_img.squeeze(0).squeeze(0), cmap="gray")
    plt.title(f"Predicted: {predicted_label}, True: {test_label}")
    plt.show()

3. 代码说明

数据集:
- 使用了一个简单的自定义数据集 SimpleImageDataset，生成随机图像和二分类标签。
- 图像大小为 (32, 32)，标签为 0 或 1。
CRNN 模型:
- 卷积层提取图像的空间特征。
- RNN 层（LSTM）处理序列特征，输入为卷积层输出的特征序列。
- 全连接层将 RNN 的输出映射到二分类结果。
训练:
- 使用交叉熵损失函数 CrossEntropyLoss。
- 优化器为 Adam。
测试:
- 从数据集中取一个样本，使用训练好的模型进行预测，并可视化结果。

4. 运行结果

运行代码后，你会看到训练过程中的损失值，以及测试样本的预测结果和真实标签。测试图像会以灰度图形式显示。

如果你有任何问题或需要进一步的帮助，请随时告诉我！ 😊

2、豆包-1.5pro

下面是一个基于PyTorch框架实现的使用CRNN（Convolutional Recurrent Neural Network）进行图像二分类的示例代码。这个示例假设输入图像为正方形且为灰度图。对于彩色图像，可以简单修改卷积层以便处理3通道数据。

1. 引入必要的库

import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
import torch.optim as optim
from PIL import Image


# 用于图像预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.Grayscale(),
    transforms.ToTensor(),
    # 将图像数据标准化到[-1, 1]
    transforms.Normalize((0.5,), (0.5,))
])

2. 定义CRNN模型

class CRNN(nn.Module):
    def __init__(self):
        super(CRNN, self).__init__()
        # 卷积层1，输入通道数1（灰度图），输出通道数16，卷积核大小3x3，步长1，填充1
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU()
        # 最大池化层1，窗口大小2x2，步长2
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)

        # 卷积层2，输入通道数16，输出通道数32，卷积核大小3x3，步长1，填充1
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU()
        # 最大池化层2，窗口大小2x2，步长2
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)

        # 展平层，将多维张量展平为一维
        self.flatten = nn.Flatten()
        # RNN层，这里使用GRU，输入特征维度32 * 8 * 8 ，隐藏层维度64，1层
        self.gru = nn.GRU(input_size=32 * 8 * 8, hidden_size=64, num_layers=1, batch_first=True)
        # 全连接层，将GRU输出的64维向量映射到2维（2个类别）
        self.fc = nn.Linear(64, 2)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = self.flatten(x)
        x = x.unsqueeze(1)
        x, _ = self.gru(x)
        # 只取GRU最后一个时刻的输出
        x = x[:, -1, :]
        x = self.fc(x)
        return x

3. 定义训练过程

# 创建数据加载器，假设数据按类别存放在data/train目录下
train_dataset = ImageFolder(root='data/train', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 创建模型实例
model = CRNN()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    running_loss = 0.0
    correct = 0
    total = 0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}, '
          f'Accuracy: {correct / total * 100}%')

4. 定义预测过程

# 创建测试集数据加载器，假设数据按类别存放在data/test目录下
test_dataset = ImageFolder(root='data/test', transform=transform)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 评估模型
correct = 0
total = 0
with torch.no_grad():
    for data in test_loader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the test images: {correct / total * 100}%')


def predict_single_image(image_path, model):
    img = Image.open(image_path).convert('L')
    img = transform(img).unsqueeze(0)
    with torch.no_grad():
        output = model(img)
        _, predicted = torch.max(output.data, 1)
    return predicted.item()

5. 运行预测

# 预测单个图像，这里假设image.jpg是需要预测的图像
predicted_class = predict_single_image('image.jpg', model)
print(f'Predicted class for single image: {predicted_class}')

代码说明

图像预处理：使用transforms.Compose将图像调整大小为32x32，转换为灰度图，然后转换为张量并进行标准化。
CRNN模型：
- 卷积层部分：使用了两个Conv2d层和对应的ReLU激活函数以及MaxPool2d池化层进行特征提取。Conv2d层用于学习图像的局部特征，池化层用于降低数据维度。
- RNN层部分：将卷积层输出的数据展平后输入到GRU层，学习序列特征（此处将图像数据看成一个序列）。
- 全连接层：将GRU层的输出映射到2个类别，输出最终的分类结果。
训练过程：
- 加载训练数据集，使用ImageFolder和DataLoader按批次加载数据。
- 定义损失函数（CrossEntropyLoss）和优化器（Adam）。
- 在每个epoch中，前向传播计算损失，反向传播更新模型参数，并打印每个epoch的损失和准确率。
预测过程：
- 加载测试数据集，对测试集进行评估并打印准确率。
- predict_single_image函数用于对单个图像进行预测，返回预测的类别。

请确保安装了torch、torchvision和Pillow库，可以使用以下命令安装：

pip install torch torchvision pillow

测试和训练数据集的目录结构应如下：

data/
├── train/
│   ├── good_images/
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └──...
│   └── bad_images/
│       ├── image3.jpg
│       ├── image4.jpg
│       └──...
└── test/
    ├── good_images/
    │   ├── image5.jpg
    │   ├── image6.jpg
    │   └──...
    └── bad_images/
        ├── image7.jpg
        ├── image8.jpg
        └──...

在实际应用中，你可以根据具体的数据集和任务需求调整模型架构、超参数等。

3、Qwen-2.5

好的，下面是一个使用CRNN（卷积循环神经网络）提取图像特征并用于二分类任务的PyTorch示例代码。我们将使用一个简单的CRNN模型来实现这个任务。代码中会包含详细的注释说明每一步的操作和向量维度的变化。

首先，确保你已经安装了必要的库：

pip install torch torchvision

以下是完整的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets
from torch.utils.data import DataLoader

# 定义CRNN模型
class CRNN(nn.Module):
    def __init__(self, num_classes=2, input_size=1024, hidden_size=512, num_layers=2):
        super(CRNN, self).__0__init__()
        self.num_classes = num_classes
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        # 卷积层
        self.conv = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 64, H/2, W/2)
            
            nn.Conv2d(64, 128, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 128, H/4, W/4)
            
            nn.Conv2d(128, 256, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2)),  # (B, 256, H/8, W/8)
            
            nn.Conv2d(256, 512, kernel_size=(3, 3), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))   # (B, 512, H/16, W/16)
        )
        
        # 计算经过卷积层后的输出尺寸
        self.fc_input_size = 512 * (32 // 16) * (32 // 16)  # 假设输入图像大小为 (B, 3, 32, 32)
        
        # 全连接层
        self.fc = nn.Linear(self.fc_input_size, input_size)
        
        # 循环层
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        
        # 输出层
        self.fc_out = nn.Linear(hidden_size, num_classes)
    
    def forward(self, x):
        # 卷积层
        conv_out = self.conv(x)  # (B, 512, H/16, W/16)
        batch_size, channels, height, width = conv_out.size()
        
        # 展平
        conv_out = conv_out.view(batch_size, channels * height, width)  # (B, 512*(H/16), W/16)
        
        # 全连接层
        conv_out = conv_out.permute(0, 2, 1)  # (B, W/16, 512*(H/16))
        fc_out = self.fc(conv_out)  # (B, W/16, input_size)
        
        # 循环层
        out, _ = self.lstm(fc_out)  # (B, W/16, hidden_size)
        
        # 取最后一个时间步的输出
        out = out[:, -1, :]  # (B, hidden_size)
        
        # 输出层
        out = self.fc_out(out)  # (B, num_classes)
        
        return out

# 数据预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 初始化模型、损失函数和优化器
model = CRNN(num_classes=2, input_size=1024, hidden_size=512, num_layers=2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    for i, (images, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')
    
    # 验证模型
    model.eval()
    with torch.no_grad():
        correct = 0
        total = 0
        for images, labels in test_loader:
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        print(f'Epoch [{epoch+1}/{num_epochs}], Accuracy: {100 * correct / total:.2f}%')

# 保存模型
torch.save(model.state_dict(), 'crnn_model.pth')

代码说明

CRNN模型定义：
- 卷积层：使用四个卷积层，每个卷积层后跟着一个ReLU激活函数和一个最大池化层。
- 全连接层：将卷积层的输出展平后通过一个全连接层。
- 循环层：使用LSTM层处理时间序列数据。
- 输出层：将LSTM的输出通过一个全连接层得到最终的分类结果。
数据预处理：
- 使用transforms对图像进行标准化和resize操作。
数据加载：
- 使用datasets.CIFAR10加载CIFAR-10数据集，并创建数据加载器。
训练和验证：
- 在每个epoch中，先对模型进行训练，然后在测试集上进行验证，计算分类准确率。
保存模型：
- 训练完成后，保存模型的参数到文件。

希望这个示例对你有帮助！如果有任何问题，欢迎随时提问。

4、deepseek-r1:

以下是一个使用CRNN（卷积递归神经网络）进行图像分类的完整代码示例，包括详细的注释和可运行的demo。代码使用PyTorch框架实现。

1. 环境要求

Python 3.x
PyTorch 1.x
torchvision
matplotlib（可选，用于可视化）

2. 代码实现

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, datasets
import numpy as np
import matplotlib.pyplot as plt

# 定义CRNN模型
class CRNN(nn.Module):
    def __init__(self, num_classes):
        super(CRNN, self).__init__()
        
        # CNN部分
        self.cnn = nn.Sequential(
            # 第一层卷积
            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1),
            # 输出维度：(32, 224, 224)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
            # 输出维度：(32, 112, 112)
            
            # 第二层卷积
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1),
            # 输出维度：(64, 112, 112)
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
            # 输出维度：(64, 56, 56)
        )
        
        # RNN部分
        self.rnn = nn.Sequential(
            # LSTM层
            nn.LSTM(input_size=64*56, hidden_size=128, num_layers=2, batch_first=True)
        )
        
        # 分类器
        self.fc = nn.Linear(128, num_classes)
    
    def forward(self, x):
        # CNN特征提取
        x = self.cnn(x)  # 输出维度：(batch_size, 64, 56, 56)
        
        # 将CNN输出展平并调整维度以适应RNN
        batch_size = x.size(0)
        x = x.view(batch_size, -1, 64*56)  # 输出维度：(batch_size, 56, 64*56)
        
        # RNN处理
        x, _ = self.rnn(x)  # 输出维度：(batch_size, 56, 128)
        
        # 取最后一个时间步的输出
        x = x[:, -1, :]  # 输出维度：(batch_size, 128)
        
        # 分类
        x = self.fc(x)  # 输出维度：(batch_size, num_classes)
        return x

# 定义数据预处理
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# 自定义数据集（假设数据分为good和bad两类）
class ImageDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.images = []
        self.labels = []
        
        # 加载good图像
        good_dir = f"{root_dir}/good"
        for img_name in os.listdir(good_dir):
            if img_name.endswith('.jpg'):
                self.images.append(f"{good_dir}/{img_name}")
                self.labels.append(0)  # good为0
        
        # 加载bad图像
        bad_dir = f"{root_dir}/bad"
        for img_name in os.listdir(bad_dir):
            if img_name.endswith('.jpg'):
                self.images.append(f"{bad_dir}/{img_name}")
                self.labels.append(1)  # bad为1
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        img_path = self.images[idx]
        label = self.labels[idx]
        image = Image.open(img_path).convert('RGB')
        if self.transform:
            image = self.transform(image)
        return image, label

# 数据加载
train_dataset = ImageDataset(root_dir="path_to_train_data", transform=transform)
val_dataset = ImageDataset(root_dir="path_to_val_data", transform=transform)
test_dataset = ImageDataset(root_dir="path_to_test_data", transform=transform)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False, num_workers=4)

# 初始化模型
model = CRNN(num_classes=2)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环
num_epochs = 10

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for images, labels in train_loader:
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    
    # 打印训练损失
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader)}")
    
    # 验证
    model.eval()
    val_loss = 0.0
    val_correct = 0
    with torch.no_grad():
        for images, labels in val_loader:
            outputs = model(images)
            loss = criterion(outputs, labels)
            val_loss += loss.item()
            
            _, predicted = torch.max(outputs.data, 1)
            val_correct += (predicted == labels).sum().item()
    
    val_accuracy = val_correct / len(val_dataset)
    print(f"Validation Loss: {val_loss/len(val_loader)}, Accuracy: {val_accuracy}")

# 测试
model.eval()
test_correct = 0
with torch.no_grad():
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        test_correct += (predicted == labels).sum().item()

test_accuracy = test_correct / len(test_dataset)
print(f"Test Accuracy: {test_accuracy}")

# 可视化示例
def visualize_example():
    # 加载测试图像
    test_images, test_labels = next(iter(test_loader))
    outputs = model(test_images)
    _, predicted = torch.max(outputs.data, 1)
    
    plt.figure(figsize=(16, 8))
    for i in range(4):
        plt.subplot(2, 4, i+1)
        img = test_images[i].numpy().transpose(1, 2, 0)
        img = (img * [0.229, 0.224, 0.225]) + [0.485, 0.456, 0.406]
        plt.imshow(img)
        plt.title(f"Predicted: {predicted[i].item()}, Actual: {test_labels[i].item()}")
        plt.axis('off')
    plt.show()

visualize_example()

3. 代码说明

1. 模型结构

CNN部分：用于提取图像特征，包含两个卷积层和两个最大池化层。
RNN部分：使用LSTM处理序列特征，提取时序信息。
分类器：全连接层用于最终分类。

2. 数据预处理

图像resize到224x224
转换为Tensor
标准化处理

3. 数据集

自定义数据集类ImageDataset，支持自定义数据路径。
数据分为good和bad两类，分别对应标签0和1。

4. 训练与验证

使用交叉熵损失函数CrossEntropyLoss
优化器选择Adam
每个epoch进行训练和验证，打印损失和准确率。

5. 测试与可视化

在测试集上评估模型性能。
随机选择4张测试图像进行可视化，显示预测结果与真实标签。

4. 使用说明

替换path_to_train_data、path_to_val_data和path_to_test_data为实际数据路径。

确保数据目录结构如下：

train_data/
    good/
        img1.jpg
        img2.jpg
        ...
    bad/
        imgA.jpg
        imgB.jpg
        ...
val_data/
    good/
        ...
    bad/
        ...
test_data/
    good/
        ...
    bad/
        ...

运行代码，训练模型并查看结果。

5. 依赖安装

pip install torch torchvision matplotlib

希望这段代码对您有所帮助！如果需要进一步调整或优化，可以根据具体需求修改网络结构、优化器参数或数据预处理步骤。

查看全文

http://www.kler.cn/a/553192.html

jenkins+docker自动发版java后端完整流程

draggable+el-tag 拖动元素有div宽度抖动问题

pycharm画图程序如何一步一步的调试

技术分享：MyBatis SQL 日志解析脚本

Discuz! X3.5 根目录权限设置

软件开源与AI开源的区别

Shapr3D在ipad上无法识别鼠标点击问题

机器翻译中的编码器、自注意和解码器

6.编写正排索引切分字符串|倒排索引原理|引入jieba到项目(C++)

树（数据结构·）

原生稀疏注意力机制(NSA)：硬件对齐且可原生训练的稀疏注意力机制-论文阅读

美股分钟级高频数据在量化研究中的时间序列分析

deepin 下安装nvm（npm+node）

感想-人工智能：AI 的优缺点 / AI是一把好的锄头，但它永远不能自己去种地

Word接入DeepSeek（API的作用）

使用 Certbot 自动获取和更新 Let‘s Encrypt SSL 证书

数据湖与数据仓库：初学者的指南

MongoDB：listDatabases failed : not master and slaveOk=false

理解计算机系统_虚拟内存(二)缓存

【核心算法篇十六】《DeepSeek强化学习：MuZero算法核心解析》

prompt

1、GPT-4o

1. 安装依赖

2. 代码实现

3. 代码说明

4. 运行结果

2、豆包-1.5pro

1. 引入必要的库

2. 定义CRNN模型

3. 定义训练过程

4. 定义预测过程

5. 运行预测

代码说明

3、Qwen-2.5

代码说明

4、deepseek-r1:

1. 环境要求

2. 代码实现

3. 代码说明

1. 模型结构

2. 数据预处理

3. 数据集

4. 训练与验证

5. 测试与可视化

4. 使用说明

5. 依赖安装

相关文章：