深度学习（三）：pytorch搭建卷积神经网络

1.常用函数介绍

0 设备准备

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

这行代码是用来选择设备的，根据是否有可用的 CUDA 设备来选择使用 GPU 还是 CPU 进行计算。

更详细的解释如下：

  1. torch.cuda.is_available()：这个函数用来检查是否有可用的 CUDA 设备。如果返回 True，表示有可用的 CUDA 设备；如果返回 False，表示没有可用的 CUDA 设备。

  2. "cuda:0" 和 "cpu"：这是设备的标识符。"cuda:0" 表示选择第一个可用的 CUDA 设备，而 "cpu" 表示选择 CPU 设备。

  3. torch.device()：这是一个用来表示设备的类。通过传入设备标识符，可以创建一个设备对象。

  4. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")：这行代码使用了条件语句，如果有可用的 CUDA 设备，则选择 "cuda:0"，否则选择 "cpu"。然后将选择的设备赋值给 device 变量。

这行代码的作用是根据是否有可用的 CUDA 设备来选择使用 GPU 还是 CPU 进行计算。在后续的代码中，可以使用 device 变量来指定模型和张量所在的设备，以便进行相应的计算。例如：

model = YourModel().to(device)
input_tensor = input_tensor.to(device)

这样就可以将模型和输入数据都移动到指定的设备上进行计算。如果有可用的 CUDA 设备，计算将在 GPU 上进行；如果没有可用的 CUDA 设备，计算将在 CPU 上进行。

1.1 数据集

1.1.1数据集对象创建

在PyTorch中，数据集对象通常继承自torch.utils.data.Dataset类。创建数据集对象时，需要重写__len__()和__getitem__()方法。下面是一个创建自定义数据集对象的示例：

import torch
from torch.utils.data import Datasetclass MyDataset(Dataset):def __init__(self, data):self.data = datadef __len__(self):return len(self.data)def __getitem__(self, index):x = self.data[index][0]y = self.data[index][1]return x, y
#测试用例
data = [(torch.randn(10), torch.randint(0, 2, (1,))) for _ in range(100)]
dataset = MyDataset(data)

在这个例子中，我们创建了一个名为MyDataset的自定义数据集类，它继承自torch.utils.data.Dataset类。

  • 在__init__()方法中，我们接收一个数据列表data，并将其存储在类属性self.data中。
  • __len__()方法返回数据集的长度，即len(self.data)。
  • __getitem__()方法根据索引index返回数据集中的一个样本。

在这个例子中，我们假设每个样本由一个特征向量和一个标签组成，所以我们从数据列表中取出特征向量和标签，并将其作为返回值。我们创建了一个包含100个样本的数据集，每个样本由一个10维的特征向量和一个0到1之间的二进制标签组成。然后，我们将这个数据集传递给MyDataset类，创建一个数据集对象。

1.1.2 数据集划分

在 PyTorch 中，可以使用 torch.utils.data.random_split() 函数来随机划分数据集。

下面是一个示例代码，展示了如何使用 random_split() 函数随机划分数据集：

from torch.utils.data import random_split# 创建一个数据集对象
dataset = ...# 计算数据集的大小
dataset_size = len(dataset)# 计算训练集和验证集的大小
train_size = int(0.8 * dataset_size)
val_size = dataset_size - train_size# 使用 random_split() 函数随机划分数据集
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

在这个例子中，我们首先创建了一个数据集对象 dataset。然后，我们计算了数据集的大小 dataset_size。接下来，我们计算了训练集和验证集的大小，并将它们分别设置为 train_size 和 val_size。最后，我们使用 random_split() 函数将数据集随机划分为训练集和验证集，并将它们分别存储在 train_dataset 和 val_dataset 变量中。

需要注意的是，random_split() 函数会打乱数据集的顺序。因此，划分的训练集和验证集的顺序是随机的。

1.1.3 数据集加载器

在PyTorch中，可以使用torch.utils.data.DataLoader类加载数据集。下面是一个使用DataLoader加载自定义数据集的示例：

# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)# 使用数据加载器
for batch_idx, (inputs, targets) in enumerate(dataloader):print(f"Batch {batch_idx}:")print(f"  Inputs: {inputs.shape}")print(f"  Targets: {targets.shape}")

