深度学习--CNN应用--VGG16网络和ResNet18网络

前言

我们在学习这两个网络时,应先了解CNN网络的相关知识

深度学习--CNN卷积神经网络(附图)-CSDN博客

这篇博客能够帮我们更好的理解VGG16和RetNet18

1.VGG16

1.1 VGG简介

VGG论文网址:VGG论文

大家有兴趣的可以去研读一下。

首先呢,我们先简单了解一下VGG网络的来源

自2012年AlexNet在lmageNet图片分类比赛中大获成功以来,关于深度神经网络的研究又一次如火如茶般进行;
VGGNet 是由牛津大学视觉几何小组 (Visual Geometry Group,VGG)提出的一种深层卷积网络结构,他们以 7.32% 的错误率赢得了 2014年 ILSVRC 分类任务的亚军(冠军由 GoogLeNet 以 6.65% 的错误率夺得)
AlexNet的网络结构来提高自己的准确率,主要有两个方向:小卷积核和多尺度。而VGG的作者们则选择了另外一个方向,即加深网络深度

VGG网络有一个特点:在每一次池化之后,经过卷积通道数都会翻倍,这样呢,就可以保留更多的特征。

1.2 VGG模型

最上面我们可以看出VGG共有6中配置,分别为A,A-LRN,B,C,D,E,其中D和E两种最为常用,即我们所说的VGG16和VGG19。 

而我们今天要学习的主要是D,即VGG16

下面是模型参数

这样看可能有点抽象,让我们结合下面的图片进行理解

我们结合图片对表进行理解:

“Weight layers” 在深度学习和神经网络的上下文中,通常指的是神经网络中的权重层。在神经网络中,每一层(无论是卷积层、全连接层还是其他类型的层)都有与之关联的权重矩阵(或权重张量,对于卷积层而言)。16Weight layers是指卷积层加上连接层共有16层,也就是对应着16个权重层。

con3-aaa,卷积层全部都是3*3的卷积核,用上图中conv3-aaa表示,xxx表示通道数。其步长为1,用padding=same填充。池化层的池化核为2*2

maxpool :是指最大池化,在这里,pooling采用的是2*2的最大池化方法

FC-aaaa:指的是全连接层中有aaaa个节点

通俗地说,就是两组:两个卷积层接上一个池化层,

三组:三个卷积层接一个池化层,

最后是三个全连接层接上一个归一化处理,

这里的每一个卷积层和连接层后都要加上ReLu激活函数。

这样,我们对VGG16论文中的两个表格以及VGG16的框架就大体了解完了,接下来我们就具体分析它们,然后用代码实现它。

1.2.1 通道数

我们可以看出,初始的图片经过卷积层和池化层的处理,通道数在不断增加,有最开始输入的3个,变为了512个,再到4096个,最终的1000是指分类的类别数为1000个。

我们先要理解通道数指的是什么:通道数指的是同时处理的并发任务数量。

也就是说,通道数越多,同时处理的并发任务数量也就越多,

这样的好处也有很多,比如:

  1. 提高并发性:通过增加通道数,可以同时处理更多的任务,从而提高程序的并发性。这对于需要同时处理多个请求或任务的应用程序非常有用,例如网络服务器、数据处理等。

  2. 提高性能:增加通道数可以充分利用计算资源,提高程序的处理能力和响应速度。当程序中存在大量的IO操作时,通过增加通道数可以减少IO等待时间,提高整体性能。

  3. 提高资源利用率:通过增加通道数,可以更好地利用系统资源,充分发挥多核处理器的并行计算能力。这对于需要处理大量数据或计算密集型任务的应用程序非常有益。

  4. 支持高并发场景:在一些需要处理大量并发请求的场景下,增加通道数可以有效地提高系统的吞吐量和响应能力。例如,在Web服务器中,通过增加通道数可以同时处理更多的客户端请求,提供更好的用户体验。

1.2.3 最大池化层

通过最大池化层时,我们将池化层的大小和步长都设为2,这样可以将特征图的长和宽减半

