【动手学深度学习】使用块的网络(VGG)的研究详情

目录

🌊1. 研究目的

🌊2. 研究准备

🌊3. 研究内容

🌍3.1 多层感知机模型选择、欠拟合和过拟合

🌍3.2 练习

🌊4. 研究体会


🌊1. 研究目的

  • 理解块的网络结构;
  • 比较块的网络与传统浅层网络的性能差异;
  • 探究块的网络深度与性能之间的关系;
  • 研究块的网络在不同任务上的适用性。

🌊2. 研究准备

  • 根据GPU安装pytorch版本实现GPU运行研究代码;
  • 配置环境用来运行 Python、Jupyter Notebook和相关库等相关库。

🌊3. 研究内容

启动jupyter notebook,使用新增的pytorch环境新建ipynb文件,为了检查环境配置是否合理,输入import torch以及torch.cuda.is_available() ,若返回TRUE则说明研究环境配置正确,若返回False但可以正确导入torch则说明pytorch配置成功,但研究运行是在CPU进行的,结果如下:


🌍3.1 使用块的网络(VGG)

(1)使用jupyter notebook新增的pytorch环境新建ipynb文件,完成基本数据操作的研究代码与练习结果如下:

VGG块

import torch
from torch import nn
from d2l import torch as d2ldef vgg_block(num_convs, in_channels, out_channels):layers = []for _ in range(num_convs):layers.append(nn.Conv2d(in_channels, out_channels,kernel_size=3, padding=1))layers.append(nn.ReLU())in_channels = out_channelslayers.append(nn.MaxPool2d(kernel_size=2,stride=2))return nn.Sequential(*layers)

VGG网络

conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))def vgg(conv_arch):conv_blks = []in_channels = 1# 卷积层部分for (num_convs, out_channels) in conv_arch:conv_blks.append(vgg_block(num_convs, in_channels, out_channels))in_channels = out_channelsreturn nn.Sequential(*conv_blks, nn.Flatten(),# 全连接层部分nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),nn.Linear(4096, 10))net = vgg(conv_arch)X = torch.randn(size=(1, 1, 224, 224))
for blk in net:X = blk(X)print(blk.__class__.__name__,'output shape:\t',X.shape)

训练模型

ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)lr, num_epochs, batch_size = 0.05, 10, 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())


🌍3.2 练习

1.打印层的尺寸时,我们只看到8个结果,而不是11个结果。剩余的3层信息去哪了?

在VGG网络中,最后三个全连接层(nn.Linear)的输出尺寸没有被打印出来。这是因为在for循环中,只遍历了卷积层部分的模块,而没有遍历全连接层部分的模块。

为了打印出全连接层的输出尺寸,可以将全连接层的模块添加到一个列表中,然后在遍历网络的时候也打印出这些模块的输出尺寸。以下是修改后的代码:

import torch
import torch.nn as nn# 定义 VGG 模型
def vgg(conv_arch):layers = []in_channels = 1for c, num_convs in conv_arch:layers.append(nn.Sequential(nn.Conv2d(in_channels, c, kernel_size=3, padding=1),nn.ReLU()))in_channels = cfor _ in range(num_convs - 1):layers.append(nn.Sequential(nn.Conv2d(c, c, kernel_size=3, padding=1),nn.ReLU()))layers.append(nn.MaxPool2d(kernel_size=2, stride=2))return nn.Sequential(*layers)conv_arch = ((1, 1), (2, 2), (4, 2), (8, 2), (16, 2))net = vgg(conv_arch)X = torch.randn(size=(1, 1, 224, 224))
for blk in net:X = blk(X)print(blk.__class__.__name__, 'output shape:\t', X.shape)# 获取卷积层的输出尺寸
_, channels, height, width = X.shape# 添加全连接层模块到列表中
fc_layers = [nn.Flatten(),nn.Linear(channels * height * width, 4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096, 4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096, 10)
]net = nn.Sequential(*net, *fc_layers)# 打印全连接层的输出尺寸
for blk in fc_layers:X = blk(X)print(blk.__class__.__name__, 'output shape:\t', X.shape)