使用torch.utils.data.DataLoader类将其转换为数据加载器dataloader。DataLoader类需要两个参数：数据集对象dataset和批次大小batch_size。shuffle参数设置为True，表示在训练过程中对数据进行随机打乱。

最后，我们使用for循环遍历数据加载器，并每次从数据加载器中获取一个批次的数据，将其存储在inputs和targets变量中。我们可以使用print()函数输出每个批次的数据形状。在这个例子中，我们假设每个批次的大小为10，并且每个样本的特征向量大小为10，新的二进制标签大小为1。

1.2卷积网络结构

1.2.1 参数配置

  1. torch.nn.Linear:

    • 用法：torch.nn.Linear(in_features, out_features, bias=True)
    • 参数：
      • in_features：输入特征的大小。
      • out_features：输出特征的大小。
      • bias：是否使用偏置项，默认为True。
    • 用途：线性层用于进行线性变换，将输入特征映射到输出特征空间。

  2. torch.nn.Conv2d:

    • 用法：torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, bias=True)
    • 参数：
      • in_channels：输入通道数。
      • out_channels：输出通道数。
      • kernel_size：卷积核的大小。
      • stride：卷积步长，默认为1。
      • padding：填充大小，默认为0。
      • bias：是否使用偏置项，默认为True。
    • 用途：二维卷积层用于处理二维输入数据，例如图像。

  3. torch.nn.ConvTranspose2d:

    • 用法：torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, bias=True)
    • 参数：
      • in_channels：输入通道数。
      • out_channels：输出通道数。
      • kernel_size：卷积核的大小。
      • stride：卷积步长，默认为1。
      • padding：填充大小，默认为0。
      • output_padding：输出填充大小，默认为0。
      • bias：是否使用偏置项，默认为True。
    • 用途：二维转置卷积层用于将低维特征图转换为高维特征图，常用于图像生成任务或图像分割任务。

  4. torch.nn.MaxPool2d:

    • 用法：torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
    • 参数：
      • kernel_size：池化窗口的大小。
      • stride：池化步长，默认为None，表示与kernel_size相同。
      • padding：填充大小，默认为0。
      • dilation：扩张率，默认为1。
      • return_indices：是否返回池化操作的索引，默认为False。
      • ceil_mode：是否使用向上取整的方式计算输出大小，默认为False。
    • 用途：二维最大池化层用于减小特征图的空间尺寸，并保留最显著的特征。

  5. torch.nn.AvgPool2d:

    • 用法：torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)
    • 参数：
      • kernel_size：池化窗口的大小。
      • stride：池化步长，默认为None，表示与kernel_size相同。
      • padding：填充大小，默认为0。
      • ceil_mode：是否使用向上取整的方式计算输出大小，默认为False。
      • count_include_pad：是否将填充值包含在计算中，默认为True。
      • divisor_override：覆盖除数的值，默认为None。
    • 用途：二维平均池化层用于减小特征图的空间尺寸，并对每个池化窗口内的特征进行平均。

  6. torch.nn.BatchNorm2d:

    • 用法：torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    • 参数：
      • num_features：输入特征的通道数。
      • eps：数值稳定性参数，默认为1e-05。
      • momentum：动量参数，用于计算移动平均和方差，默认为0.1。
      • affine：是否使用可学习的缩放和偏移参数，默认为True。
      • track_running_stats：是否跟踪运行时的统计信息，默认为True。
    • 用途：二维批归一化层用于加速神经网络的训练过程和提高模型的泛化能力，对每个通道的特征进行归一化，并通过学习可调参数来进一步调整特征的均值和方差。

  7. torch.nn.ReLU:

    • 用法：torch.nn.ReLU(inplace=False)
    • 参数：
      • inplace：是否进行原地操作，默认为False。
    • 用途：ReLU激活函数用于引入非线性性，将负值置为零。

  8. torch.nn.Dropout:

    • 用法：torch.nn.Dropout(p=0.5, inplace=False)
    • 参数：
      • p：丢弃概率，默认为0.5。
      • inplace：是否进行原地操作，默认为False。
    • 用途：随机失活层用于在训练过程中随机丢弃一部分神经元，以减少过拟合。

