PyTorch深度学习实战(6)——神经网络性能优化技术

PyTorch深度学习实战(6)——神经网络性能优化技术

    • 0. 前言
    • 1. 数据准备
      • 1.1 数据集分析
      • 1.2 数据集加载
    • 2. 使用 PyTorch 训练神经网络
      • 2.1 神经网络训练流程
      • 2.2 PyTorch 神经网络训练
    • 3. 缩放数据集
    • 4. 修改优化器
    • 5. 构建深层神经网络
    • 小结
    • 系列链接

0. 前言

我们已经学习了神经网络的基础概念,并了解了如何利用 PyTorch 库构建实用神经网络模型。同时我们还提到了,有多种超参数可以影响神经网络的准确率。在本节中,我们将使用 Fashion MNIST 数据集,用于构建神经网络模型执行图像分类任务,并对比使用不同参数训练模型的性能差异。

1. 数据准备

1.1 数据集分析

Fashion MNIST 数据集是一个用于图像分类任务的经典数据集,它包含了 10 个类别的时尚服饰图像。每个样本都是一张 28x28 像素的灰度图像,总共有 60000 个训练样本和 10000 个测试样本。由于其简单易用的特点,Fashion MNIST 数据集已经成为学术界和研究人员常用的基准数据集之一,可以用于验证图像分类算法的性能。

1.2 数据集加载

(1) 首先下载数据集并导入相关库,torchvision 库包含多个机器学习数据集,其中包括 Fashion MNIST 数据集:

from torchvision import datasets
import torch
data_folder = './data/FMNIST' # This can be any directory you want to download FMNIST to
fmnist = datasets.FashionMNIST(data_folder, download=True, train=True)

在以上代码中,指定了要存储下载数据集的文件夹 (data_folder)。接下来,利用 datasets.FashionMNIST 获取 fmnist 数据并将其存储在 data_folder 中。此外,通过参数 train = True 指定仅下载训练图像。

(2) 接下来,将 fmnist.data 中可用的图像存储为 tr_images,并将对应的图像标签 (fmnist.targets) 存储为 tr_targets

tr_images = fmnist.data
tr_targets = fmnist.targets

(3) 检查加载后的张量数据:

unique_values = tr_targets.unique()
print(f'tr_images & tr_targets:\n\tX - {tr_images.shape}\n\tY - {tr_targets.shape}\n\tY - Unique Values : {unique_values}')
print(f'TASK:\n\t{len(unique_values)} class Classification')
print(f'UNIQUE CLASSES:\n\t{fmnist.classes}') 

代码输出结果如下:

tr_images & tr_targets:X - torch.Size([60000, 28, 28])Y - torch.Size([60000])Y - Unique Values : tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
TASK:10 class Classification
UNIQUE CLASSES:['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

在以上结果中,可以看出训练数据集有 60,000 张图像,每张图像的大小为 28 x 28,且包含 10 个可能的类别,tr_targets 包含每个图像的类别标签(以数值表示),而 fmnist.classes 表示与 tr_targets 中的每个数值对应的类别名称。

(4) 绘制随机图像样本。

导入相关库用于绘制图像以及处理图像数组:

import matplotlib.pyplot as plt
import numpy as np

创建一个 10 x 10 的图像网格,其中网格的每一行对应一个类别,遍历所有类别 (label_class) 并获取与给定类别对应的行索引 (label_x_rows):

R, C = len(tr_targets.unique()), 10
fig, ax = plt.subplots(R, C, figsize=(10,10))
for label_class, plot_row in enumerate(ax):label_x_rows = np.where(tr_targets == label_class)[0]

在以上代码中,获取 np.where 输出的第 0 个索引(因为其输出的长度为 1),它包含目标值 (tr_targets) 等于 label_class 的所有索引。

循环 10 次填充所有图像网格,我们从先前获得的给定类的索引 (label_x_rows) 中选择一个随机值 (ix) 并绘制:

    for plot_cell in plot_row:plot_cell.grid(False); plot_cell.axis('off')ix = np.random.choice(label_x_rows)x, y = tr_images[ix], tr_targets[ix]plot_cell.imshow(x, cmap='gray')

示例图像

在上图中,每一行代表属于同一类的 10 个不同图像的样本。

2. 使用 PyTorch 训练神经网络

接下来,将介绍如何使用 PyTorch 训练神经网络,以便根据输入图像预测图像类别。此外,我们还将了解各种超参数对模型预测准确率的影响。

2.1 神经网络训练流程

使用 PyTorch 训练神经网络,通常需要执行以下步骤:

  • 导入相关库
  • 构建数据集,一次获取一个数据点
  • 使用 DataLoader 封装数据集
  • 构建模型,并定义损失函数和优化器
  • 定义两个函数分别用于在一批数据上进行训练和验证
  • 定义函数用于模型预测的准确率
  • 在每批数据训练过程中更新模型权重,通过多个 epoch 的迭代训练模型

2.2 PyTorch 神经网络训练

(1) 导入相关库和 Fashion MNIST 数据集:

from torch.utils.data import Dataset, DataLoader
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as pltdevice = "cuda" if torch.cuda.is_available() else "cpu"
from torchvision import datasets
data_folder = './data/FMNIST' # This can be any directory you want to download FMNIST to
fmnist = datasets.FashionMNIST(data_folder, download=True, train=True)
tr_images = fmnist.data
tr_targets = fmnist.targets

(2) 构建一个用于获取数据集的类,它继承自 Dataset 类,且需要定义以下三个函数, __init____getitem____len__

class FMNISTDataset(Dataset):def __init__(self, x, y):x = x.float()x = x.view(-1, 28*28)self.x, self.y = x, ydef __getitem__(self, ix):x, y = self.x[ix], self.y[ix]return x.to(device), y.to(device)def __len__(self):return len(self.x)

__init__ 方法中,将输入转换为浮点数,并将每个图像展平为 28*28 = 784 个数值(其中每个数值对应一个像素值);在 __len__ 方法中指定数据数量;__getitem__ 方法用于返回第 ix 个索引对应的数据( ix0__len__ 之间的整数)。

(3) 创建函数,从数据集( FMNISTDataset )中生成一个训练数据 DataLoader——trn_dl,每批数据包含随机采样的 32 个数据点:

def get_data():train = FMNISTDataset(tr_images, tr_targets)trn_dl = DataLoader(train, batch_size=32, shuffle=True)return trn_dl

在以上代码中,创建了 FMNISTDataset 类的对象 train,并调用了 DataLoader,使其随机获取 32 个数据点并返回训练 DataLoader

(4) 定义模型,以及损失函数和优化器:

from torch.optim import SGD
def get_model():model = nn.Sequential(nn.Linear(28*28, 1000),nn.ReLU(),nn.Linear(1000, 10)).to(device)loss_fn = nn.CrossEntropyLoss()optimizer = SGD(model.parameters(), lr=1e-2)return model, loss_fn, optimizer

模型使用了一个具有 1,000 个神经元的隐藏层,输出层包含 10 个神经元,对应于 10 个可能的类别。由于输出结果表示输入图像属于 10 个类别的概率,因此调用 CrossEntropyLoss 损失函数。最后,将学习率 lr 初始化为 0.01,而不使用默认值 0.001
在神经网络中并未使用 “softmax” 函数(因此模型输出范围不受限制,而交叉熵损失通常期望输出为概率——每一图像的预测结果之和 1),这是因为 nn.CrossEntropyLoss 接受原始 logits (即不受约束的值)并在内部执行 softmax

(5) 定义将在一批图像上训练模型的函数:

def train_batch(x, y, model, optimizer, loss_fn):model.train()# call your model like any python function on your batch of inputsprediction = model(x)# compute lossbatch_loss = loss_fn(prediction, y)# based on the forward pass in `model(x)` compute all the gradients of 'model.parameters()'batch_loss.backward()# apply new-weights = f(old-weights, old-weight-gradients) where "f" is the optimizeroptimizer.step()# Flush gradients memory for next batch of calculationsoptimizer.zero_grad()return batch_loss.item()

在前向传播中通过模型处理输入图像,计算输入批数据损失,然后通过反向传播计算梯度并更新权重,最后刷新梯度的内存,以免对下一次传递中计算梯度时产生影响。可以通过在 batch_loss 之上获取 batch_loss.item() 提取标量损失值。

(6) 编写函数计算模型在给定数据集上准确率:

@torch.no_grad()
def accuracy(x, y, model):model.eval()# get the prediction matrix for a tensor of `x` imagesprediction = model(x)# compute if the location of maximum in each row coincides with ground truthmax_values, argmaxes = prediction.max(-1)is_correct = argmaxes == yreturn is_correct.cpu().numpy().tolist()

在以上代码中,通过使用 @torch.no_grad() 显式的声明无需进行梯度计算。调用 prediction.max(-1) 来识别每行对应的 argmax 索引;此外,通过 argmaxes == y 将预测结果 argmaxes 与真实值( ground true )进行比较,以便检查是否得到正确预测。最后,将 is_correct 对象列表移动到 CPU 中并将其转换为 numpy 数组后返回。

(7) 训练神经网络。

首先初始化模型、损失、优化器和数据加载器:

trn_dl = get_data()
model, loss_fn, optimizer = get_model()

在每个 epoch 结束时记录准确率和损失值:

losses, accuracies = [], []

定义模型训练的 epoch 数:

for epoch in range(10):print(epoch)

初始化列表用于记录一个 epoch 内每批数据对应的准确率和损失值:

    epoch_losses, epoch_accuracies = [], []

通过迭代 DataLoader 创建批训练数据:

    for ix, batch in enumerate(iter(trn_dl)):x, y = batch

使用 train_batch 函数利用批数据训练模型,并将批训练结束时的损失值 batch_loss 存储在 epoch_losses 列表中:

        batch_loss = train_batch(x, y, model, optimizer, loss_fn)epoch_losses.append(batch_loss)

存储一个 epoch 内所有批训练的平均损失值:

    epoch_loss = np.array(epoch_losses).mean()

在所有批训练结束时计算预测的准确率:

    for ix, batch in enumerate(iter(trn_dl)):x, y = batchis_correct = accuracy(x, y, model)epoch_accuracies.extend(is_correct)epoch_accuracy = np.mean(epoch_accuracies)

将每个 epoch 结束时的损失和准确率值存储在列表中:

    losses.append(epoch_loss)accuracies.append(epoch_accuracy)

(8) 绘制训练损失和准确率随时间的变化情况:

epochs = np.arange(10)+1
plt.figure(figsize=(20,5))
plt.subplot(121)
plt.title('Loss value over increasing epochs')
plt.plot(epochs, losses, label='Training Loss')
plt.legend()
plt.subplot(122)
plt.title('Accuracy value over increasing epochs')
plt.plot(epochs, accuracies, label='Training Accuracy')
plt.gca().set_yticklabels(['{:.0f}%'.format(x*100) for x in plt.gca().get_yticks()]) 
plt.legend()
plt.show()

损失和准确率随时间的变化情况

在训练 5epoch 时,模型的训练准确率为 15%,并且随着 epoch 的增加,损失值并没有显着降低。换句话说,无论再训练多长时间,该模型的准确率都不太可能显著增长。
我们已经对训练神经网络的完整流程有了完整了解,接下来,我们通过微调超参数来获得更好的模型性能。

3. 缩放数据集

缩放数据集是确保变量被限制在给定范围内的过程,以确保数据不会分布在较大的区间。在本节中,我们通过将每个输入值除以数据集中的最大可能值,将自变量的值限制在 01 之间。通常,缩放输入数据集能够提高神经网络的性能表现。

(1) 获取数据集,包括训练图像及其标签:

from torch.utils.data import Dataset, DataLoader
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as pltdevice = "cuda" if torch.cuda.is_available() else "cpu"
from torchvision import datasets
data_folder = './data/FMNIST' 
fmnist = datasets.FashionMNIST(data_folder, download=True, train=True)
tr_images = fmnist.data
tr_targets = fmnist.targets

(2) 修改获取数据的 FMNISTDataset 类,将输入图像除以 255 (最大像素强度值):

class FMNISTDataset(Dataset):def __init__(self, x, y):x = x.float() / 255.x = x.view(-1, 28*28)self.x, self.y = x, ydef __getitem__(self, ix):x, y = self.x[ix], self.y[ix]return x.to(device), y.to(device)def __len__(self):return len(self.x)

与上一小节相比,唯一需要修改的是将输入数据除以最大可能的像素值 (255),将它们除以 255 将得到介于 01 之间的值。

(3) 训练模型,首先获取数据、定义模型和用于训练和验证数据的数据,然后训练模型,最后绘制训练期间损失和准确率的变化:


def get_data():train = FMNISTDataset(tr_images, tr_targets)trn_dl = DataLoader(train, batch_size=32, shuffle=True)return trn_dltrn_dl = get_data()
model, loss_fn, optimizer = get_model()losses, accuracies = [], []
for epoch in range(10):print(epoch)epoch_losses, epoch_accuracies = [], []for ix, batch in enumerate(iter(trn_dl)):x, y = batchbatch_loss = train_batch(x, y, model, optimizer, loss_fn)epoch_losses.append(batch_loss)epoch_loss = np.array(epoch_losses).mean()for ix, batch in enumerate(iter(trn_dl)):x, y = batchis_correct = accuracy(x, y, model)epoch_accuracies.extend(is_correct)epoch_accuracy = np.mean(epoch_accuracies)losses.append(epoch_loss)accuracies.append(epoch_accuracy)epochs = np.arange(10)+1
import matplotlib.pyplot as plt
plt.figure(figsize=(20,5))
plt.subplot(121)
plt.title('Loss value over increasing epochs')
plt.plot(epochs, losses, label='Training Loss')
plt.legend()
plt.subplot(122)
plt.title('Accuracy value over increasing epochs')
plt.plot(epochs, accuracies, label='Training Accuracy')
plt.gca().set_yticklabels(['{:.0f}%'.format(x*100) for x in plt.gca().get_yticks()]) 
plt.legend()
plt.show()

损失和准确率随时间的变化情况

如上图所示,训练损失不断减少,训练准确率不断提高,可以将准确率提高到约 85%

接下来,我们将了解缩放数据集能使神经网络性能更好的原因。假设输入数据未缩放,以计算 sigmoid 值为例:

输入权重偏置sigmoid 值
2550.0100.93
2550.101.00
2550.201.00
2550.401.00
2550.801.00
2551.601.00
2553.201.00
2556.401.00

在上表中,即使权重值在 0.016.4 之间变化,在经过函数 Sigmoid 后输出变化也不大。Sigmoid 函数的计算公式如下:
o u t p u t = 1 1 + e − ( w ∗ x + b ) output = \frac1 {1+e^{-(w*x + b)}} output=1+e(wx+b)1
其中 w w w 是权重, x x x 是输入, b b b 是偏置值。Sigmoid 输出不变的原因是由于 w ∗ x w*x wx 的乘积很大(因为 x x x 较大),导致 Sigmoid 值始终落在 Sigmoid 曲线的饱和部分中( Sigmoid 曲线的右上角或左下角的值称为饱和部分)。
如果我们将不同的权重值乘以一个较小的输入数字,如下所示:

输入权重偏置sigmoid 值
10.0100.50
10.100.52
10.200.55
10.400.60
10.800.69
11.600.83
13.200.96
16.401.00

由于输入值较小,因此上表中的 Sigmoid 输出的变化幅度较大。通过此示例,我们了解了缩放输入对数据集的影响,当权重(假设权重不具有较大范围)乘以输入值时,产生的值范围空间并不会突变,从而使输入数据能够对输出产生足够重要的影响。
当权重值也很大时,输入值对输出的影响也将变得不太重要。因此,我们一般将权重值初始化为更接近零的较小数值。同时,为了获得最佳的权重值,通常设置初始权重的范围变化不大,比如权重初始化为介于 -1+1 之间的随机值。

4. 修改优化器

不同优化器同样可能会影响模型学习拟合输入和输出的速度,在本节中,将了解修改优化器对模型准确性的影响。为了便于比较随机梯度下降( Stochastic Gradient Descent, SGD )和 Adam 在更多 epoch 上的性能,将 epoch 修改为 20

(1) 修改优化器,在 get_model() 函数中使用 SGD 优化器,同时确保其他设定保持不变:

from torch.optim import SGD, Adam
def get_model():model = nn.Sequential(nn.Linear(28 * 28, 1000),nn.ReLU(),nn.Linear(1000, 10)).to(device)loss_fn = nn.CrossEntropyLoss()optimizer = SGD(model.parameters(), lr=1e-2)return model, loss_fn, optimizer

(2) 增加训练模型的 epoch 数:

trn_dl, val_dl = get_data()
model, loss_fn, optimizer = get_model()train_losses, train_accuracies = [], []
val_losses, val_accuracies = [], []
for epoch in range(20):print(epoch)train_epoch_losses, train_epoch_accuracies = [], []for ix, batch in enumerate(iter(trn_dl)):x, y = batchbatch_loss = train_batch(x, y, model, optimizer, loss_fn)train_epoch_losses.append(batch_loss) train_epoch_loss = np.array(train_epoch_losses).mean()for ix, batch in enumerate(iter(trn_dl)):x, y = batchis_correct = accuracy(x, y, model)train_epoch_accuracies.extend(is_correct)train_epoch_accuracy = np.mean(train_epoch_accuracies)for ix, batch in enumerate(iter(val_dl)):x, y = batchval_is_correct = accuracy(x, y, model)validation_loss = val_loss(x, y, model, loss_fn)val_epoch_accuracy = np.mean(val_is_correct)train_losses.append(train_epoch_loss)train_accuracies.append(train_epoch_accuracy)val_losses.append(validation_loss)val_accuracies.append(val_epoch_accuracy)epochs = np.arange(20)+1
import matplotlib.ticker as mtick
import matplotlib.ticker as mticker
plt.subplot(121)
plt.plot(epochs, train_losses, 'bo', label='Training loss')
plt.plot(epochs, val_losses, 'r', label='Validation loss')
plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(1))
plt.title('Training and validation loss with SGD optimizer')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.grid('off')
plt.subplot(122)
plt.plot(epochs, train_accuracies, 'bo', label='Training accuracy')
plt.plot(epochs, val_accuracies, 'r', label='Validation accuracy')
plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(1))
plt.title('Training and validation accuracy with SGD optimizer')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.gca().set_yticklabels(['{:.0f}%'.format(x*100) for x in plt.gca().get_yticks()]) 
plt.legend()
plt.grid('off')
plt.show()

