PyTorch图像识别模型和图像分割模型体验

文章目录

  • 仓库地址
  • 练习：图像自动识别模型
    • 数据集说明
    • 模型训练和保存
      • 导入数据集
      • 搭建神经网络
      • 训练和保存实现
    • 模型测试
      • 测试代码
      • 测试结果
  • 练习：图像自动分割模型
    • 模型训练和保存
      • 加载数据集
      • 搭建神经网络
      • 训练和保存
    • 模型测试
      • 测试代码
      • 测试效果

仓库地址

  • 图像识别(image_classification_and_recognition)
  • 图像分割(image_segmentation)

练习：图像自动识别模型

  • 图像识别是指利用计算机对图像进行处理、分析和理解，以识别各种不同模式的目标和对象的技术，是深度学习算法的一种实践应用

数据集说明

  • 使用MNIST数据集，MNIST数据集来自美国国家标准与技术研究所（National Institute of Standards and Technology，NIST）。该数据集分成训练集（Training Set）和测试集（Test Set）两个部分，其中训练集由来自250个不同人手写的数字构成，其中50%是高中学生，50%来自人口普查局（theCensusBureau）的工作人员，测试集也是同样比例的手写数字数据。

模型训练和保存

导入数据集

# 定义MNIST数据集的训练数据
import torch
import torchvision
from torch import nn
import torch.utils.data as data
from tqdm import tqdmtrain_dataset = torchvision.datasets.MNIST(root='./data',train=True,transform=torchvision.transforms.ToTensor(),download=True
)test_dataset = torchvision.datasets.MNIST(root='./data',train=False,transform=torchvision.transforms.ToTensor(),download=True
)

搭建神经网络

# 搭建神经网络
class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()# 定义第一层卷积层和相关操作self.conv1 = nn.Sequential(nn.Conv2d(  # 二维卷积层in_channels=1,  # 输入通道数为1out_channels=16,  # 输出通道数为16kernel_size=3,  # 卷积核大小为×3stride=1,  # 卷积核移动步长为1padding=1  # 边界填充为1),nn.ReLU(),  # 激活函数为ReLUnn.MaxPool2d(kernel_size=2)  # 最大池化层，池化核大小为2)# 定义第二层卷积层和相关操作self.conv2 = nn.Sequential(nn.Conv2d(in_channels=16,out_channels=32,kernel_size=3,stride=1,padding=1),nn.ReLU(),nn.MaxPool2d(kernel_size=2))# 定义全连接层# 输入维度为32*7*7，输出维度为10self.output = nn.Linear(32 * 7 * 7, 10)def forward(self, x):out = self.conv1(x)  # 第一层卷积和池化操作out = self.conv2(out)  # 第二层卷积和池化操作out = out.view(out.size(0), -1)  # 将数据输出为一维向量out = self.output(out)return out

训练和保存实现