2.与AlexNet相比,VGG的计算要慢得多,而且它还需要更多的显存。分析出现这种情况的原因。
VGG相对于AlexNet而言,计算速度更慢、显存需求更高的主要原因如下:

  • 更深的网络结构: VGG网络相比AlexNet更深,它使用了更多的卷积层和全连接层。VGG的网络结构包含了多个连续的卷积层,导致了参数的数量增加和计算量的增加。相对于AlexNet的8层网络,VGG网络有16或19层,这导致了更多的计算和内存消耗。
  • 小尺寸的卷积核: VGG网络使用了较小的卷积核(3x3大小),而AlexNet则使用了更大的卷积核(11x11和5x5大小)。较小的卷积核意味着每个卷积层需要进行更多次的卷积运算来覆盖相同的感受野,从而增加了计算量。
  • 更多的参数: VGG网络具有更多的参数量。由于每个卷积层都使用了较小的卷积核,导致了更多的卷积核参数。此外,由于网络更深,全连接层的参数数量也更多。更多的参数需要更多的内存来存储,并且在计算过程中需要更多的计算量。
  • 更高的内存需求: VGG网络的深度和参数量的增加导致了更高的内存需求。在训练过程中,需要存储每一层的输出、梯度和参数,这会消耗大量的显存。较大的显存需求可能导致无法一次性加载更多的数据和模型,从而导致更多的显存读写操作和内存碎片化,进而影响计算速度。

3.尝试将Fashion-MNIST数据集图像的高度和宽度从224改为96。这对实验有什么影响?
将Fashion-MNIST数据集图像的高度和宽度从224改为96会对实验产生以下影响:

  • 模型性能下降: 缩小图像尺寸会导致图像的信息丢失和细节损失。VGG网络在设计时使用了较大的输入尺寸,以便更好地捕捉图像的细节和纹理。通过将图像尺寸缩小为96x96,模型可能无法有效地捕捉到原始图像中的细微特征,从而导致性能下降。
  • 空间分辨率减小: 图像尺寸从224x224缩小到96x96会导致空间分辨率的减小。较小的图像尺寸意味着每个像素代表的区域更大,图像中的细节信息被压缩。这可能会导致模型在进行物体边界检测、纹理识别等任务时表现不佳。
  • 减少计算和内存需求: 缩小图像尺寸可以减少模型的计算和内存需求。较小的输入图像尺寸意味着每个卷积层的特征图大小也会减小,从而减少了参数数量和计算量。此外,由于特征图大小减小,模型所需的内存也会相应减少。
  • 训练速度加快: 缩小图像尺寸可以加快训练速度。较小的输入图像尺寸意味着每个批次的数据量减少,从而减少了每个训练步骤的计算量和内存消耗。这可能导致更快的训练速度和更高的训练效率。
import torch
from torch import nn
from torchvision.transforms import ToTensor
from torchvision.datasets import FashionMNIST
from torch.utils.data import DataLoader# 定义VGG块
def vgg_block(num_convs, in_channels, out_channels):layers = []for _ in range(num_convs):layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))layers.append(nn.ReLU())in_channels = out_channelslayers.append(nn.MaxPool2d(kernel_size=2, stride=2))return nn.Sequential(*layers)# 定义VGG网络
class VGG(nn.Module):def __init__(self, conv_arch):super(VGG, self).__init__()self.conv_blocks = nn.Sequential()in_channels = 1for i, (num_convs, out_channels) in enumerate(conv_arch):self.conv_blocks.add_module(f'vgg_block{i+1}', vgg_block(num_convs, in_channels, out_channels))in_channels = out_channelsself.fc_layers = nn.Sequential(nn.Linear(out_channels * 3 * 3, 4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096, 4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096, 10))def forward(self, x):x = self.conv_blocks(x)x = torch.flatten(x, start_dim=1)x = self.fc_layers(x)return x# 将Fashion-MNIST图像尺寸缩小为96x96
transform = ToTensor()
train_dataset = FashionMNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = FashionMNIST(root='./data', train=False, download=True, transform=transform)# 创建数据加载器
batch_size = 128
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)# 定义VGG网络结构
conv_arch = [(1, 64), (1, 128), (2, 256), (2, 512), (2, 512)]
model = VGG(conv_arch)# 训练和测试
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.SGD(model.parameters(), lr=0.05)
criterion = nn.CrossEntropyLoss()def train(model, train_loader, optimizer, criterion, device):model.train()train_loss = 0.0train_acc = 0.0for images, labels in train_loader:images = images.to(device)labels = labels.to(device)optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)train_acc += torch.sum(preds == labels.data).item()train_loss /= len(train_loader.dataset)train_acc /= len(train_loader.dataset)return train_loss, train_accdef test(model, test_loader, criterion, device):model.eval()test_loss = 0.0test_acc = 0.0with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)loss = criterion(outputs, labels)test_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)test_acc += torch.sum(preds == labels.data).item()test_loss /= len(test_loader.dataset)test_acc /= len(test_loader.dataset)return test_loss, test_acc# 训练模型
num_epochs = 10
for epoch in range(num_epochs):train_loss, train_acc = train(model, train_loader, optimizer, criterion, device)test_loss, test_acc = test(model, test_loader, criterion, device)print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, 'f'Test Loss: {test_loss:.4f}, Test Accuracy: {test_acc:.4f}')# 输出样例
print("Sample outputs:")
model.eval()
with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)_, preds = torch.max(outputs, 1)for i in range(images.size(0)):print(f"Predicted: {preds[i].item()}, Ground Truth: {labels[i].item()}")break  # 只输出一个批次的样例结果

