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

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. 代码说明

  1. 数据集:

    • 使用了一个简单的自定义数据集 SimpleImageDataset，生成随机图像和二分类标签。
    • 图像大小为 (32, 32)，标签为 0 或 1。

  2. CRNN 模型:

    • 卷积层提取图像的空间特征。
    • RNN 层（LSTM）处理序列特征，输入为卷积层输出的特征序列。
    • 全连接层将 RNN 的输出映射到二分类结果。

  3. 训练:

    • 使用交叉熵损失函数 CrossEntropyLoss。
    • 优化器为 Adam。

  4. 测试:

    • 从数据集中取一个样本，使用训练好的模型进行预测，并可视化结果。

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}')

代码说明

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

代码说明

  1. CRNN模型定义：

    • 卷积层：使用四个卷积层，每个卷积层后跟着一个ReLU激活函数和一个最大池化层。
    • 全连接层：将卷积层的输出展平后通过一个全连接层。
    • 循环层：使用LSTM层处理时间序列数据。
    • 输出层：将LSTM的输出通过一个全连接层得到最终的分类结果。

  2. 数据预处理：

    • 使用transforms对图像进行标准化和resize操作。

  3. 数据加载：

    • 使用datasets.CIFAR10加载CIFAR-10数据集，并创建数据加载器。

  4. 训练和验证：

    • 在每个epoch中，先对模型进行训练，然后在测试集上进行验证，计算分类准确率。

  5. 保存模型：

    • 训练完成后，保存模型的参数到文件。

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

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. 使用说明

  1. 替换path_to_train_data、path_to_val_data和path_to_test_data为实际数据路径。
  2. 确保数据目录结构如下：
    train_data/good/img1.jpgimg2.jpg...bad/imgA.jpgimgB.jpg...
val_data/good/...bad/...
test_data/good/...bad/...
  3. 运行代码，训练模型并查看结果。

5. 依赖安装

pip install torch torchvision matplotlib

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/70341.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

DeepBI助力跨境电商打破流量垄断：AI驱动的亚马逊广告投放新打法

DeepBI助力跨境电商打破流量垄断：AI驱动的亚马逊广告投放新打法

#亚马逊广告优化# 亲爱的亚马逊跨境电商卖家们，是否曾因亚马逊的广告打法不清晰，或是纠结于亚马逊广告费用过高，或是为亚马逊电商广告怎么投放合适的问题而苦恼？在竞争激烈的亚马逊市场中，广告投放效果平平&#xff0…
阅读更多...
前端基础入门：HTML、CSS 和 JavaScript

前端基础入门：HTML、CSS 和 JavaScript

在现代网页开发中，前端技术扮演着至关重要的角色。无论是个人网站、企业官网，还是复杂的 Web 应用程序，前端开发的基础技术 HTML、CSS 和 JavaScript 都是每个开发者必须掌握的核心技能。本文将详细介绍这三者的基本概念及其应用 一、HTML——网页的骨架 HTML（HyperText …
阅读更多...
单元测试junit5

单元测试junit5

一、idea 安装自动化生成插件jcode5 安装可能不成功&#xff0c;尝试多次安装&#xff1b; 安装成功后&#xff0c;重启idea&#xff0c;再次确认安装是否成功&#xff1b; 二、在需要生成单元测试代码的模块的pom中引入依赖 ......<parent><groupId>org.springf…
阅读更多...
windows系统本地部署DeepSeek-R1全流程指南：Ollama+Docker+OpenWebUI

windows系统本地部署DeepSeek-R1全流程指南：Ollama+Docker+OpenWebUI

本文将手把手教您使用OllamaDockerOpenWebUI三件套在本地部署DeepSeek-R1大语言模型&#xff0c;实现私有化AI服务搭建。 一、环境准备 1.1 硬件要求 CPU&#xff1a;推荐Intel i7及以上&#xff08;需支持AVX2指令集&#xff09; 内存&#xff1a;最低16GB&#xff0c;推荐…
阅读更多...
Windows Server 任务计划