进行这些更改后,优化器为 SGD 时,训练和验证数据集上的准确率和损失的变化如下所示:

准确率和损失的变化

在优化器为 Adam 时,训练和验证数据集上的准确率和损失值的变化如下:

准确率和损失的变化

与其他优化器相比,Adam 通常优化器可以更快地实现最佳准确率,其他一些可用的优化器包括 AdagradAdadeltaAdamWLBFGSRMSprop

5. 构建深层神经网络

到目前为止,我们构建的神经网络架构只有一个隐藏层。在本节中,我们将对比具有两个隐藏层和没有隐藏层的神经网络模型的性能。

(1) 构建包含两层隐藏层的神经网络模型:

def get_model():model = nn.Sequential(nn.Linear(28 * 28, 1000),nn.ReLU(),nn.Linear(1000, 512),nn.ReLU(),nn.Linear(512, 10)).to(device)loss_fn = nn.CrossEntropyLoss()optimizer = Adam(model.parameters(), lr=1e-3)return model, loss_fn, optimizer

(2) 类似地,修改 get_model() 函数构建不含隐藏层的神经网络,将输入直接连接到输出层:

from torch.optim import SGD, Adam
def get_model():model = nn.Sequential(nn.Linear(28 * 28, 10)).to(device)loss_fn = nn.CrossEntropyLoss()optimizer = Adam(model.parameters(), lr=1e-3)return model, loss_fn, optimizer