if __name__ == '__main__':# 设置设备device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 训练和保存模型# 定义超参数LR = 0.001EPOCHS = 3BATCH_SIZE = 50# 创建模型实例cnn = CNN().to(device)  # 移动模型到GPU# 定义Adam优化器h和交叉熵损失函数loss_funcoptimizer = torch.optim.Adam(cnn.parameters(), lr=LR)loss_func = nn.CrossEntropyLoss()# 定义数据集加载器train_loader = data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)test_data = torchvision.datasets.MNIST(root='./data', train=False)# 导入测试训练集test_x = torch.unsqueeze(test_dataset.data, dim=1).type(torch.float32) / 255test_y = test_dataset.targetstest_x, test_y = test_x.to(device), test_y.to(device)  # 移动测试数据到GPUfor epoch in range(EPOCHS):progress_bar = tqdm(enumerate(train_loader), total=len(train_loader))for step, (x, y) in progress_bar:x, y = x.to(device), y.to(device)  # 移动数据到GPUoutput = cnn(x)loss = loss_func(output, y)optimizer.zero_grad()loss.backward()optimizer.step()if step % 50 == 0:# 在测试集上进行前向传播test_output = cnn(test_x)# 获取预测的类别和索引"""test_output：这是模型对测试数据的原始输出，通常是一个二维张量（Tensor），其中每一行对应一个样本，每一列对应每个类别的得分或概率torch.max(test_output, 1)：这个操作会在指定的维度（这里是1，即行维度）上找到最大值。对于分类任务来说，这通常意味着找到具有最高得分或概率的类别返回值是一个元组，包含两个张量：第一个是最大值本身，第二个是这些最大值的索引[1]：从torch.max返回的元组中选取第二个元素，即最大值的索引。这些索引代表了模型对每个测试样本预测的类别.cpu 将预测结果移回CPU以便后续处理.numpy()：将PyTorch Tensor转换为NumPy数组，以便进行后续的处理或者评估，如计算准确率或者其他性能指标  """pred_y = torch.max(test_output, 1)[1].cpu().numpy()#  计算准确度"""pred_y == test_y.cpu().numpy()：将模型预测结果pred_y与真实标签test_y进行比较，返回一个布尔数组，其中值为True表示预测正确，False表示预测错误.astype(int)：将布尔数组转换为整数数组，True变为1，False变为0.sum()：对数组中的所有元素求和，得到预测正确的样本数量float(test_y.size(0))：测试集中总样本的数量"""accuracy = float((pred_y == test_y.cpu().numpy()).astype(int).sum()) / float(test_y.size(0))# 更新进度条描述 打印当前训练轮次（epoch）的训练损失（loss）和测试准确率（accuracy）progress_bar.set_description(f"Epoch {epoch} | Step {step} | Loss: {loss.item():.4f} | test accuracy: {accuracy}:.2f")"""1. torch.save(cnn, 'image_recognition.pkl')保存的是整个模型对象（包括模型结构和参数）。可以直接保存整个 CNN 模型实例 cnn。优点：加载时可以直接恢复完整的模型，不需要重新定义网络结构。缺点：保存的文件体积较大，且对模型结构耦合度高，如果模型结构发生变化，加载会出错。加载方式：model = torch.load('image_recognition.pkl')2. torch.save(cnn.state_dict(), 'image_recognition.pth')只保存模型的参数（权重和偏置等），不保存模型结构。更加轻量、灵活，推荐在实际项目中使用。使用前提：需要先定义好相同的模型结构，然后通过 load_state_dict() 加载参数。    加载方式：model = CNN() # 先创建模型结构model.load_state_dict(torch.load('image_recognition.pth'))  # 再加载参数通常建议使用第二种方式 state_dict() 来保存模型参数"""torch.save(cnn, './data/image_recognition.pkl')torch.save(cnn.state_dict(), './data/image_recognition.pth')

模型测试

测试代码

  • image_segmentation_test.py
# 定义MNIST数据集的训练数据
import torch
import torchvision
from torch import nn
import torch.utils.data as data# 搭建神经网络
class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()# 定义第一层卷积层和相关操作self.conv1 = nn.Sequential(nn.Conv2d(  # 二维卷积层in_channels=1,  # 输入通道数为1out_channels=16,  # 输出通道数为16kernel_size=3,  # 卷积核大小为×3stride=1,  # 卷积核移动步长为1padding=1  # 边界填充为1),nn.ReLU(),  # 激活函数为ReLUnn.MaxPool2d(kernel_size=2)  # 最大池化层，池化核大小为2)# 定义第二层卷积层和相关操作self.conv2 = nn.Sequential(nn.Conv2d(in_channels=16,out_channels=32,kernel_size=3,stride=1,padding=1),nn.ReLU(),nn.MaxPool2d(kernel_size=2))# 定义全连接层# 输入维度为32*7*7，输出维度为10self.output = nn.Linear(32 * 7 * 7, 10)def forward(self, x):out = self.conv1(x)  # 第一层卷积和池化操作out = self.conv2(out)  # 第二层卷积和池化操作out = out.view(out.size(0), -1)  # 将数据输出为一维向量out = self.output(out)return outif __name__ == '__main__':# 设置设备device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 导入测试数据集test_dataset = torchvision.datasets.MNIST(root='./data',train=False,transform=torchvision.transforms.ToTensor(),download=True)# 导入测试训练集test_x = torch.unsqueeze(test_dataset.data, dim=1).type(torch.float32) / 255test_y = test_dataset.targetstest_x, test_y = test_x.to(device), test_y.to(device)  # 移动测试数据到GPU# 2 对测试数据进行预测，并输出准确率# 加载已保存的模型cnn_test = CNN().to(device)cnn_test.load_state_dict(torch.load("./data/image_recognition.pth"))# 对整个测试集上的数据进行预测test_output1 = cnn_test(test_x)# 获取预测的类别和索引pred_y1 = torch.max(test_output1, 1)[1].cpu().numpy()# 计算准确率accuracy = float((pred_y1 == test_y.cpu().numpy()).astype(int).sum()) / float(test_y.size(0))print('准确率', accuracy)  # 准确率 0.9849

