【动手学深度学习】使用块的网络（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.mzph.cn/pingmian/23350.shtml

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

相关文章

Qt如何让按钮的菜单出现在按钮的右侧

Qt如何让按钮的菜单出现在按钮的右侧

直接上代码，我们用到了一个eventfilter的函数功能。这个函数比较厉害和重要，大家务必经常拿出来看看。 void MainWindow::initMenu() { QMenu* menuLiXiang new QMenu; QAction* actXiangMuZhangCheng new QAction("项目章程"); …
阅读更多...
【Cesium4UE】使用问题及解法统计

【Cesium4UE】使用问题及解法统计

本期作者：尼克 易知微3D引擎技术负责人 1.加载3dtiles模型很慢 1.3dtiles是否做了重建顶层处理。如果3dtiles的tiles块太多使用CesiumLab重建顶层。 2.将3dtiles模型放置到固态硬盘中 3.如果有多块3dtiles，考虑使用CesiumLab合并3dtiles处理 4.如果不需…
阅读更多...
OSG天空图代码

OSG天空图代码

osgEarth // 创建天空选项osgEarth::Util::SkyOptions skyOptions;// 设置天空的坐标系统（可选）skyOptions.coordinateSystem() osgEarth::Util::SkyOptions::COORDSYS_ECEF;// 设置一天中的小时数（可选）skyOptions.hours() 12.…
阅读更多...
基于springboot实现社区养老服务系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现社区养老服务系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现社区养老服务系统演示 摘要 现代经济快节奏发展以及不断完善升级的信息化技术，让传统数据信息的管理升级为软件存储，归纳，集中处理数据信息的管理方式。本社区养老服务系统就是在这样的大环境下诞生，其可以帮助…
阅读更多...
Al2O3/SiC纳米复相陶瓷力学性能显著提升 我国研究机构数量较多

Al2O3/SiC纳米复相陶瓷力学性能显著提升 我国研究机构数量较多

Al2O3/SiC纳米复相陶瓷力学性能显著提升 我国研究机构数量较多 Al2O3/SiC纳米复相陶瓷，是以氧化铝（Al2O3）为基体相，以纳米碳化硅（SiC）为第二相，将第二相纳米颗粒弥散进入基体相，经高…
阅读更多...
Google Inventor一款适合儿童的趣味APP编程开发平台

Google Inventor一款适合儿童的趣味APP编程开发平台

Google Inventor 其实是指 App Inventor，这是由 Google 开发并由麻省理工学院（MIT）继续维护和发展的一个应用程序开发平台。 App Inventor 的主要特点和用途如下： 什么是 App Inventor？ App Inventor 是一个基于 W…
阅读更多...
uni-app基础框架搭建（vue3+ts+vite）

uni-app基础框架搭建（vue3+ts+vite）

1.基础准备 uni-app官网uni-app,uniCloud,serverless,环境安装,创建uni-app,自定义模板,国内特殊情况,更新依赖到指定版本,运行、发布uni-app,运行并发布快应用,运行并发布快应用(webview),运行并发布快应用(webview)-华为,cli创建项目和HBuilderX可视化界面创https://uniapp.…
阅读更多...
中科数安 | 透明加密防泄密系统！如何有效防止企业内部核心数据资料外泄？

中科数安 | 透明加密防泄密系统！如何有效防止企业内部核心数据资料外泄？

中科数安提供的透明加密防泄密系统是一种专为企业设计的数据保护解决方案，它通过以下关键特性有效防止企业内部核心数据资料外泄： PC地址：——www.weaem.com 自动智能透明加密：系统能够在操作系统级别无缝集成，对指定类…
阅读更多...
AC/DC电源模块：跟踪技术的创新之选

AC/DC电源模块：跟踪技术的创新之选

BOSHIDA AC/DC电源模块：跟踪技术的创新之选 AC/DC电源模块是一种将交流电转换为直流电的设备，广泛应用于各个领域的电子设备中。随着现代科技的发展，对电子设备的要求越来越高，需要能够提供更稳定、更高效的电源。AC/DC电源模块…
阅读更多...
从零开始写 Docker(十七)---容器网络实现(中)：为容器插上”网线“

从零开始写 Docker(十七)---容器网络实现(中)：为容器插上”网线“

本文为从零开始写 Docker 系列第十七篇，利用 linux 下的 Veth、Bridge、iptables 等等相关技术，构建容器网络模型，为容器插上”网线“。 完整代码见：https://github.com/lixd/mydocker 欢迎 Star 推荐阅读以下文章对 docker 基本实…
阅读更多...
BERT应用——文本间关联性分析

BERT应用——文本间关联性分析

本文结合了自然语言处理（NLP）和深度学习技术，旨在分析一段指定的任务文本中的动词，并进一步探讨这个动词与一系列属性之间的关联性。具体技术路径包括文本的词性标注、语义编码和模型推断。 一、技术思路 NLP和词性标注 在自然…
阅读更多...
独著出书的出版流程是怎样的？

独著出书的出版流程是怎样的？

独著出书的出版流程一般包括以下几个步骤： 1. 准备书稿：确保书稿内容完整、准确，并符合出版社的要求。 2. 选择出版社：根据书稿的主题和内容，选择合适的出版社。可以考虑出版社的专业性、声誉和出版范围等因素。 3.…
阅读更多...
MySQL Shell 使用指南

MySQL Shell 使用指南

前言： MySQL Shell 是官方提供的 MySQL 周边适配组件，是新一代的高级客户端，在 MySQL 8.0 及其以后的版本得以慢慢推广应用。之前笔者因为 MySQL 8.0 用得比较少，一直没有详细使用过这个工具，近期在捣鼓 MySQL 8.0&am…
阅读更多...
如何去掉IDEA中烦人的警告波浪线

如何去掉IDEA中烦人的警告波浪线

有时候想去掉idea中那些黄色的红色的warning波浪线，这些不是错误，并不影响执行，一直显示显得让人很烦躁，去"Editor" -> "Inspections"中一个个设置很麻烦。 可以通过设置代码检测级别来降低代码检查的严格…
阅读更多...
ChatGPT Prompt技术全攻略-入门篇：AI提示工程基础

ChatGPT Prompt技术全攻略-入门篇：AI提示工程基础

系列篇章💥 No.文章1ChatGPT Prompt技术全攻略-入门篇：AI提示工程基础2ChatGPT Prompt技术全攻略-进阶篇：深入Prompt工程技术3ChatGPT Prompt技术全攻略-高级篇：掌握高级Prompt工程技术4ChatGPT Prompt技术全攻略-应用篇&#xf…
阅读更多...
文献解读-肿瘤测序-第六期|《基于CRISPR/Cas9技术的肿瘤突变负荷测量新参考物质的开发》

文献解读-肿瘤测序-第六期|《基于CRISPR/Cas9技术的肿瘤突变负荷测量新参考物质的开发》

关键词：肿瘤测序；基因组变异检测； 文献简介 标题（英文）：Development of a Novel Reference Material for Tumor Mutational Burden Measurement Based on CRISPR/Cas9 Technolog标题（中文&…
阅读更多...
【协同感知】Collaborative Perception in Autonomous Driving数据集与论文整理

【协同感知】Collaborative Perception in Autonomous Driving数据集与论文整理

Collaborative Perception in Autonomous Driving 目前最全的Collaborative Perception整理数据集协同感知论文-【三维目标检测】现实世界下的协同感知理想条件下的协同感知 目前最全的Collaborative Perception整理 https://github.com/Little-Podi/Collaborative_Perception…
阅读更多...
【探索全球精彩瞬间，尽享海外短剧魅力！海外短剧系统，您的专属观影平台】

【探索全球精彩瞬间，尽享海外短剧魅力！海外短剧系统，您的专属观影平台】

🌟 海外短剧系统，带您走进一个全新的视界，让您随时随地欣赏到来自世界各地的精选短剧。在这里，您可以感受到不同文化的碰撞，品味到各种题材的精髓，让您的生活更加丰富多彩！ 🎬 精选…
阅读更多...
【Python】【Pyinstaller】打包过程问题记录及解决

【Python】【Pyinstaller】打包过程问题记录及解决

一、写在前面 将python脚本打包成.exe可执行文件，使用windows电脑运行。 所需库：pyinstaller 官网链接 命令格式： pyinstaller -F -w (需要打包的文件，文件名之间用空格分隔）二、打包步骤（见图片&#x…
阅读更多...
自费出书一般需要多少钱？

自费出书一般需要多少钱？

自费出书的费用因多种因素而异，包括书号费、审稿费、排版费、封面设计费、纸张及印刷费、仓储物流费等。 以下是一些常见的费用项目和大致价格范围： - 书号费：书号是出版社的特有资源，书号费用在2023年又进一步上涨。目前&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023