不用多说,这样也有很多好处:

1. 降维与减少冗余信息:池化层通过下采样操作,有效地减少了特征图的维度,从而降低了数据的冗余性。这对于后续的卷积层或全连接层来说,可以显著减少计算量和内存消耗。
2. 扩大感知野:池化操作使得后续的卷积层能够看到更大范围的输入信息,即提高了网络的感知野。这有助于捕捉全局特征和上下文信息,从而增强网络的特征提取能力。
3. 防止过拟合:通过减少特征图的尺寸和参数数量,池化层有助于防止模型在训练过程中出现过拟合现象。过拟合是指模型在训练数据上表现良好,但在未见过的数据上性能较差的情况。
4. 提高鲁棒性:池化操作,尤其是最大池化,能够提取出输入中最显著的特征,对于输入中的微小变化(如平移、旋转或尺度变化)具有一定的不变性。这使得模型对于不同的输入变化更为鲁棒。
5. 加速计算:由于池化层减少了特征图的尺寸,后续的卷积或全连接层的计算量也会相应减少,从而提高了整体的计算速度。 

1.2.4 ReLu函数

我们通过ReLu函数进行非线性激活,并且inplace选择了True,这样可以大大减少VGG16模型所需要的内存

下面,我们就尝试用代码实现CNN网络 

1.3 核心代码

import torch.nn
class VGG16(torch.nn.Module):def __init__(self):super(VGG16, self).__init__()self.conv1 = torch.nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1)self.relu1 = torch.nn.ReLU(inplace=True)self.conv2 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)self.relu2 = torch.nn.ReLU(inplace=True)self.maxpl1 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv3 = torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)self.relu3 = torch.nn.ReLU(inplace=True)self.conv4 = torch.nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)self.relu4 = torch.nn.ReLU(inplace=True)self.maxpl2 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv5 = torch.nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)self.relu5 = torch.nn.ReLU(inplace=True)self.conv6 = torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)self.relu6 = torch.nn.ReLU(inplace=True)self.conv7 = torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)self.relu7 = torch.nn.ReLU(inplace=True)self.maxpl3 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv8 = torch.nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)self.relu8 = torch.nn.ReLU(inplace=True)self.conv9 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu9 = torch.nn.ReLU(inplace=True)self.conv10 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu10 = torch.nn.ReLU(inplace=True)self.maxpl4 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv11 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu11 = torch.nn.ReLU(inplace=True)self.conv12 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu12 = torch.nn.ReLU(inplace=True)self.conv13 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu13 = torch.nn.ReLU(inplace=True)self.maxpl5 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.fc1 = torch.nn.Linear(7*7*512, 4096)self.relu14 = torch.nn.ReLU(inplace=True)self.fc2 = torch.nn.Linear(4096, 4096)self.relu15 = torch.nn.ReLU(inplace=True)self.dropout = torch.nn.Dropout()self.fc3 = torch.nn.Linear(4096, 1000)def forward(self, x):x = self.conv1(x)x = self.relu1(x)x = self.conv2(x)x = self.relu2(x)x = self.maxpl1(x)x = self.conv3(x)x = self.relu3(x)x = self.conv4(x)x = self.relu4(x)x = self.maxpl2(x)x = self.conv5(x)x = self.relu5(x)x = self.conv6(x)x = self.relu6(x)x = self.conv7(x)x = self.relu7(x)x = self.maxpl3(x)x = self.conv8(x)x = self.relu8(x)x = self.conv9(x)x = self.relu9(x)x = self.conv10(x)x = self.relu10(x)x = self.maxpl4(x)x = self.conv11(x)x = self.relu11(x)x = self.conv12(x)x = self.relu12(x)x = self.conv13(x)x = self.relu13(x)x = self.maxpl5(x)x = x.view(-1,7*7*512)x = self.fc1(x)x = self.relu14(x)x = self.fc2(x)x = self.relu15(x)x = self.fc3(x)return x

 注意:

在实现全连接层之前,我们需要用view将x展平 原理如下:

1.4 实战实现猫狗数据集分类

1.4.1代码

import torch.nn
from PIL import Image                   # 这行代码从Pillow库中导入了Image模块,它提供了许多用于打开、操作和保存图像的函数。
import numpy as np
from torch.utils.data import Dataset    # Dataset类是torch.utils.data模块中的一个抽象类,用于表示一个数据集
from torchvision import transforms
import os                               # os模块提供了与操作系统交互的函数,例如读取目录内容、检查文件是否存在等。
import torch
import matplotlib.pyplot as plt
import matplotlib
#设置字体为楷体
matplotlib.rcParams['font.sans-serif'] = ['KaiTi']# 自定义数据集
class mydataset(Dataset):def __init__(self,root_dir,lable_dir):self.root_dir=root_dir      # 文件主路径dataset/trainself.label_dir=lable_dir    # 分路径 cat 和 dogself.path=os.path.join(self.root_dir,self.label_dir)  # 将文件路径的两部分连接起来self.img_path=os.listdir(self.path)     # 查看self.transform = transforms.Compose([   # 包含:transforms.Resize((224,224)),       # 统一大小为224*224transforms.ToTensor()               # 转化为Tensor类型])def __len__(self):ilen=len(self.img_path)return ilen                            # 返回self.img_path列表的长度,即该数据集包含的图像数量。def __getitem__(self,item):img_name=self.img_path[item]                     # path路径中的第item个图像img_item_path=os.path.join(self.path,img_name)   # 该图像的路径img=Image.open(img_item_path)                    # 打开并读取图像img=self.transform(img)                          # 转化为(224*224)并转化为Tensor类型if self.label_dir=="cat":           # 如果是cat下的图片label=1                         # label为猫狗的二分类值,因为二分类不能用文字“猫,狗”表示,所以这里我们用1来表示猫,0来表示狗else:label=0return img,label
root_dir="dataset/train"
lable_cat_dir="cat"
lable_dog_dir="dog"
cat_dataset=mydataset(root_dir,lable_cat_dir)
dog_dataset=mydataset(root_dir,lable_dog_dir)
train_dataset=cat_dataset+dog_dataset
class VGG16(torch.nn.Module):def __init__(self):super(VGG16, self).__init__()self.conv1 = torch.nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1)self.relu1 = torch.nn.ReLU(inplace=True)self.conv2 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)self.relu2 = torch.nn.ReLU(inplace=True)self.maxpl1 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv3 = torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)self.relu3 = torch.nn.ReLU(inplace=True)self.conv4 = torch.nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)self.relu4 = torch.nn.ReLU(inplace=True)self.maxpl2 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv5 = torch.nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)self.relu5 = torch.nn.ReLU(inplace=True)self.conv6 = torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)self.relu6 = torch.nn.ReLU(inplace=True)self.conv7 = torch.nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)self.relu7 = torch.nn.ReLU(inplace=True)self.maxpl3 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv8 = torch.nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)self.relu8 = torch.nn.ReLU(inplace=True)self.conv9 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu9 = torch.nn.ReLU(inplace=True)self.conv10 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu10 = torch.nn.ReLU(inplace=True)self.maxpl4 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.conv11 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu11 = torch.nn.ReLU(inplace=True)self.conv12 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu12 = torch.nn.ReLU(inplace=True)self.conv13 = torch.nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)self.relu13 = torch.nn.ReLU(inplace=True)self.maxpl5 = torch.nn.MaxPool2d(kernel_size=2, stride=2)self.fc1 = torch.nn.Linear(7*7*512, 4096)self.relu14 = torch.nn.ReLU(inplace=True)self.fc2 = torch.nn.Linear(4096, 4096)self.relu15 = torch.nn.ReLU(inplace=True)self.dropout = torch.nn.Dropout()self.fc3 = torch.nn.Linear(4096, 2)def forward(self, x):x = self.conv1(x)x = self.relu1(x)x = self.conv2(x)x = self.relu2(x)x = self.maxpl1(x)x = self.conv3(x)x = self.relu3(x)x = self.conv4(x)x = self.relu4(x)x = self.maxpl2(x)x = self.conv5(x)x = self.relu5(x)x = self.conv6(x)x = self.relu6(x)x = self.conv7(x)x = self.relu7(x)x = self.maxpl3(x)x = self.conv8(x)x = self.relu8(x)x = self.conv9(x)x = self.relu9(x)x = self.conv10(x)x = self.relu10(x)x = self.maxpl4(x)x = self.conv11(x)x = self.relu11(x)x = self.conv12(x)x = self.relu12(x)x = self.conv13(x)x = self.relu13(x)x = self.maxpl5(x)x = x.view(-1,7*7*512)x = self.fc1(x)x = self.relu14(x)x = self.fc2(x)x = self.relu15(x)x = self.fc3(x)return x
trainloader=torch.utils.data.DataLoader(train_dataset,batch_size=4, shuffle=True)model=VGG16()
criterion = torch.nn.CrossEntropyLoss()
optimizer= torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)eopchs=6
for i in range(eopchs):sumloss=0for images, lables in trainloader:ypre=model(images)loss=criterion(ypre,lables)loss.backward()optimizer.step()optimizer.zero_grad()sumloss+=loss.item()print("Epoch {}, Loss: {}".format(i+1, sumloss/len(trainloader)))examples=enumerate(trainloader)
batch,(images,lables)=next(examples)fig=plt.figure()
for i in range(4):t=torch.unsqueeze(images[i],dim=0)       # 增加一个维度,使t的形状与模型期望的形状相匹配logps=model(t)probab=list(logps.detach().numpy()[0])# logps.detach()从计算图中分离出logps,确保后续的操作不会影响到模型的梯度。# 接着,.numpy()将张量转换为NumPy数组。[0]取出第一个元素(因为t是一个批次大小为1的数据),# 最后list()将这个元素转换为一个列表。此时,probab是一个包含所有类别概率的列表。pred_label=probab.index(max(probab))   # 找出probab列表中概率最大的元素的索引,这个索引即代表模型预测的类别标签。if pred_label==0:pre="狗"else:pre="猫"img=torch.squeeze(images[i])           # 移除大小为1的维度,让它回到原来的形状img1=img.permute(1, 2, 0)              # 将图像的维度从(channels, height, width)调整为(height, width, channels)img1=img1.numpy()plt.subplot(2,2,i+1)    # 创建一个2*2的子图网格,并选择第i+1个子图作为当前绘图区域plt.tight_layout()            # 自动调整子图参数,使之填充整个图像区域并尽量减少重叠plt.imshow(img1,cmap='gray',interpolation='none')plt.title(f"预测值:{pre}")plt.xticks([])                # 设置x轴和y轴的刻度标签为空plt.yticks([])
plt.show()