1.2.2代码实例

  1. torch.nn.Linear:
import torch
import torch.nn as nn# 创建一个线性层，输入特征大小为10，输出特征大小为5
linear_layer = nn.Linear(10, 5)# 创建一个随机输入张量
input_tensor = torch.randn(3, 10)# 将输入张量传递给线性层进行线性变换
output = linear_layer(input_tensor)print(output.shape)  # 输出: torch.Size([3, 5])
  1. torch.nn.Conv2d:
import torch
import torch.nn as nn# 创建一个二维卷积层，输入通道数为3，输出通道数为16，卷积核大小为3x3
conv_layer = nn.Conv2d(3, 16, kernel_size=3)# 创建一个随机输入张量，大小为(batch_size, channels, height, width)
input_tensor = torch.randn(4, 3, 32, 32)# 将输入张量传递给卷积层进行卷积操作
output = conv_layer(input_tensor)print(output.shape)  # 输出: torch.Size([4, 16, 30, 30])
  1. torch.nn.ConvTranspose2d:
import torch
import torch.nn as nn# 创建一个二维转置卷积层，输入通道数为16，输出通道数为8，卷积核大小为4x4
conv_transpose_layer = nn.ConvTranspose2d(16, 8, kernel_size=4)# 创建一个随机输入张量，大小为(batch_size, channels, height, width)
input_tensor = torch.randn(4, 16, 14, 14)# 将输入张量传递给转置卷积层进行转置卷积操作
output = conv_transpose_layer(input_tensor)print(output.shape)  # 输出: torch.Size([4, 8, 17, 17])
  1. torch.nn.MaxPool2d:
import torch
import torch.nn as nn# 创建一个二维最大池化层，池化窗口大小为2x2
maxpool_layer = nn.MaxPool2d(kernel_size=2)# 创建一个随机输入张量，大小为(batch_size, channels, height, width)
input_tensor = torch.randn(4, 3, 32, 32)# 将输入张量传递给最大池化层进行池化操作
output = maxpool_layer(input_tensor)print(output.shape)  # 输出: torch.Size([4, 3, 16, 16])
  1. torch.nn.AvgPool2d:
import torch
import torch.nn as nn# 创建一个二维平均池化层，池化窗口大小为2x2
avgpool_layer = nn.AvgPool2d(kernel_size=2)# 创建一个随机输入张量，大小为(batch_size, channels, height, width)
input_tensor = torch.randn(4, 3, 32, 32)# 将输入张量传递给平均池化层进行池化操作
output = avgpool_layer(input_tensor)print(output.shape)  # 输出: torch.Size([4, 3, 16, 16])
  1. torch.nn.BatchNorm2d:
import torch
import torch.nn as nn# 创建一个二维批归一化层，输入特征通道数为3
batchnorm_layer = nn.BatchNorm2d(3)# 创建一个随机输入张量，大小为(batch_size, channels, height, width)
input_tensor = torch.randn(4, 3, 32, 32)# 将输入张量传递给批归一化层进行归一化操作
output = batchnorm_layer(input_tensor)print(output.shape)  # 输出: torch.Size([4, 3, 32, 32])
  1. torch.nn.ReLU:
import torch
import torch.nn as nn# 创建一个ReLU激活函数
relu = nn.ReLU()# 创建一个随机输入张量
input_tensor = torch.randn(3, 5)# 将输入张量传递给ReLU激活函数进行非线性变换
output = relu(input_tensor)print(output)
  1. torch.nn.Dropout:
import torch
import torch.nn as nn# 创建一个随机失活层，丢弃概率为0.5
dropout_layer = nn.Dropout(p=0.5)# 创建一个随机输入张量
input_tensor = torch.randn(3, 5)# 将输入张量传递给随机失活层进行随机丢弃
output = dropout_layer(input_tensor)print(output)

1.2.3 动手实践

#搭建神经网络
class Net(nn.Module):def __init__(self):super(Net,self).__init__()self.conv1 = nn.Conv2d(1,6,5)self.conv2 = nn.Conv2d(6,16,5)self.fc1 = nn.Linear(16*8*8,120)self.fc2 = nn.Linear(120,84)def forward(self,x):input_size=x.size(0)x=self.conv1(x)#print(x.size())x=F.relu(x)x=F.max_pool2d(x,2)x=self.conv2(x)#print(x.size())x=F.relu(x)x=x.view(input_size,-1)x=self.fc1(x)#print(x.size())x=F.relu(x)x=self.fc2(x)return F.log_softmax(x,dim=1)