测试结果

  • 准确率 0.9849

练习：图像自动分割模型

  • 图像分割就是指把图像分成若干特定的、具有独特性质的区域并提出感兴趣的目标的技术和过程。为了更好地理解和应用图像自动分割技术。

模型训练和保存

加载数据集

import os
import torch
import cv2
import numpy as np
from torch import nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transformsclass MyDataset(Dataset):def __init__(self, train_path, transform=None):"""初始化方法:param train_path: 训练数据的路径:param transform:  数据预处理函数"""# 列出last目录下的所有图像文件self.images = os.listdir(train_path + '/last')# 列出last_msk目录下的所有标签文件self.labels = os.listdir(train_path + '/last_msk')# 断言图像和标签数量相等assert len(self.images) == len(self.labels), '图像数量与标签数量不匹配'self.transform = transform# 创建一个列表，存储图像和标签的路径self.images_and_labels = []for i in range(len(self.images)):# 将图像和标签的路径添加到列表中self.images_and_labels.append((train_path + '/last/' + self.images[i], train_path + '/last_msk/' + self.labels[i]))def __getitem__(self, item):# 获取图像和标签的路径image_path, label_path = self.images_and_labels[item]# 读取图像和标签# 使用opencv读取图像image = cv2.imread(image_path)# 调整图像大小image = cv2.resize(image, (224, 224))# 使用opencv读取标签label = cv2.imread(label_path, 0)# 调整标签大小label = cv2.resize(label, (224, 224))# 归一化标签值范围到[0,1]范围label = label / 255# 将标签转化为无符号8位整数范围label = label.astype('uint8')# 将标签转化为独热编码label = np.eye(2)[label]# 对独热编码进行处理# 将标签中的0和1进行取反label = np.array(list(map(lambda x: abs(x - 1), label))).astype('float32')# 将标签的维度进行交换label = label.transpose(2, 0, 1)# 如果有数据预处理函数，则对图像进行预处理if self.transform is not None:image = self.transform(image)return image, labeldef __len__(self):# 返回数据集的长度return len(self.images)

搭建神经网络

# 搭建网络模型
"""
输入图像大小为3×224×224 卷积部分使用的是VGG11模型 经过第5个最大池化后开始上采样 经过5个反卷积层还原成图像大小
"""
class Net(nn.Module):def __init__(self):super(Net, self).__init__()# 定义第一层编码块 由卷积层、批归一化层和激活函数组成self.encoder_one = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(64),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_two = nn.Sequential(nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(128),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_three = nn.Sequential(nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True),nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_four = nn.Sequential(nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_five = nn.Sequential(nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))# 定义第一层解码块 由反卷积层、批归一化层和激活函数组成self.decoder_one = nn.Sequential(nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True))self.decoder_two = nn.Sequential(nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(128),nn.ReLU(inplace=True))self.decoder_three = nn.Sequential(nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(64),nn.ReLU(inplace=True))self.decoder_four = nn.Sequential(nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(32),nn.ReLU(inplace=True))self.decoder_five = nn.Sequential(nn.ConvTranspose2d(in_channels=32, out_channels=16, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(16),nn.ReLU(inplace=True))# 定义分类器，用于生成最终的输出self.classifier = nn.Conv2d(in_channels=16, out_channels=2, kernel_size=1)def forward(self, x):# 对输入数据进行编码块处理out = self.encoder_one(x)out = self.encoder_two(out)out = self.encoder_three(out)out = self.encoder_four(out)out = self.encoder_five(out)# 对编码后的数据进行解码块处理out = self.decoder_one(out)out = self.decoder_two(out)out = self.decoder_three(out)out = self.decoder_four(out)out = self.decoder_five(out)# 通过分类器生成最终的输出out = self.classifier(out)return out

训练和保存