在第一层卷积层,我们需要根据图片原本的通道数进行修改,

最后的全连接层也要根据要分类的类的个数进行修改

注意:因为我们只是简单的进行示例,我们的循环次数就只循环了6次

大家可以根据自己的需要,来增加卷积层的层数来更好地获取图片特征,

增加循环次数,来减少损失值

1.4.2 结果

Epoch 1, Loss: 0.6931928634643555
Epoch 2, Loss: 0.6932265162467957
Epoch 3, Loss: 0.6932326912879944
Epoch 4, Loss: 0.6933580279350281
Epoch 5, Loss: 0.6932826161384582
Epoch 6, Loss: 0.6932745337486267

因为我们的循环次数和卷积层层数过少,损失值仍然较大,所以即使我们训练集和测试集用的同一数据集 ,我们地预测仍然存在误差。

2. ResNet18

2.1 ResNet18简介

论文网址:

ResNet网络

让我们先来简单了解一下ResNet18

ResNet18是深度学习中的一个模型,它由残差网络(ResNet)和18层深度组成。

具体来说,ResNet18包含了4个卷积层,每个卷积层使用3x3的卷积核和ReLU激活函数来提取图像的局部特征。

同时,它还有8个残差块,每个残差块由两个卷积层和一条跳跃连接(恒等连接)构成,这有助于解决深度卷积神经网络中可能出现的梯度消失和梯度爆炸问题。