1.3训练迭代

使用优化器进行模型训练时，可以根据需要选择不同的优化器算法和设置不同的参数。

  1. 创建优化器对象：

    optimizer = torch.optim.Optimizer(model.parameters(), lr=learning_rate)

    这里的 model.parameters() 是指模型的可学习参数，lr 是学习率（learning rate）。除了学习率，还可以设置其他参数，如权重衰减（weight decay）、动量（momentum）等。

  2. 在每个训练迭代中进行以下步骤：

    • 清零梯度：optimizer.zero_grad()
    • 前向传播：计算模型的输出
    • 计算损失：根据模型输出和目标值计算损失函数的值
    • 反向传播：计算梯度，使用 loss.backward() 方法
    • 更新参数：调用 optimizer.step() 方法来更新模型的参数

  3. 设置不同的优化器参数：

    • 学习率调整：可以使用 optimizer.param_groups 获取优化器的参数组，并对每个参数组设置不同的学习率。
    • 权重衰减：可以通过设置 weight_decay 参数来应用 L2 正则化，以减小模型参数的大小。
    • 动量：对于带有动量的优化器（如 SGD、Adam），可以设置 momentum 参数来控制动量的大小。

下面是一个更详细的示例代码片段，展示了优化器的用法：

import torch
import torch.nn as nn
import torch.optim as optim# 创建模型实例（这里是你创建的模型）
model = YourModel()# 定义损失函数
criterion = nn.CrossEntropyLoss()# 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001, momentum=0.9)# 在每个训练迭代中进行以下步骤：
for inputs, labels in dataloader:# 清零梯度optimizer.zero_grad()# 前向传播outputs = model(inputs)# 计算损失loss = criterion(outputs, labels)# 反向传播loss.backward()# 更新参数optimizer.step()

1.4模型评估

model.eval() 是一个模型方法，用于将模型设置为评估模式。在评估模式下，模型会禁用一些特定的操作，如 Dropout 层和批归一化层的随机性，以确保输出的一致性和可重复性。

更详细的用法如下：

  1. 设置模型为评估模式：

    model.eval()

    这将把模型设置为评估模式，禁用一些随机性操作。

  2. 在评估模式下进行推断或评估：

    with torch.no_grad():# 进行推断或评估操作output = model(input_tensor)

    在评估模式下，通常会使用 torch.no_grad() 上下文管理器来禁用梯度计算，以提高推断或评估的效率。

下面是一个更详细的示例代码片段，展示了 model.eval() 的用法：

import torch
import torch.nn as nn
model.eval()correct=0with torch.no_grad():for data,target in dataloader:output = model(data)pred = output.argmax(dim=1,keepdim=True)correct+=pred.eq(target.view_as(pred)).sum().item()
return correct/len(dataloader.dataset)

在上述示例中，首先创建了模型实例，然后使用 model.eval() 将模型设置为评估模式。接下来，加载了预训练模型参数，并在评估模式下进行推断或评估操作。使用 torch.no_grad() 上下文管理器来禁用梯度计算，以提高推断或评估的效率。

请注意，model.eval() 方法只是将模型设置为评估模式，并不会自动执行推断或评估操作。你需要根据具体的需求编写相应的代码来进行推断或评估。

1.5 保存模型

保存模型是在训练完成后将模型的参数保存到磁盘上，以便后续加载和使用。以下是保存模型的一般步骤：

  1. 定义模型：

    model = YourModel()

  2. 训练模型：

    # 训练过程...

  3. 保存模型参数：

    torch.save(model.state_dict(), 'model.pth')

    上述代码将模型的参数保存到名为 'model.pth' 的文件中。model.state_dict() 返回一个包含模型参数的字典，torch.save() 函数将该字典保存到文件中。

完整的示例代码如下：

import torch
import torch.nn as nn# 定义模型
model = YourModel()# 训练模型
# ...# 保存模型参数
torch.save(model.state_dict(), 'model.pth')