Windows Server 任务计划

背景&#xff1a;QMT服务只能在windows服务器上面运行 直接在控制面板里面搜索"任务计划"点进去 需要注意的是&#xff1a; 1.创建任务计划选择”不管用户是否登录都运行“&#xff0c;是否需要最高权限执行看你的需求 2.操作程序或脚本&#xff0c;选择bat脚本就…
阅读更多...
makefile+LSF

makefile+LSF

LSF LSF&#xff08;Load Sharing Facility&#xff09;是一种常用的集群作业调度系统&#xff0c;bsub 命令用于提交作业到 LSF 集群&#xff0c;而若要关闭&#xff08;终止&#xff09;一个正在运行的作业&#xff0c;需要使用 bkill 命令&#xff0c;下面为你详细介绍相关…
阅读更多...
spring boot知识点3

spring boot知识点3

1.spring boot能否使用xml配置 可以&#xff0c;但是很繁琐&#xff0c;现在都建议走JavaConfig 2.spring boot的核心配置文件 application.properties application.yml 3.bootstrap.properties和application.properties的区别 b&#xff1a;用于远程配置 a&#xff1a;…
阅读更多...
人工智能学习环境配置

人工智能学习环境配置

文章目录 Python、CUDA、cuDNN、PyTorch 和 Anaconda 的介绍PythonCUDAcuDNNPyTorchAnaconda联系 安装n卡驱动更新安装 AnacondaAnaconda配置镜像源CUDA安装Cudnn安装Anaconda初始化创建虚拟环境安装 PyTorch验证安装 可能的错误SSL错误 Python、CUDA、cuDNN、PyTorch 和 Anaco…
阅读更多...
【C语言】C语言 食堂自动化管理系统（源码+数据文件）【独一无二】

【C语言】C语言 食堂自动化管理系统（源码+数据文件）【独一无二】

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;专__注&#x1f448;&#xff1a;专注主流机器人、人工智能等相关领域的开发、测试技术。 【C语言】C语言 食堂自动化管理系统&#xff08;源…
阅读更多...
DeepSeek是什么？两种模型的对比？

DeepSeek是什么？两种模型的对比？

最近DeepSeek的风也是很大&#xff0c;它也是很火&#xff0c;那么DeepSeek是什么呢&#xff1f; 什么是DeepSeek&#xff1f; DeepSeek是一家专注通用人工智能&#xff08;AGI&#xff09;的中国科技公司&#xff0c;主攻大模型研发与应用。DeepSeek-R1是其开源的推理模型&a…
阅读更多...
【架构】分层架构 (Layered Architecture)

【架构】分层架构 (Layered Architecture)

一、分层模型基础理论 ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/0365cf0bfa754229bdedca6b472bffc7.png 1. 核心定义 分层架构（Layered Architecture）模型是一种常见的软件设计架构，它将软件系统按照功能划分为不同的层次，每个层次都有特定的职责和功能…
阅读更多...
基于MATLAB的均匀面阵MUSIC算法DOA估计仿真

基于MATLAB的均匀面阵MUSIC算法DOA估计仿真

基于MATLAB的均匀面阵MUSIC算法DOA估计仿真 文章目录 前言一、二维MUSIC算法原理二、二维MUSIC算法MATLAB仿真三、MATLAB源代码总结 前言 \;\;\;\;\; 在波达角估计算法中&#xff0c;MUSIC 算法与ESPRIT算法属于特征结构子空间算法&#xff0c;是波达角估计算法中的基石。在前面…
阅读更多...
组学数据分析实操系列 |（四） 富集气泡图的绘制

组学数据分析实操系列 |（四） 富集气泡图的绘制

