深度学习（三）：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.rhkb.cn/news/207138.html

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

相关文章

C语言-指针讲解(4)

C语言-指针讲解(4)

在上一篇博客中： C语言-指针讲解(3) 我们给大家介绍了指针进阶的用法 让下面我们来回顾一下讲了什么吧： 1.字符指针变量类型以及用法 2.数组指针本质上是一个指针，里面存放数组的地址。而指针数组本质上是个数组，里面存放的是指针…
阅读更多...
IDEA maven无法下载源代码处理

IDEA maven无法下载源代码处理

1、使用idea内置maven 在idea中新增一个mvn运行项,截图如下: 输入命令: dependency:resolve -Dclassifiersources 2、如果外部maven，不使用idea内部maven 在工程目录下命令行执行命令: mvn dependency:resolve -Dclassifiersources
阅读更多...
智慧城市政务一网统管解决方案：PPT全文34页，附下载

智慧城市政务一网统管解决方案：PPT全文34页，附下载

关键词：智慧政务解决方案，智慧城市解决方案，智慧政务一网统管解决方案，一网统管治理理念，一网统管治理体系，一网统管治理手段，智慧政务综合服务平台建设 一、智慧城市政务一网统管建设背景 一…
阅读更多...
Python快速实现BMI(身体质量指数)计算器(窗口界面形式)

Python快速实现BMI(身体质量指数)计算器(窗口界面形式)

BMI是身体质量指数（Body Mass Index）的缩写，是一种衡量人体肥胖程度的指标。它是根据人的身高和体重计算得出的，公式为： BMI 体重（kg）/ 身高^2（m） 其中，体…
阅读更多...
说说你对slot的理解？slot使用场景有哪些？

说说你对slot的理解？slot使用场景有哪些？

面试官&#xff1a;说说你对slot的理解&#xff1f;slot使用场景有哪些&#xff1f; 一、slot是什么 在HTML中 slot 元素 &#xff0c;作为 Web Components 技术套件的一部分&#xff0c;是Web组件内的一个占位符 该占位符可以在后期使用自己的标记语言填充 举个栗子 <t…
阅读更多...
centos服务器安装docker和Rabbitmq

centos服务器安装docker和Rabbitmq

centos服务器 一 centos安装docker1 安装docker所需要的依赖包2配置yum源3查看仓库中所有的docker版本4安装docker5 设置docker为开机自启6验证docker是否安装成功 二 使用docker安装RabbitMQ拉取RabbitMQ镜像创建并运行容器 一 centos安装docker 1 安装docker所需要的依赖包 …
阅读更多...
借助ETL快速查询金蝶云星空表单信息

借助ETL快速查询金蝶云星空表单信息

随着数字化转型的加速&#xff0c;企业信息化程度越来越高&#xff0c;大量的数据产生并存储在云端&#xff0c;需要进行有效的数据管理和查询。金蝶云星空是金蝶云旗下的一款云ERP产品&#xff0c;为企业提供了完整的业务流程和数据管理功能&#xff0c;因此需要进行有效的数据…
阅读更多...
【Linux】I/O多路转接技术

【Linux】I/O多路转接技术

I/O多路转接技术 一、I/O多路转接之select1、select函数2、fd_set的相关内容3、如何在代码中高效的使用select函数4、select服务器5、select的优缺点6、select的适用场景 二、I/O多路转接之poll1、poll函数2、struct pollfd结构2、poll服务器3、poll的优缺点 三、I/O多路转接之…
阅读更多...
Nacos 2.X核心架构源码剖析

Nacos 2.X核心架构源码剖析

概述 注册中心并发处理&#xff0c;1.4.x 写时复制&#xff0c;2.1.0 读写分离&#xff1b;nacos 一般使用 AP 架构&#xff0c;即临时实例&#xff0c;1.4.x 为 http 请求&#xff0c;2.1.0 优化为 gRPC 协议&#xff1b;源码中使用了大量的事件通知机制和异步定时线程池&…
阅读更多...
【产品经理】AI在SaaS产品中的应用及挑战

【产品经理】AI在SaaS产品中的应用及挑战

随着ChatGPT大模型在全球的爆火&#xff0c;AI迅速在各个行业内&#xff0c;助力于各行业的效率提升。而SaaS领域&#xff0c;AI同样也大有可为。 AI&#xff08;人工智能&#xff0c;Artificial Intelligence的缩写&#xff09;近一年来一直处于舆论风口&#xff0c;随着ChatG…
阅读更多...
颠覆性语音识别：单词级时间戳和说话人分离