保存模型参数后，你可以使用 torch.load() 函数加载模型参数，并将其应用于新的模型实例中：

import torch
import torch.nn as nn# 定义模型
model = YourModel()# 加载模型参数
model.load_state_dict(torch.load('CNN.pth'))

通过加载模型参数，你可以恢复之前训练好的模型，并在后续的推断或评估中使用它。

2.在MNIST数据集实验

2.1 结果

数据如图所示
在这里插入图片描述
训练得到,保存模型：
在这里插入图片描述
调用预测：
在这里插入图片描述
调用保存的模型：

在这里插入图片描述

2.2总代码

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt
import torchvision.transforms as transforms
import torchvision
import torch.nn.functional as F
from torch import nn, optim
import torch
from torch.utils.data import Dataset
import numpy as np""" class MyDataset(Dataset):def __init__(self, data):self.data = datadef __len__(self):return len(self.data)def __getitem__(self, index):x = self.data[index][0]y = self.data[index][1]return x, y
data = [(torch.randn(10), torch.randint(0, 2, (1,))) for _ in range(100)]
print(data)
dataset = MyDataset(data)
print(dataset)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True)"""
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device) # 指定数据集的根目录
root = './data'# 定义数据预处理
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))
])# 加载MNIST数据集
mnist_dataset = torchvision.datasets.MNIST(root=root,train=True,transform=transform,download=True
)
print(len(mnist_dataset))
#划分数据集
train_dataset, val_dataset = torch.utils.data.random_split(mnist_dataset, [55000, 5000])# 创建数据加载器
mnist_train_dataloader = DataLoader(dataset=train_dataset,batch_size=100,shuffle=False,
)
mnist_val_dataloader = DataLoader(dataset=val_dataset,batch_size=100,shuffle=False,
)#搭建神经网络
class Net(nn.Module):def __init__(self):super(Net,self).__init__()self.conv1 = nn.Conv2d(1,6,5)self.conv2 = nn.Conv2d(6,16,5)self.fc1 = nn.Linear(16*8*8,120)self.fc2 = nn.Linear(120,84)def forward(self,x):input_size=x.size(0)x=self.conv1(x)#print(x.size())x=F.relu(x)x=F.max_pool2d(x,2)x=self.conv2(x)#print(x.size())x=F.relu(x)x=x.view(input_size,-1)x=self.fc1(x)#print(x.size())x=F.relu(x)x=self.fc2(x)return F.log_softmax(x,dim=1)#训练
def train(epoch_idx,model,dataloader,optimizer):model.train()for batch_idx, (data,target) in enumerate(dataloader):optimizer.zero_grad()output = model(data)loss = F.nll_loss(output,target)loss.backward()optimizer.step()#预测结果
def test(model,dataloader):model.eval()correct=0with torch.no_grad():for data,target in dataloader:output = model(data)pred = output.argmax(dim=1,keepdim=True)correct+=pred.eq(target.view_as(pred)).sum().item()return correct/len(dataloader.dataset),pred
network = Net().to(device)
""" n_epochs = 10
learning_rate=0.01
optimizer = optim.SGD(network.parameters(), lr=learning_rate)
for i in range(1,n_epochs+1):print(f"Epoch {i}\n-------------------------------")train(epoch_idx = i, model = network,dataloader = mnist_train_dataloader, optimizer = optimizer)accuray,result=test(model = network,dataloader = mnist_val_dataloader)print(accuray)print(result.shape)print("-------------------------------")
torch.save(network.state_dict(), 'CNN.pth') """
network.load_state_dict(torch.load('CNN.pth'))
accuray,result=test(model = network,dataloader = mnist_val_dataloader)
data_loader_iter = iter(mnist_val_dataloader)
while True:try:item = next(data_loader_iter)# 对 item 进行处理image, label = itemexcept StopIteration:break
images=image.numpy()
labels=label.numpy()fig = plt.figure(figsize=(25,4))
for idx in np.arange(20):ax = fig.add_subplot(2,10, idx+1, xticks=[], yticks=[])ax.imshow(images[idx][0], cmap='gray')ax.set_title('real:'+str(labels[idx].item())+'ped:'+str(result[idx].item()))
plt.show()

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

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

相关文章