if __name__ == '__main__':"""# 加载数据集测试image=cv2.imread('./data/train/last_msk/50.jpg',0)image=cv2.resize(image,(16,16))image_2=image/255image_3=image_2.astype('uint8')hot_1=np.eye(2)[image_3]hot_2=np.array(list(map(lambda x:abs(x-1),hot_1)))print(hot_2.shape) # (16, 16, 2)""""""# 网络模型测试# 生成一个随机图像张量img=torch.randn(2,3,224,224)net=Net() # 创建一个网络模型sample=net(img) # 输入图像张量进行前向传播print(sample.shape) # 打印输出的形状 torch.Size([2, 2, 224, 224])"""# 训练模型并保存batch_size = 8  # 设置批量大小epochs = 2000  # 设置训练轮数train_data_path = './data/train'  # 设置训练数据路径# 定义数据预处理操作transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])# 创建自定义数据集 数据加载器bag = MyDataset(train_data_path, transform)data_loader = DataLoader(bag, batch_size=batch_size, shuffle=True)# 定义计算设备 创建网络模型device = torch.device("cuda" if torch.cuda.is_available() else "cpu")net = Net().to(device)# 定义损失函数和优化器loss_func = nn.BCELoss()optimizer = optim.SGD(net.parameters(), lr=1e-2, momentum=0.7)# 创建目录if not os.path.exists('./model'):os.mkdir('./model')for epoch in range(1, epochs + 1):for i, (img, label) in enumerate(data_loader):img, label = img.to(device), label.to(device)output = torch.sigmoid(net(img))loss = loss_func(output, label)# 将输出转换为numpy数组并取最小值# output_np=output.detach().cpu().numpy()# output_np=np.argmin(output_np,axis=1)# 将标签转换为numpy数组并取最小值# label_np=label.detach().cpu().numpy()# label_np=np.argmin(label_np,axis=1)# 每20个批次打印一次损失if i % 20 == 0:print('Epoch:[{}/{}]\t Step:[{}/{}]\t Loss:{:.6f}'.format(epoch, epochs, (i + 1) * len(img), len(data_loader.dataset), loss.item()))optimizer.zero_grad()loss.backward()optimizer.step()# 每个200个轮次保存一次模型参数if epoch % 200 == 0:torch.save(net.state_dict(), './model/model_epoch_{}.pth'.format(epoch))print('./model/model_epoch_{}.pth saved!'.format(epoch))

模型测试

测试代码

  • image_recognition_test.py
import os
import torch
import cv2
import numpy as np
from torch import nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transformsclass Net(nn.Module):def __init__(self):super(Net, self).__init__()# 定义第一层编码块 由卷积层、批归一化层和激活函数组成self.encoder_one = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(64),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_two = nn.Sequential(nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(128),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_three = nn.Sequential(nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True),nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_four = nn.Sequential(nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))self.encoder_five = nn.Sequential(nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(512),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=2, stride=2))# 定义第一层解码块 由反卷积层、批归一化层和激活函数组成self.decoder_one = nn.Sequential(nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(256),nn.ReLU(inplace=True))self.decoder_two = nn.Sequential(nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(128),nn.ReLU(inplace=True))self.decoder_three = nn.Sequential(nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(64),nn.ReLU(inplace=True))self.decoder_four = nn.Sequential(nn.ConvTranspose2d(in_channels=64, out_channels=32, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(32),nn.ReLU(inplace=True))self.decoder_five = nn.Sequential(nn.ConvTranspose2d(in_channels=32, out_channels=16, kernel_size=3, stride=2, padding=1, output_padding=1),nn.BatchNorm2d(16),nn.ReLU(inplace=True))# 定义分类器，用于生成最终的输出self.classifier = nn.Conv2d(in_channels=16, out_channels=2, kernel_size=1)def forward(self, x):# 对输入数据进行编码块处理out = self.encoder_one(x)out = self.encoder_two(out)out = self.encoder_three(out)out = self.encoder_four(out)out = self.encoder_five(out)# 对编码后的数据进行解码块处理out = self.decoder_one(out)out = self.decoder_two(out)out = self.decoder_three(out)out = self.decoder_four(out)out = self.decoder_five(out)# 通过分类器生成最终的输出out = self.classifier(out)return outclass TestDataset(Dataset):def __init__(self, test_img_path, transform=None):self.test_img = os.listdir(test_img_path)self.transform = transformself.images = []for i in range(len(self.test_img)):self.images.append(os.path.join(test_img_path, self.test_img[i]))def __getitem__(self, index):img_path = self.images[index]img = cv2.imread(img_path)img = cv2.resize(img, (224, 224))if self.transform is not None:img = self.transform(img)return imgdef __len__(self):return len(self.images)if __name__ == '__main__':# 测试图像路径test_img_path = './data/test/last'# 检查点保存路径check_point_path = './model/model_epoch_200.pth'# 结果保存路径 如果不存在就创建save_dir = './data/test/result'if not os.path.exists(save_dir):os.makedirs(save_dir)transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])bag = TestDataset(test_img_path, transform)test_loader = DataLoader(bag, batch_size=1, shuffle=False)# 加载模型model = Net()model.load_state_dict(torch.load(check_point_path))# 遍历数据加载器中的每个图像for i, img in enumerate(test_loader):output = torch.sigmoid(model(img))# 将输出转换为numpy数组并取每列最小值output_np = output.detach().cpu().numpy()output_np = np.argmin(output_np, axis=1)# 压缩输出并乘以255img_arr = np.squeeze(output_np)img_arr = (img_arr * 255).astype(np.uint8)# 保存图像cv2.imwrite('%s/%03d.png' % (save_dir, i), img_arr)# 打印保存的图像路径print('%s/%03d.png' % (save_dir, i))