在上面的代码中,定义了VGG网络结构,并在Fashion-MNIST数据集上进行了训练和测试。通过将图像尺寸从224缩小为96,可以看到模型的训练和推理速度可能会加快,但模型的性能可能会下降,因为图像的细节被压缩。这里使用了SGD优化器和交叉熵损失函数来训练模型,并输出了训练和测试的损失和准确率。最后输出了一个样例的预测结果,以查看模型的输出效果。请注意,实际训练过程可能需要更多的迭代次数和调整超参数以获得更好的性能。

4.请参考VGG论文 (Simonyan and Zisserman, 2014)中的表1构建其他常见模型,如VGG-16或VGG-19。
VGG-16:

import torch
from torch import nn
from torchvision.transforms import ToTensor
from torchvision.datasets import FashionMNIST
from torch.utils.data import DataLoader# 定义VGG块
def vgg_block(num_convs, in_channels, out_channels):layers = []for _ in range(num_convs):layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))layers.append(nn.ReLU())in_channels = out_channelslayers.append(nn.MaxPool2d(kernel_size=2, stride=2))return nn.Sequential(*layers)# 定义VGG-16网络
class VGG16(nn.Module):def __init__(self):super(VGG16, self).__init__()self.conv_blocks = nn.Sequential(vgg_block(2, 3, 64),vgg_block(2, 64, 128),vgg_block(3, 128, 256),vgg_block(3, 256, 512),vgg_block(3, 512, 512))self.fc_layers = nn.Sequential(nn.Linear(512 * 7 * 7, 4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096, 10))def forward(self, x):x = self.conv_blocks(x)x = torch.flatten(x, start_dim=1)x = self.fc_layers(x)return x# 将Fashion-MNIST图像转换为Tensor,并进行数据加载
transform = ToTensor()
train_dataset = FashionMNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = FashionMNIST(root='./data', train=False, download=True, transform=transform)# 创建数据加载器
batch_size = 128
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)# 创建VGG-16模型实例
model = VGG16()# 定义优化器和损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.05)
criterion = nn.CrossEntropyLoss()# 将模型移动到GPU(如果可用)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)# 训练模型
num_epochs = 10
for epoch in range(num_epochs):model.train()train_loss = 0.0train_acc = 0.0for images, labels in train_loader:images = images.to(device)labels = labels.to(device)optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)train_acc += torch.sum(preds == labels.data).item()train_loss /= len(train_loader.dataset)train_acc /= len(train_loader.dataset)# 在测试集上评估模型model.eval()test_loss = 0.0test_acc = 0.0with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)loss = criterion(outputs, labels)test_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)test_acc += torch.sum(preds == labels.data).item()test_loss /= len(test_loader.dataset)test_acc /= len(test_loader.dataset)print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, 'f'Test Loss: {test_loss:.4f}, Test Accuracy: {test_acc:.4f}')# 输出样例
print("Sample outputs:")
model.eval()
with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)_, preds = torch.max(outputs, 1)for i in range(images.size(0)):print(f"Predicted: {preds[i].item()}, Ground Truth: {labels[i].item()}")break  # 只输出一个批次的样例结果