训练和验证数据集的准确率和损失变化如下所示:

训练和验证数据集的准确率和损失变化

从以上结果可以看出:

  • 当没有隐藏层时,模型无法学习
  • 与一个隐藏层相比,当有两个隐藏层时,模型的过拟合会更严重

深度神经网络意味着在输入层和输出层间存在多个隐藏层。多个隐藏层确保神经网络可以学习输入和输出之间的复杂非线性关系,而简单的神经网络则无法完成这样的需求(由于隐藏层数量有限)。

小结

神经网络性能优化技术是指通过改进神经网络的结构、参数初始化、正则化和训练过程等方面来提高其性能和泛化能力的方法。本节首先训练了一个简单的全连接网络,然后在此基础上介绍了简单有效的神经网络性能提升技巧,在之后的学习中,还将进一步介绍包括批归一化、动态学习率等常见技术。

系列链接

PyTorch深度学习实战(1)——神经网络与模型训练过程详解
PyTorch深度学习实战(2)——PyTorch基础
PyTorch深度学习实战(3)——使用PyTorch构建神经网络
PyTorch深度学习实战(4)——常用激活函数和损失函数详解
PyTorch深度学习实战(5)——计算机视觉基础

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

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

相关文章

C#之事件

目录 一、发布者和订阅者 (一)概述 (二)有关事件的重要事项 (三)有关事件的私有委托需要了解的重要事项 二、源代码组件概览 三、声明事件 事件是成员 四、订阅事件 五、触发事件 六、标准事件的…