测试效果

在这里插入图片描述

  • 由于模型简单和训练次数较少，效果不是很好。

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

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

相关文章

威纶通触摸屏IP地址设定步骤及程序下载指南

威纶通触摸屏IP地址设定步骤及程序下载指南

在使用威纶通触摸屏时，正确设定IP地址以及完成程序下载是确保其正常运行和实现功能的关键步骤。本文将详细介绍威纶通触摸屏IP地址设定步骤及程序下载的方法。 一、IP地址设定步骤 （一）前期准备 确保威纶通触摸屏已经通电并启动&#xff0…
阅读更多...
一文读懂｜大模型智能体互操作协议：MCP/ACP/A2A/ANP

一文读懂｜大模型智能体互操作协议：MCP/ACP/A2A/ANP

导读 随着推理大模型的出现（deepseek，Qwen3等），进一步地推进了大模型的智能体系统发展。然而，如何使智能体更好的调用外部工具，智能体与智能体之间如何有机地协作，仍然没有一个完美的答案。这篇…
阅读更多...
前端下载ZIP包方法总结

前端下载ZIP包方法总结

在前端实现下载 ZIP 包到本地，通常有以下几种方法，具体取决于 ZIP 包的来源（静态文件、后端生成、前端动态生成等）： 方法 1：直接下载静态文件（最简单） 如果 ZIP 包是服务器上的静态…
阅读更多...
简单使用Slidev和PPTist

简单使用Slidev和PPTist

简单使用Slidev和PPTist 1 简介 前端PPT制作有很多优秀的工具包，例如：Slidev、revealjs、PPTist等，Slidev对Markdown格式支持较好，适合与大模型结合使用，选哟二次封装；revealjs适合做数据切换&#xff0c…
阅读更多...
数据挖掘：从数据堆里“淘金”，你的数据价值被挖掘了吗？

数据挖掘：从数据堆里“淘金”，你的数据价值被挖掘了吗？

数据挖掘：从数据堆里“淘金”，你的数据价值被挖掘了吗？ 在这个数据爆炸的时代，我们每天都在产生海量信息：社交媒体上的点赞、网购时的浏览记录，甚至是健身手环记录下的步数。这些数据本身可能看似杂乱无章…
阅读更多...
程序运行报错分析文档

程序运行报错分析文档