以上代码展示了包含数据加载和训练的完整代码,使用VGG-16模型对Fashion-MNIST数据集进行了训练和测试。训练过程中,模型在每个epoch中进行了训练和验证,并输出了训练和验证集上的损失和准确率。最后,展示了一个样例输出,显示了模型在测试集上的预测结果。

VGG-19:

import torch
from torch import nn
from torchvision.transforms import ToTensor
from torchvision.datasets import FashionMNIST
from torch.utils.data import DataLoader# 定义VGG块
def vgg_block(num_convs, in_channels, out_channels):layers = []for _ in range(num_convs):layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))layers.append(nn.ReLU())in_channels = out_channelslayers.append(nn.MaxPool2d(kernel_size=2, stride=2))return nn.Sequential(*layers)# 定义VGG-19网络
class VGG19(nn.Module):def __init__(self):super(VGG19, self).__init__()self.conv_blocks = nn.Sequential(vgg_block(2, 3, 64),vgg_block(2, 64, 128),vgg_block(4, 128, 256),vgg_block(4, 256, 512),vgg_block(4, 512, 512))self.fc_layers = nn.Sequential(nn.Linear(512 * 7 * 7, 4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096, 4096),nn.ReLU(True),nn.Dropout(),nn.Linear(4096, 10))def forward(self, x):x = self.conv_blocks(x)x = torch.flatten(x, start_dim=1)x = self.fc_layers(x)return x# 将Fashion-MNIST图像转换为Tensor,并进行数据加载
transform = ToTensor()
train_dataset = FashionMNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = FashionMNIST(root='./data', train=False, download=True, transform=transform)# 创建数据加载器
batch_size = 128
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)# 创建VGG-19模型实例
model = VGG19()# 定义优化器和损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.05)
criterion = nn.CrossEntropyLoss()# 将模型移动到GPU(如果可用)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)# 训练模型
num_epochs = 10
for epoch in range(num_epochs):model.train()train_loss = 0.0train_acc = 0.0for images, labels in train_loader:images = images.to(device)labels = labels.to(device)optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)train_acc += torch.sum(preds == labels.data).item()train_loss /= len(train_loader.dataset)train_acc /= len(train_loader.dataset)# 在测试集上评估模型model.eval()test_loss = 0.0test_acc = 0.0with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)loss = criterion(outputs, labels)test_loss += loss.item() * images.size(0)_, preds = torch.max(outputs, 1)test_acc += torch.sum(preds == labels.data).item()test_loss /= len(test_loader.dataset)test_acc /= len(test_loader.dataset)print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, 'f'Test Loss: {test_loss:.4f}, Test Accuracy: {test_acc:.4f}')# 输出样例
print("Sample outputs:")
model.eval()
with torch.no_grad():for images, labels in test_loader:images = images.to(device)labels = labels.to(device)outputs = model(images)_, preds = torch.max(outputs, 1)for i in range(images.size(0)):print(f"Predicted: {preds[i].item()}, Ground Truth: {labels[i].item()}")break  # 只输出一个批次的样例结果


🌊4. 研究体会

在本次实验中,我采用了块的网络结构,具体来说是VGG(Visual Geometry Group)网络,进行了深入的研究和分析。通过实验,我对使用块的网络的性能和优势有了更深刻的理解,并在不同任务上的适用性方面进行了探索。

首先,块的网络结构给予了深度神经网络更强大的特征提取能力。通过将多个卷积层和池化层堆叠在一起形成块的方式,块的网络能够逐层地提取出越来越抽象的特征信息。这种层次化的特征提取过程有助于网络更好地理解和表示输入数据,提高模型的分类准确率。在实验中的结果表明,相比传统的浅层网络,块的网络在处理复杂的视觉任务时表现出更好的性能。