socket.io介绍

socket.io介绍

1. 使用的技术 Socket.IO 是一个封装了 Websocket、基于 Node 的 JavaScript 框架，包含 client 的 JavaScript 和 server 的 Node。其屏蔽了所有底层细节，让顶层调用非常简单。 另外，Socket.IO 还有一个非常重要的好处。其不仅支持 WebSocket…
阅读更多...
Spring三级缓存处理循环依赖的过程

Spring三级缓存处理循环依赖的过程

Spring三级缓存 Spring三级缓存是什么？ 一级缓存：单例池。存放的是完整的Bean对象。经过完整的生命周期。二级缓存：存放需要提前暴露的Bean对象。也就不完整的Bean对象。需要提前暴露就是指，可能会被循环依赖。(这里可能需要用代…
阅读更多...
jupyter notebook 添加环境与删除环境

jupyter notebook 添加环境与删除环境

添加环境 一、查看conda现有的环境 打开 Anaconda Powershell Prompt 输入以下代码，查看全部环境：conda env list 可以看到如下已经配置的环境变量： 二、激活现有环境 在 Anaconda Powershell Prompt 继续输入，激活环境&#…
阅读更多...
Python之Appium 2自动化测试（Android篇）

Python之Appium 2自动化测试（Android篇）

一、环境搭建及准备工作 1、Appium 2 环境搭建 请参考另一篇文章: Windows系统搭建Appium 2 和 Appium Inspector 环境 2、安装 Appium-Python-Client，版本要求3.0及以上 pip install Appium-Python-ClientVersion: 3.1.03、手机连接电脑，并在dos窗口…
阅读更多...
13-Vue基础之自定义指令与插槽的使用

13-Vue基础之自定义指令与插槽的使用

个人名片： 😊作者简介：一名大二在校生 🤡 个人主页：坠入暮云间x 🐼座右铭：懒惰受到的惩罚不仅仅是自己的失败，还有别人的成功。 🎅**学习目标: 坚持每一次的学习打卡 文章…
阅读更多...
[c++]——string类____详细初步了解string类的运用

[c++]——string类____详细初步了解string类的运用

在成为大人的路上喘口气. 目录 🎓标准库类型string 🎓定义和初始化string对象 💻string类对象的常见构造 💻string类对象的不常见构造 💻读写string对象 🎓 string类对象的修改操作 &#x1f4…
阅读更多...
openGauss学习笔记-135 openGauss 数据库运维-例行维护-检查openGauss健康状态

openGauss学习笔记-135 openGauss 数据库运维-例行维护-检查openGauss健康状态

文章目录 openGauss学习笔记-135 openGauss 数据库运维-例行维护-检查openGauss健康状态135.1 检查办法135.2 操作步骤135.3 异常处理 openGauss学习笔记-135 openGauss 数据库运维-例行维护-检查openGauss健康状态 135.1 检查办法 通过openGauss提供的gs_check工具可以开展o…
阅读更多...
List系列集合

List系列集合

List系列集合特点：有序，可重复，有索引 ArrayList：有序，可重复，有索引 LinkedList：有序，可重复，有索引 （底层实现不同！适合的场景不同！…
阅读更多...
java实战（四）:编写学生信息管理系统页面·

java实战（四）:编写学生信息管理系统页面·

1.要求 编写程序 实现表格的输入和编辑功能。界面如下： 1、用户按插入键后，把学号、姓名和成绩插入到最后一行，序号显示当前的行号。 2、当用户选中表格的某一行时，按删除按钮，则这一行从表格中删除 3、编辑功能&am…
阅读更多...
OpenCV中八种不同的目标追踪算法

OpenCV中八种不同的目标追踪算法

引言 目标跟踪作为机器学习的一个重要分支，加之其在日常生活、军事行动中的广泛应用，受到极大的关注。在AI潮流中，大家对于深度学习，目标跟踪肯定都会有过接触了解：在GPU上通过大量的数据集训练出自己想使用的垂直场景…
阅读更多...
sqli-labs(9)

sqli-labs(9)

45. 不会显示报错信息通过or 1验证 在密码处输入)or(1 登录成功 )union select 1,2,3 # )union select 1,database(),3 # )union select 1,(select group_concat(table_name) from information_schema.tables where table_schemasecurity),3 # )union select 1,(select gro…
阅读更多...
学习记录PCL-1 通过哈希表进行三维点云的虚拟格网划分