此外,ResNet18还包括全局平均池化层、一个大小为1000的全连接层以及输出层,后者使用softmax激活函数生成1000个类别的概率分布。

这这里,我们主要学习ResNet18,即18-layer

我们的代码主要围绕这部分展开

实线代表卷积直接进行相加,虚线代表要先将长和宽转化一下(使前一个和下一个能够相加),在求和

2.2 结构图 

这个结构图是引入了一个快捷连接来解决深度神经网络训练中的梯度消失和梯度爆炸等问题,从而构建深层的神经网络 。

这部分也是残差函数的相关内容。

那么,什么是残差函数呢

2.3 代码 

import matplotlib.pyplot as plt
import numpy as np
from matplotlib import font_manager
from sklearn.metrics import accuracy_score
import torch
from torch.utils.data import DataLoader, Dataset
import torchvision
from torchvision import transforms
from PIL import Image
import torch.nn.functional as F
import osclass CommonBlock(torch.nn.Module):def __init__(self, in_channel, out_channel, stride):super(CommonBlock, self).__init__()self.conv1 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, bias=False)self.bn1 = torch.nn.BatchNorm2d(out_channel)  # 添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定self.conv2 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, bias=False)self.bn2 = torch.nn.BatchNorm2d(out_channel)def forward(self, x):identity = xx = F.relu(self.bn1(self.conv1(x)), inplace=True)x = self.bn2(self.conv2(x))x += identityreturn F.relu(x, inplace=True)class SpecialBlock(torch.nn.Module):def __init__(self, in_channel, out_channel, stride):super(SpecialBlock, self).__init__()self.change_channel = torch.nn.Sequential(torch.nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride[0], padding=0, bias=False),torch.nn.BatchNorm2d(out_channel))self.conv1 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride[0], padding=1, bias=False)self.bn1 = torch.nn.BatchNorm2d(out_channel)  # 添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定self.conv2 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride[1], padding=1, bias=False)self.bn2 = torch.nn.BatchNorm2d(out_channel)def forward(self, x):identity = self.change_channel(x)x = F.relu(self.bn1(self.conv1(x)), inplace=True)x = self.bn2(self.conv2(x))x += identityreturn F.relu(x, inplace=True)class ResNet18(torch.nn.Module):def __init__(self, classes_num):super(ResNet18).__init__()# 定义网络模块self.prepare = torch.nn.Sequential(torch.nn.Conv2d(3, 64, 7, 2, 3),torch.nn.BatchNorm2d(64),  # Batch Normanlization简称 BN,也就是数据归一化torch.nn.ReLU(inplace=True),torch.nn.MaxPool2d(3, 2, 1))self.layer1 = torch.nn.Sequential(CommonBlock(64, 64, 1),CommonBlock(64, 64, 1))self.layer2 = torch.nn.Sequential(SpecialBlock(64, 128, [2, 1]),CommonBlock(128, 128, 1))self.layer3 = torch.nn.Sequential(SpecialBlock(128, 256, [2, 1]),CommonBlock(256, 256, 1))self.layer4 = torch.nn.Sequential(SpecialBlock(256, 512, [2, 1]),CommonBlock(512, 512, 1))self.pool = torch.nn.AdaptiveAvgPool2d(output_size=(1, 1))self.fc = torch.nn.Sequential(torch.nn.Linear(256, classes_num))def forward(self, x):x = self.prepare(x)x = self.layer1(x)x = self.layer2(x)x = self.layer3(x)x = self.layer4(x)x = self.pool(x)x = x.reshape(x.shape[0], -1)x = self.fc(x)return x

有几个我们需要注意的点:

class SpecialBlock(torch.nn.Module):def __init__(self, in_channel, out_channel, stride):super(SpecialBlock, self).__init__()self.change_channel = torch.nn.Sequential(torch.nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride[0], padding=0, bias=False),torch.nn.BatchNorm2d(out_channel))self.conv1 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride[0], padding=1, bias=False)self.bn1 = torch.nn.BatchNorm2d(out_channel)  # 添加BatchNorm2d进行数据的归一化处理,这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定self.conv2 = torch.nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride[1], padding=1, bias=False)self.bn2 = torch.nn.BatchNorm2d(out_channel)def forward(self, x

在下面,stride传入的是一个列表,分别表示横向滑动和纵向滑动的步长,当 stride=stride[0]时表示的是横向滑动,另一个则是纵向滑动。

self.change_channel = torch.nn.Sequential

它允许用户将多个计算层按照顺序组合成一个模型。在深度学习中,模型可以是由各种不同类型的层组成的,例如卷积层、池化层、全连接层等。nn.Sequential()方法可以将这些层组合在一起,形成一个整体模型。

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

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

相关文章

pinpoint接入及接入tomcat

# 5、pinpoint接入 1、开启性能监控 应用管理详情页面-->【属性】编辑,勾选开启用性能监控 2.java命令行引用pinpoint和相关变量 java $JAVA_OPTS -javaagent:/usr/local/pinpoint-agent/pinpoint-bootstrap-1.7.2.jar -Dpinpoint.agentIddcs-repair-${HOSTNAME…

k8s集群安装网络插件calico常见问题

关于calico网络插件报错的常见问题处理 1.安装calico插件时,calico相关pod无法成功运行。 报错信息:“MountVolume.SetUp failed for volume "bpffs" : hostPath type check failed: /sys/fs/bpf is not a directory”解决办法:检…

互联网摸鱼日报(2024-04-19)

互联网摸鱼日报(2024-04-19) 36氪新闻 魏建军把方向盘交给AI,长城汽车开卷智能驾驶 一季度我国工业经济保持较快增长,下一步这么做 晶华光学北交所IPO问询分析:利润下滑和存货计提是否充分或成公司能否上会的关键性问题 这10 本改变人生的…

【智能算法】鸡群优化算法(CSO)原理及实现

目录 1.背景2.算法原理2.1算法思想2.2算法过程 3.结果展示4.参考文献 1.背景 2014年,X Meng等人受到鸡群社会行为启发,提出了鸡群优化算法(Chicken Swarm Optimization, CSO)。 2.算法原理 2.1算法思想 CSO算法的思想是基于对…

数仓建模—物理数据模型

数仓建模—物理数据模型 前面我们讲了数据模型和逻辑数据模型,你可以参考前面的文章,这一节我们介绍一下物理数据模型 数仓建模—数据模型 数仓建模—逻辑数据模型 什么是物理数据模型 物理数据模型指定如何在数据库中构建数据模型。它概述了所有表结构,包括列名、数据类…

润开鸿与蚂蚁数科达成战略合作,发布基于鸿蒙的mPaaS移动应用开发产品

4月18日,江苏润和软件股份有限公司(以下简称“润和软件”) 旗下专注鸿蒙方向的专业技术公司及终端操作系统发行版厂商江苏润开鸿数字科技有限公司(以下简称“润开鸿”)与蚂蚁数科举行战略合作签约仪式,并发…

【Java开发指南 | 第十六篇】Java数组及Arrays类

读者可订阅专栏:Java开发指南 |【CSDN秋说】 文章目录 数组数组特点创建数组处理数组多维数组Arrays类 数组 Java中的数组是一种用来存储固定大小的相同类型元素的数据结构。 数组特点 数组具有以下特点: 1、固定大小: 一旦数组被创建,其…

系统调优助手,PyTorch Profiler TensorBoard 插件教程

0x1. 前言 使用PyTorch Profiler进行性能分析已经一段时间了,毕竟是PyTorch提供的原生profile工具,个人感觉做系统性能分析时感觉比Nsys更方便一些,并且画的图也比较直观。这里翻译一下PyTorch Profiler TensorBoard Plugin的教程并分享一些…

Sui在Basecamp 2024上重塑区块链行业

