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

网站服务器中如何做重定向湖南省专业建设公司网站

news 2025/9/29 22:34:46

网站服务器中如何做重定向,湖南省专业建设公司网站,照片网站源码,wordpress 插件系统prompt 使用 crnn 提取图像特征，给出图像好坏的二分类结果，写清楚代码备注，注释清楚向量维度大小，并给出一个可运行的 demo1、GPT-4o 以下是一个使用 CRNN（Convolutional Recurrent Neural Network）提取图…

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_samplesself.img_size = img_sizeself.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_samplesdef __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 * 2def 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 = 0for 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，填充1self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)self.relu1 = nn.ReLU()# 最大池化层1，窗口大小2x2，步长2self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)# 卷积层2，输入通道数16，输出通道数32，卷积核大小3x3，步长1，填充1self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)self.relu2 = nn.ReLU()# 最大池化层2，窗口大小2x2，步长2self.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.0correct = 0total = 0for i, data in enumerate(train_loader, 0):inputs, labels = dataoptimizer.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 = dataoutputs = 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_classesself.hidden_size = hidden_sizeself.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 = 0total = 0for 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输出展平并调整维度以适应RNNbatch_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_dirself.transform = transformself.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为1def __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 = 10for epoch in range(num_epochs):model.train()running_loss = 0.0for 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.0val_correct = 0with 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.jpgimg2.jpg...bad/imgA.jpgimgB.jpg...
val_data/good/...bad/...
test_data/good/...bad/...

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

5. 依赖安装

pip install torch torchvision matplotlib

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

查看全文

http://www.yayakq.cn/news/235785/

衣服网站建设方案设计公司logo免费设计生成器

快递网站怎么制作潍坊专业技术继续教育平台

jsp做网站案例猎聘招聘官方网站

平安车险官方保险网站为企业做网站建设优化小程序包年竞价

俄语网站推广通哪个网站的ppt模板最好

做网站设计制作的公司wordpress房产主题汉化版

网站规划与建设ppt模板下载wordpress主题幻灯

上海公共招聘网官方网站断桥铝门窗制作需要哪些工具

建个什么网站赚钱手机端网站开发源码

怎么降低网站的跳出率郑州做网站服务器

租车公司网站模板网站排名第一

百度站点提交工具idc网站是用什么语言做的

怎么更换网站logo国内主要的o2o电商平台

电子产品网站建设策划书已注册的网站如何注销

专业网站设计公司推荐wordpress 商品分类

网站 f型长春网络公司营销模式

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. 依赖安装

相关文章：