【Zerotier】通过docker自建PLANET服务器

在如今全球互联的时代,我们对于互联网的依赖程度越来越高。然而,传统的网络连接方式在某些情况下可能会受到一些限制,例如局域网的范围限制、防火墙的阻断或者设备所处的多层NAT等。但是,现在有一个名为ZeroTier的工具出现了&…

【C语言进阶】文件操作

🔥博客主页:小王又困了 📚系列专栏:C语言 🌟人之为学,不日近则日退 ❤️感谢大家点赞👍收藏⭐评论✍️ 目录 一、什么是文件 1.1程序文件 1.2数据文件 1.3文件名 二、文件的打开和关闭 2…

银河麒麟服务器v10 sp1 nginx 部署项目

上一篇:银河麒麟服务器v10 sp1 nginx开机自动启动_csdn_aspnet的博客-CSDN博客 由于项目为前后端分离,前端项目使用nginx部署,VUE项目打包后上传至银河麒麟服务器: 8063 为前端项目文件目录,修改配置 ,默认…

脑电信号处理与特征提取——三. 脑电实验设计的原理与实例(古若雷)

三、脑电实验设计的原理与实例 被试间设计的实验结果也有可能是人员不同造成的,所以建议被试内设计。

双端队列(deque)与优先队列(priority_queue)