其次,通过实验发现,块的网络的深度与性能之间存在一定的关系。逐渐增加块的数量可以增加网络的深度,但并不意味着性能一定会线性提升。实验中,我逐步增加了VGG网络的块数,并观察了模型的性能变化。结果显示,在增加块的数量初期,性能得到了显著提升,但随着深度继续增加,性能的改善趋于平缓,甚至有时会出现性能下降的情况。这表明网络深度的增加并不是无限制地提高性能的唯一因素,适当的模型复杂度和正则化方法也需要考虑。对块的网络在不同任务上的适用性进行了研究。通过在不同的数据集上进行训练和测试,我发现块的网络在图像分类、目标检测和语义分割等多个视觉任务中都表现出很好的性能。这表明块的网络具有较强的泛化能力和适应性,能够应用于多个领域和应用场景。这对于深度学习的研究和应用具有重要的启示意义,也为实际应用中的图像分析和理解提供了有力支持。

实验发现块的网络结构具有良好的模块化和复用性,使得网络的设计和调整变得更加灵活和高效。通过将相同的卷积层和池化层堆叠在一起形成块,我可以轻松地调整网络的深度和宽度,而不需要对每一层都进行单独设计和调整。这种模块化的结构使得网络的搭建和调试更加高效,节省了大量的时间和资源。

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

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

相关文章

Ansys的电磁场分析和系统电路仿真软件Electronics 2024 R1版本在Windows系统的下载与安装配置

目录 前言一、许可管理工具安装二、许可配置三、EM安装四、MCAD和帮助文件安装(可选择,非必要)总结 前言 “ ANSYS Electromagnetics Suite或ANSYS Electronics Suite是几个功能强大的程序的集合,用于仿真系统的电磁。ANSYS电磁套…

git 大文件上传失败 Please remove the file from history and try again.

根据提示执行命令 --- 查找到当前文件 git rev-list --objects --all | grep b24e74b34e7d482e2bc687e017c8ab28cd1d24b6git filter-branch --tree-filter rm -f 文件名 --tag-name-filter cat -- --all git push origin --tags --force git push origin --all --force

MySQL数据库数据恢复方案应对没有where误操作导致的大量数据更新或删除

😄 19年之后由于某些原因断更了三年,23年重新扬帆起航,推出更多优质博文,希望大家多多支持~ 🌷 古之立大事者,不惟有超世之才,亦必有坚忍不拔之志 🎐 个人CSND主页——Mi…

分享飞行棋夫妻互动游戏高阶版,揭秘夫妻飞行棋游戏玩法!

朋友们,今天我要给你们介绍一款超级甜蜜的小游戏——情侣飞行棋。别小看它,这可不是咱们小时候玩的那种,这是专门为咱们这些恩爱的小两口设计的,能让你们的感情在游戏中更加甜蜜蜜,擦出更多爱的火花。 准备好了吗&…

Spring AOP(实现,动态原理)详解版

Spring AOP 1.什么是AOP?1.1引入AOP依赖1.2编写AOP程序 2.Spring AOP核⼼概念2.1 切点(Pointcut)2.2连接点(Join Point)2.3通知(Advice)2.4 切⾯(Aspect) 3.通知类型3.1顺序3.2切⾯优先级 Order3.3 ⾃定义注解 MyAspect 4. Spring AOP 原理5 动态代理怎么实现5.1 JD…

Web后端开发(请求-简单参数)(一)