颠覆性语音识别：单词级时间戳和说话人分离

vbenjs/vue-vben-admin[1] Stars: 19.7k License: MIT Vue Vben Admin 是一个免费开源的中后台模板&#xff0c;使用最新的 vue3、vite4 和 TypeScript 等主流技术进行开发。该项目提供了现成的中后台前端解决方案&#xff0c;并可用于学习参考。 使用先进的前端技术如 Vue3/…
阅读更多...
ZYNQ_project:HDMI

ZYNQ_project:HDMI

实验目标&#xff1a;先显示彩条&#xff0c;通过uart串口传输100x100 大小图片像素信息&#xff0c;然后开始弹跳显示该图片在显示器上。 HDMI 是新一代的多媒体接口标准&#xff0c; 英文全称是 High-Definition Multimedia Interface&#xff0c; 即高清多媒体接口。 它能够…
阅读更多...
LeetCode（38）生命游戏【矩阵】【中等】

LeetCode（38）生命游戏【矩阵】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 生命游戏 1.题目 根据 百度百科 &#xff0c; 生命游戏 &#xff0c;简称为 生命 &#xff0c;是英国数学家约翰何顿康威在 1970 年发明的细胞自动机。 给定一个包含 m n 个格子的面板&#xff0c;每一个格子都可以看成是…
阅读更多...
【数据库】数据库并发控制的冲突检测，冲突可串行化的调度，保障事务的特性

【数据库】数据库并发控制的冲突检测，冲突可串行化的调度，保障事务的特性

冲突可串行化 ​专栏内容&#xff1a; 手写数据库toadb 本专栏主要介绍如何从零开发&#xff0c;开发的步骤&#xff0c;以及开发过程中的涉及的原理&#xff0c;遇到的问题等&#xff0c;让大家能跟上并且可以一起开发&#xff0c;让每个需要的人成为参与者。 本专栏会定期更新…
阅读更多...
cocos游戏引擎制作的滚动框地图防止误点操作的简单方法

cocos游戏引擎制作的滚动框地图防止误点操作的简单方法

本篇文章主要讲解&#xff0c;使用cocos creator 来解决在我们日常滚动框开发中&#xff0c;滚动和触摸存在冲突的情况&#xff0c;导致的误触行为的解决办法。 日期&#xff1a;2023年11月25日 具体事项 说明&#xff1a;在我们滚动滚动框时&#xff0c;会出现误点的情况&…
阅读更多...
JSP过滤器和监听器

JSP过滤器和监听器

什么是过滤器 Servlet过滤器与Servlet十分相似&#xff0c;但它具有拦截客户端&#xff08;浏览器&#xff09;请求的功能&#xff0c;Servlet过滤器可以改变请求中的内容&#xff0c;来满足实际开发中的需要。 对于程序开发人员而言&#xff0c;过滤器实质就是在Web应用服务…
阅读更多...
【双向链表的实现】

【双向链表的实现】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 目录 前言 1. 双向链表的结构 2. 双向链表的实现 2.1 头文件 ——双向链表的创建及功能函数的定义 2.2 源文件 ——双向链表的功能函数的实现 2.3 源文件 ——双向链表功能的…
阅读更多...
处理机调度与作业调度

处理机调度与作业调度

处理机调度 一个批处理型作业&#xff0c;从进入系统并驻留在外存的后备队列上开始&#xff0c;直至作业运行完毕&#xff0c;可能要经历如下的三级调度 高级调度 也称为作业调度、长程调度、接纳调度。调度对象是作业 主要功能&#xff1a; 挑选若干作业进入内存 为作业创建…
阅读更多...
Js页面录屏切片存储数据上传后端

Js页面录屏切片存储数据上传后端

前端 screenShot(){// 获取屏幕共享流navigator.mediaDevices.getDisplayMedia({video: true,audio: true,//preferCurrentTab 共享本次操作的页面preferCurrentTab: true}).then(async stream > {const mediaRecorder new MediaRecorder(stream, { mimeType: video/webm; …
阅读更多...
阿里云国际短信业务网络超时排障指南

阿里云国际短信业务网络超时排障指南

选取一台或多台线上的应用服务器或选取相同网络环境下的机器&#xff0c;执行以下操作。 获取公网出口IP。 curl ifconfig.me 测试连通性。 &#xff08;推荐&#xff09;执行MTR命令&#xff08;可能需要sudo权限&#xff09;&#xff0c;检测连通性&#xff0c;执行30秒。 m…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023