文章目录 一.双端队列——deque1.deque的优点与缺点2.deque的原理 二.优先队列——priority_queue1.什么是优先队列?2.优先队列的基本使用3.什么是仿函数?4.优先队列的模拟实现 一.双端队列——deque 在上一章stack、queue的模拟实现中,我们…

Mysql 数据库开发及企业级应用

文章目录 1、Mysql 数据库开发及企业级应用1.1、为什么要使用数据库1.1.1、数据库概念(Database)1.1.2、为什么需要数据库 1.2、程序员为什么要学习数据库1.3、数据库的选择1.3.1、主流数据库简介1.3.2、使用 MySQL 的优势1.3.3、版本选择 1.4、Windows …

【VUE】解决图片视频加载缓慢/首屏加载白屏的问题

1 问题描述 在 Vue3 项目中,有时候会出现图片视频加载缓慢、首屏加载白屏的问题 2 原因分析 通常是由以下原因导致的: 图片或视频格式不当:如果图片或视频格式选择不当,比如选择了无损压缩格式,可能会导致文件大小过大…

unity 控制text根据字数自动扩展大小,并扩展UI背景

需求:文字内容位置保持不变,向下增加,背景框随之同步扩展。 1.UGUI 九宫格 拉伸 对背景框图片资源处理,避免图片拉伸。 (10条消息) unity UGUI 九宫格 拉伸_unity九宫格拉伸_野区捕龙为宠的博客-CSDN博客 2.背景框添加组件 3.…