原始方式: 在原始的web程序中,获取请求参数,需要通过HttpServletRequest 对象手动获取。 RequestMapping("/simpleParam") public String simpleParam(HttpServletRequest request){//获取请求参数String name request.getParame…

html+CSS+js部分基础运用17

在图书列表中,为书名“零基础学JavaScript”和“HTML5CSS3精彩编程200例”添加颜色。(请用class或style属性实现),效果如下图1所示: 图1 图书列表 Class和style的综合应用。(1)应用class的对象、…

使用wireshark分析tcp握手过程

开启抓包 tcpdump -i any host 127.0.0.1 and port 123 -w tcp_capture.pcap 使用telnet模拟tcp连接 telnet 127.0.0.1 123 如果地址无法连接,则会一直重试SYN包,各个平台SYN重试间隔并不一致,如下: 异常站点抓包展示&#xff…

抽象的java入门1.3.0

前言: 在1.2.0版本中我们介绍了public class hello {}并从中提取出两个新概 修饰符和作用域 public class hello {public static void main(String[] args) {System.out.println("Hello World");} } 正片: 这一期把剩余的内容刨析出来 pub…

Python 机器学习 基础 之 【实战案例】轮船人员获救预测实战

Python 机器学习 基础 之 【实战案例】轮船人员获救预测实战 目录 Python 机器学习 基础 之 【实战案例】轮船人员获救预测实战 一、简单介绍 二、轮船人员获救预测实战 三、数据处理 1、导入数据 2、对缺失数据的列进行填充 3、属性转换,把某些列的字符串值…

【SkyWalking】启用apm-trace-ignore-plugin追踪忽略插件

背景 使用Agent采集追踪数据的时候,想排除某些路径,比如健康检查等,这样可以减少上报的数据,也可以去除一些不必要的干扰数据。 加载插件 在agent/optional-plugins目录中有个apm-trace-ignore-plugin-${version}.jar插件&…

WEB漏洞服务能提供哪些帮助

在数字化浪潮的推动下,Web应用程序已成为企业展示形象、提供服务、与用户进行交互的重要平台。然而,随着技术的飞速发展,Web应用程序中的安全漏洞也日益显现,成为网络安全的重大隐患。这些漏洞一旦被恶意攻击者利用,可…

AI高考大战,揭秘五大热门模型谁能问鼎数学之巅?

在高考前,我就有想法了,这一次让AI来做做高考题。就用国内的大模型,看哪家的大模型解题最厉害。 第一天考完,就拿到了2024高考数学2卷的电子版,这也是重庆市采用的高考试卷 这次选了5个AI工具,分别是天工&a…

Fatfs

STM32进阶笔记——FATFS文件系统(上)_stm32 fatfs-CSDN博客 STM32进阶笔记——FATFS文件系统(下)_stm32 文件系统怎样获取文件大小-CSDN博客 STM32——FATFS文件基础知识_stm32 fatfs-CSDN博客 021 - STM32学习笔记 - Fatfs文件…

React -- memo允许你的组件在 props 没有改变的情况下跳过重新渲染。

memo(Component, arePropsEqual?) 使用 memo 将组件包装起来,以获得该组件的一个 记忆化 版本。通常情况下,只要该组件的 props 没有改变,这个记忆化版本就不会在其父组件重新渲染时重新渲染。但 React 仍可能会重新渲染它:记忆化…

java 大型企业MES生产管理系统源码:MES系统与柔性化产线控制系统的关系、作用

MES定义为“位于上层的计划管理系统与底层的工业控制之间的面向车间层的管理信息系统”,它为操作人员/管理人员提供计划的执行、跟踪以及所有资源(人、设备、物料、客户需求等)的当前状态。 MES系统与柔性化产线控制系统的关系 MES(制造执行系统)是一种…

离散数学---树

目录 1.基本概念及其相关运用 2.生成树 3.有向树 4.最优树 5.前缀码 1.基本概念及其相关运用 (1)无向树:连通而且没有回路的无向图就是无向树; 森林就是有多个连通分支,每个连通分支都是树的无连通的无向图&…

pytorch构建模型训练数据集

pytorch构建模型训练数据集 pytorch构建模型训练数据集1.AlexNet:1.1.导入必要的库:1.2.数据预处理和增强:1.3.加载数据集:1.4.划分测试集和训练集:1.5.创建数据加载器:1.6.加载AlexNet模型:1.7.修改模型以…

训练营第三十一天 | 494.目标和474.一和零动态规划:完全背包理论基础518.零钱兑换II

494.目标和 力扣题目链接(opens new window) 难度:中等 给定一个非负整数数组,a1, a2, ..., an, 和一个目标数,S。现在你有两个符号 和 -。对于数组中的任意一个整数,你都可以从 或 -中选择一个符号添加在前面。 返回可以使…

mysql当前状态分析(show status)

文章目录 查看当前线程数据查询连接情况查询缓存相关查询锁相关查询增删改查执行次数查询DDL创建相关 SHOW STATUS 是一个在 MySQL 中用来查看服务器运行状态的命令。它可以帮助你了解服务器的当前性能,包括连接数、表锁定、缓冲区使用情况等信息。 查看当前线程数据…