zryhuawei:~/src/modules/Connect$ ./newbuild/OpConnectAidTool \WARNING: MYSQL_OPT_RECONNECT is deprecated and will be removed in a future version. replace into process_tracking (step_id,date,status,context_data,start_time,end_time,error_log) values(?,?,?…
阅读更多...
基于flask+vue的电影可视化与智能推荐系统

基于flask+vue的电影可视化与智能推荐系统

基于flaskvue爬虫的电影数据的智能推荐与可视化系统，能展示电影评分、评论情感分析等直观的数据可视化图表，还能通过协同过滤算法为用户提供个性化电影推荐，帮助用户发现更多感兴趣的电影作品，具体界面如图所示。 本系统主要技术架…
阅读更多...
BYUCTF 2025

BYUCTF 2025

几周没会的比赛了，都是一题游。这周的BYU还不错，难度适中，只是时间有点短。周末时间不够。 Crypto Many Primes from Crypto.Util.number import bytes_to_long, getPrime import randomflag open("flag.txt").read().encode()…
阅读更多...
链表的面试题8之环形链表

链表的面试题8之环形链表

许久不见，那么这是最后倒数第三题了，这道题我们来看一下环形链表。 老规矩贴链接：141. 环形链表 - 力扣（LeetCode） 目录 倒数第k个元素 获取中间元素的问题。 双指针 来，大致看一下题目，这…
阅读更多...
在 JavaScript 中正确使用 Elasticsearch，第二部分

在 JavaScript 中正确使用 Elasticsearch，第二部分

作者：来自 Elastic Jeffrey Rengifo 回顾生产环境中的最佳实践，并讲解如何在无服务器环境中运行 Elasticsearch Node.js 客户端。 想获得 Elastic 认证？查看下一期 Elasticsearch Engineer 培训的时间！ Elasticsearch 拥有大量新…
阅读更多...
2025年网站安全防御全解析：应对DDoS与CC攻击的智能策略

2025年网站安全防御全解析：应对DDoS与CC攻击的智能策略

2025年，随着AI技术与物联网设备的深度融合，DDoS与CC攻击的规模与复杂度持续升级。攻击者不仅利用T级流量洪泛冲击带宽，还通过生成式AI伪造用户行为，绕过传统防御规则。如何在保障业务高可用的同时抵御混合型攻击？本文将…
阅读更多...
window 安装 wsl + cuda + Docker

window 安装 wsl + cuda + Docker

WSL 部分参考这里安装： Windows安装WSL2 Ubuntu环境 - 知乎 如果出现错误： WslRegisterDistribution failed with error: 0x800701bc 需要运行：https://crayon-shin-chan.blog.csdn.net/article/details/122994190 wsl --update wsl --shu…
阅读更多...
《MambaLLIE：基于隐式Retinex感知的低光照增强框架与全局-局部状态空间建模》学习笔记

《MambaLLIE：基于隐式Retinex感知的低光照增强框架与全局-局部状态空间建模》学习笔记

Paper:2405.16105 Github:GitHub - wengjiangwei/MambaLLIE 目录 摘要 一、介绍 二、相关工作 2.1 低光图像增强 2.2 视觉空间状态模型 三、方法 3.1 预备知识 3.2 整体流程 3.3 全局优先-局部次之状态空间块 四、实验 4.1 基准数据集与实施细节 4.2 对比实验 4…
阅读更多...
微信小程序：封装request请求、解决请求路径问题

微信小程序：封装request请求、解决请求路径问题

一、创建文件 1、创建请求文件 创建工具类文件request.js，目的是用于发送请求 二、js接口封装 1、写入接口路径 创建一个变量BASE_URL专门存储api请求地址 2、获取全局的token变量 从缓存中取出token的数据 3、执行请求 (1)方法中接收传递的参数 function request(url,…
阅读更多...
【单机版OCR】清华TH-OCR v9.0免费版

【单机版OCR】清华TH-OCR v9.0免费版

今天向大家介绍一款非常好用的单机版OCR图文识别软件，它不仅功能多，识别能力强，而且还是免费使用的。OCR软件为什么要使用单机版，懂得都懂，因为如果使用在线识别的OCR软件，用户需要将文档上传互联网服务器的…
阅读更多...
开源情报搜集系统：科研创新的强大引擎

开源情报搜集系统：科研创新的强大引擎

一、引言 在当今全球化和信息化高度发展的时代，科研活动面临着前所未有的机遇与挑战。一方面，知识的更新换代速度极快，科研成果如雨后春笋般不断涌现；另一方面，科研竞争日益激烈，如何在众多科研团队中脱颖…
阅读更多...
产品生命周期不同阶段的营销策略

产品生命周期不同阶段的营销策略

产品生命周期的不同阶段（导入期、成长期、成熟期、衰退期）需要匹配差异化的营销策略。以下是各阶段的营销重点及具体策略： 1. 导入期（Introduction Stage） 核心目标：建立市场认知，快速触达目标…
阅读更多...
Mujoco 学习系列（二）基础功能与xml使用

Mujoco 学习系列（二）基础功能与xml使用

这篇文章是 Mujoco 学习系列第二篇，主要介绍一些基础功能与 xmI 使用，重点在于如何编写与读懂 xml 文件。 运行这篇博客前请先确保正确安装 Mujoco 并通过了基本功能与GUI的验证，即至少完整下面这个博客的 第二章节 内容： Mujoc…
阅读更多...
面向SDV的在环测试深度解析——仿真中间件SIL KIT应用篇

面向SDV的在环测试深度解析——仿真中间件SIL KIT应用篇

1.引言 在汽车行业向软件定义汽车（SDV）转型的过程中，传统硬件在环（HIL）测试方案因难以适应新的技术架构与需求，其局限性日益凸显。传统HIL对硬件依赖性强，扩展性差，更换ECU或传感器…
阅读更多...
windows使用anaconda安装pytorch cuda版本

windows使用anaconda安装pytorch cuda版本

Windows安装PytorchCUDA环境_使用conda安装pytorch cuda10.2版本-CSDN博客
阅读更多...
最新文章

Copyright @ 2022~2023