php裁剪图片,并给图片加上水印

本次以裁剪四个图片为例,图片如下 代码如下 public function cutImg($imgUrl){try{// 读取原始图片$src_img imagecreatefromjpeg($imgUrl);// 获取原始图片的宽度和高度$src_width imagesx($src_img);$src_height imagesy($src_img);// 计算每个部分的宽度和高…

【数字信号处理】带通采样定理及其MATLAB仿真

目录 一、带通采样定理1.1 内容1.2 公式推导 二、MATLAB信号仿真2.1 信号仿真实验2.2 MATLAB代码 三、总结参考 一、带通采样定理 按照奈奎斯特采样定理(低通采样),采样频率 f s f_{s} fs​ 要大于等于信号中最高频率 f m a x f_{max} fmax​ 的2倍,才…

C++OpenCV(2):图像处理基础概念与操作

🔆 文章首发于我的个人博客:欢迎大佬们来逛逛 🔆 OpenCV项目地址及源代码:点击这里 文章目录 图形读取与显示加载图片显示图片打印图片信息保存图片 色彩模型转换RGB颜色模型HSV颜色模型HLS模型LAB模型 图像像素读写操作像素算数运…

macOS 源码编译 qpress

╰─➤ git clone https://github.com/PierreLvx/qpress.git ╰─➤ cd qpress ╰─➤ make g -O3 -o qpress -x c quicklz.c -x c qpress.cpp aio.cpp utilities.cpp -lpthread -Wall -Wextra -Werror ╰─➤ sudo make install …

怎么快速定位bug?怎么编写测试用例?

目录 01定位问题的重要性 02问题定位技巧 03初次怎么写用例 作为一名测试人员如果连常见的系统问题都不知道如何分析,频繁将前端人员问题指派给后端人员,后端人员问题指派给前端人员,那么在团队里你在开发中的地位显而易见 ,口碑…

垃圾回收标记阶段算法

1.标记阶段的目的 主要是在GC在前,判断出哪些是有用的对象,哪些是需要回收的对象,只有被标记为垃圾对象,GC才会对其进行垃圾回收。判断对象是否为垃圾对象的两种方式:引用计数算法和可达性分析算法。 2.引用计数算法…

如何搭建使用dubbo-Admin?

dubbo-Admin介绍 一款用于dubbo可视化界面操作的管理平台 dubbo-Admin特点 dubbo-Admin是dubbo的管理界面平台,且是一个前后端分离的项目,前端使用vue,后端使用springboot。 软件下载 dubbo-admin-0.5.0.zip 软件使用

会议OA项目之会议审批(亮点功能:将审批人签名转换为电子手写签名图片)

🥳🥳Welcome Huihuis Code World ! !🥳🥳 接下来看看由辉辉所写的关于OA项目的相关操作吧 目录 🥳🥳Welcome Huihuis Code World ! !🥳🥳 一.主要功能点介绍 二.效果展示 三.前端…

MongoDB 的日常使用

一、简介 1、 常见的数据库分类 RDBMS(关系型数据库):常见的关系型数据库有 Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL; NoSQL(非关系型数据库):常见的非关系型数据库有 …

thinkphp实现无限分类(使用递归)

thinkphp实现无限分类(使用递归) 本文实例为大家分享了thinkphp实现无限分类的详细代码,希望对大家学习无限分类有所启发。 数据库:test 数据表:(tp_category): Common/conf/conf…

在VSCode中实现Rust编程调试指南

在 VS Code 中调试 Rust:终极指南 在本教程中,您将学习如何使用 VS Code 调试 Rust。可用于使用 VS Code 调试 Rust 的操作。设置 VS Code 来调试 Rust Rust因其易用性、安全性和高性能而继续保持其作为最受欢迎的编程语言的地位。随着 Rust 的流行&…