Sui主网于去年推出,世界各地的社区活动帮助开发者了解了这一开创性的区块链技术的潜力,而Sui Basecamp表明Sui时代已经到来。 来自65个国家的超过1100人参加了今年在巴黎举办的Sui全球活动,以了解Sui在游戏和DeFi领域的坚实立足点。在两天的…

js DOM模型常用方法复盘梳理

大家好,我是资深前端之路,今天主要是在对常用的js基础知识进行复盘,回顾下最基础的知识,不断打地基。今天主要回顾的知识是以下几个内容: 1、什么是DOM 定义:文档对象模型,操作html标签的能力&…

什么是XXE攻击?如何进行防护

安全性很难做到正确,即使在当今具有安全意识的世界中,也存在一些严重的漏洞,例如 XML 外部实体 (XXE),它们被忽视并最终成为破坏的原因。 XML 外部实体 (XXE) 攻击是一种计算机安全漏洞,通常存在于 Web 应用程序中&…

单字符 和 宽字符

#define PI 3.14 //产生新类型 typedef 3.14 PI单字符,一个字节存储,宽字符,二个字节存储。sizeof(L"abc")8 size("abc")4typedef unsigned short wchar_t; chartypedef wchar_t WCHAR; typedef char CHAR;WCHAR* p …

SpringBoot 项目Docker部署三种方式

一种:直接拷贝jar到服务器部署 1.增加docker配置文件 新建Dockerfile文件,负责Docker的配置 FROM openjdk:21#ENV timezone RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \&& echo Asia/Shanghai >/etc/timezone# WORKD…

项目活动图

关键路径: 从开始到结束的所有路径中,时间最长的一条为关键路径。(特点:在关键路径上,所有任务的松弛时间都为0); 松弛时间: 最晚开始时间 – 最早开始时间; 所有的路…

解释Java中的容器化技术,如Docker和Kubernetes

容器化技术是近年来软件开发和运维领域的一项重大创新,它允许开发者将应用程序及其依赖项打包到一个轻量级、可移植的容器中,从而实现快速、一致和高效的部署。在Java开发中,Docker和Kubernetes是两种非常流行的容器化技术。 ### Docker Do…

2W 3KVDC 隔离单、双输出 DC/DC 电源模块——TPH 系列

TPH系列是一款2W,单、双输出隔离电源模块,特别适合板上只有一种电压而要求有正负电源的场合,工业级温度范围–40℃到105℃,在此温度范围内都可以稳定输出2W,并且效率非常高,高达86%,温升非常低&…

JavaSE进阶篇-面向对象程序设计

一、面向对象和面向过程的关系 1)面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做; 2)面向对象:强调了具备功能的对象,以类/对象为最小单位,考虑谁来做。 总结…

虚拟机的网络模式

仅主机 仅用来与主机交互,使用的是VMnet1网卡,该模式无法链接互联网,只能与物理机通讯,如果ip不与物理机在同一个网段,那么也无法与物理机通讯 桥接模式 该模式下的虚拟机会链接VMnet0网卡,该网卡会直接桥接…

Python进阶编程 --- 3.闭包、装饰器、设计模式、多线程、网络编程、正则表达式、递归

文章目录 第三章:3.1 闭包3.2 装饰器语法糖写法 3.3 设计模式3.3.1 单例模式3.3.2 工厂模式 3.4 多线程3.4.1 进程、线程和并行执行3.4.2 多线程编程 3.5 网络编程3.5.1 Socket3.5.2 服务端开发3.5.3 客户端开发 3.6 正则表达式3.6.1 基础匹配3.6.2 元字符匹配单字符…

fopen/fwrite/fread/open/write/read的区别

fopen和Open,read和fread,write和fwrite有什么区别,很多人都会弄混了,而这经常会带来一些问题。所以在这里理清他们的关系是很有必要的。 open/read/write是Linux提供的系统调用,用户态的程序只能通过这些接口来访问文件系统层。而fopen/fread/fwrite是C库提供的文件读写接…