前言:在上一篇中&#xff0c;我们介绍了利用Metascape零代码实现富集分析&#xff0c;但是Metascape的富集分析结果是以柱状图的形式展示的。文章中更常使用的富集结果可视化方式是气泡图。气泡图可以通过气泡的坐标、形状、颜色、大小等来展示更加丰富的富集分析结果&#xff…
阅读更多...
实现一个专注应用-后端开发(一)-搭建

实现一个专注应用-后端开发(一)-搭建

搭建后端服务 搭建服务拆分下用户服务 增加公共库通用模块 运行一下接入数据库安装Prisma增加prisma库 redis增加redis服务 搭建服务 使用nestjs来做 这里是nestjs的网站Nestjs 安装 nest npm i -g nestjs/cli创建一个项目 并在开发工具打开 nest new todonest new xx 是新…
阅读更多...
C++17并行化加速STL算法——std::execution

C++17并行化加速STL算法——std::execution

C17 并行化STL算法 文章目录 C17 并行化STL算法概念环境准备工具类 并行算法 - 使用并行算法 - 执行策略总览选择标准详细介绍顺序执行 seq并行化顺序执行 par并行化乱序执行 par_unseq 并行算法 - 异常处理可以不使用并行算法并行算法 - 限制并行算法有哪些原有算法17引入新算…
阅读更多...
Deepseek 怼CHATGPT实况

Deepseek 怼CHATGPT实况

提示词&#xff1a; 用犀利的语言批评ChatGPT 深度思考&#xff08;R1) 嗯&#xff0c;用户让我用犀利的语言批评ChatGPT。首先&#xff0c;我需要理解他们的动机。可能他们遇到了ChatGPT的某些问题&#xff0c;比如回答不准确或者缺乏深度&#xff0c;所以想表达不满。也有…
阅读更多...
always和assign语法区别

always和assign语法区别

always语句可以带时钟， 也可以不带时钟。 一，assign和always区别 assign 语句使用时不能带时钟。 assign a=1; assign b=2; 在always不带时钟时，逻辑功能和assign完全一致，都是只产生组合逻辑。比较简单的组合逻辑推荐使用assign语句，比较复杂的组合逻辑推荐使用 al…
阅读更多...
解析跨域：原理、解决方案与实践指南

解析跨域：原理、解决方案与实践指南

解析跨域&#xff1a;原理、解决方案与实践指南 &#x1f310; 在现代Web开发中&#xff0c;跨域问题是一个常见且重要的挑战。随着互联网应用的日益复杂&#xff0c;前端与后端之间的交互越来越频繁&#xff0c;跨域请求的需求也随之增加。 一、跨域问题的本质与产生条件 &a…
阅读更多...
鸿蒙开发：熟知@BuilderParam装饰器

鸿蒙开发：熟知@BuilderParam装饰器

前言 本文代码案例基于Api13。 在实际的开发中&#xff0c;我们经常会遇到自定义组件的情况&#xff0c;比如通用的列表组件&#xff0c;选项卡组件等等&#xff0c;由于使用方的样式不一&#xff0c;子组件是动态变化的&#xff0c;针对这一情况&#xff0c;就不得不让使用方把…
阅读更多...
MSI微星电脑冲锋坦克Pro Vector GP76 12UGS(MS-17K4)原厂Win11系统恢复镜像，含还原功能，预装OEM系统下载

MSI微星电脑冲锋坦克Pro Vector GP76 12UGS(MS-17K4)原厂Win11系统恢复镜像，含还原功能，预装OEM系统下载

适用机型&#xff1a;【MS-17K4】 链接&#xff1a;https://pan.baidu.com/s/1P8ZgXc6S_J9DI8RToRd0dQ?pwdqrf1 提取码&#xff1a;qrf1 微星笔记本原装出厂WINDOWS11系统自带所有驱动、出厂主题壁纸、系统属性专属联机支持标志、Office办公软件、MSI Center控制中心等预装…
阅读更多...
最新文章

Copyright @ 2022~2023