学习记录PCL-1 通过哈希表进行三维点云的虚拟格网划分

直接对整个场景的点云进行特征提取，效果很差，因此通过划分区域格网进行划分。格网划分有很多种方式，在这里尝试使用哈希表进行格网链接，后续通过在每个格网内基于点云特征进行提取。 参考博客： 点云侠的PCL 点云分块_p…
阅读更多...
ESP32-Web-Server编程- 通过文本框向 Web 提交数据

ESP32-Web-Server编程- 通过文本框向 Web 提交数据

ESP32-Web-Server编程- 通过文本框向 Web 提交数据 概述 前述章节我们通过简单 HTML、AJAX、Websocket、SSE 在网页上显示数据，通过网页上的按钮控制 ESP32 的行为。从本节开始，我们将进一步了解通过网页与 ESP32 进行交互的方法。 实现更复杂的交互功…
阅读更多...
【OJ比赛日历】快周末了，不来一场比赛吗？ #12.02-12.08 #15场

【OJ比赛日历】快周末了，不来一场比赛吗？ #12.02-12.08 #15场

CompHub[1] 实时聚合多平台的数据类(Kaggle、天池…)和OJ类(Leetcode、牛客…）比赛。本账号会推送最新的比赛消息，欢迎关注！ 以下信息仅供参考，以比赛官网为准 目录 2023-12-02（周六） #4场比赛2023-12-03…
阅读更多...
nginx部署多个vue或react项目

nginx部署多个vue或react项目

下载nginx(tar.gz) nginx: download(官方地址) 部署nginx # 进入nginx压缩包所在目录 cd /usr/nginx# 解压 tar -zxvf nginx-1.25.3.tar.gz# 安装nginx的相关依赖 yum -y install gcc zlib zlib-devel pcre-devel openssl openssl-devel# 生成Makefile可编译文件 cd /usr/ng…
阅读更多...
Electron+Ts+Vue+Vite桌面应用系列：TypeScript常用时间处理工具

Electron+Ts+Vue+Vite桌面应用系列：TypeScript常用时间处理工具

文章目录 1️⃣ 时间处理工具1.1 格式化时间1.2 把时间戳改成日期格式1.3 Day.js 工具类使用1.4 date-fns 工具类使用 优质资源分享 作者：xcLeigh 文章地址：https://blog.csdn.net/weixin_43151418/article/details/134712978 ElectronTsVueVite桌面应用…
阅读更多...
华为全屋智能5.0，无为而“智”

华为全屋智能5.0，无为而“智”

在赖特西塔里埃森混凝土墙的中心壁龛里，一块铜牌上刻着一些英文，意思是“建筑的意义不是屋顶和墙，而是人们生活于其中的空间”。 这句话，取自老子《道德经》中的“凿户牖以为室，当其无，有室之用”。 《理想…
阅读更多...
数据库管理-第119期 记一次迁移和性能优化（202301130）

数据库管理-第119期 记一次迁移和性能优化（202301130）

数据库管理-第119期 记一次迁移和性能优化（202301130） 1 迁移 之前因为DV组件没有迁移成功的那个PDB，后来想着在目标端安装DV组件迁移，结果目标端装不上，而且开了SR也没看出个所以然来。只能换一个方向，尝…
阅读更多...
VIR-SLAM代码分析3——VIR_VINS详解之estimator.cpp/.h

VIR-SLAM代码分析3——VIR_VINS详解之estimator.cpp/.h

前言 续接上一篇，本本篇接着介绍VIR-SLAM中estimator.cpp/.h文件的函数，尤其是和UWB相关的相比于VINS改动过的函数，仍然以具体功能情况代码注释的形式进行介绍。 重点函数介绍 优化函数，代码是先优化，后边缘化。 …
阅读更多...
mysql 日志分析

mysql 日志分析

程序启动标志 可以直接全局搜索，查看启动了几次 可以看到总共11次，当前是第2次 如何判断mysql是正常关闭，手动启动的 下图中启动之前出现 Shutdown complete打印说明启动之前是正常关闭的
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023