【PyTorch】图像多分类项目

【PyTorch】图像二分类项目

【PyTorch】图像二分类项目-部署

【PyTorch】图像多分类项目

【PyTorch】图像多分类项目部署

多类图像分类的目标是为一组固定类别中的图像分配标签。

目录

加载和处理数据

搭建模型

定义损失函数

定义优化器

训练和迁移学习

用随机权重进行训练

用预训练权重进行训练


加载和处理数据

将使用 PyTorch torchvision 包中提供的 STL-10 数据集,数据集中有 10 个类:飞机、鸟、车、猫、鹿、狗、马、猴、船、卡车。图像为96*96像素的RGB图像。数据集包含 5,000 张训练图像和 8,000 张测试图像。在训练数据集和测试数据集中,每个类分别有 500 和 800 张图像。

from torchvision import datasets
import torchvision.transforms as transforms
import ospath2data="./data"
# 如果数据路径不存在,则创建
if not os.path.exists(path2data):os.mkdir(path2data)# 定义数据转换
data_transformer = transforms.Compose([transforms.ToTensor()])# 从datasets库中导入STL10数据集,并指定数据集的路径、分割方式、是否下载以及数据转换器
train_ds=datasets.STL10(path2data, split='train',download=True,transform=data_transformer)# 打印数据形状
print(train_ds.data.shape)

 若数据集导入较慢可直接下载:http://ai.stanford.edu/~acoates/stl10/stl10_binary.tar.gz

import collections# 获取标签
y_train=[y for _,y in train_ds]# 统计标签
counter_train=collections.Counter(y_train)
print(counter_train)

# 加载数据
test0_ds=datasets.STL10(path2data, split='test', download=True,transform=data_transformer)
# 打印数据形状
print(test0_ds.data.shape)

# 导入StratifiedShuffleSplit模块
from sklearn.model_selection import StratifiedShuffleSplit# 创建StratifiedShuffleSplit对象,设置分割次数为1,测试集大小为0.2,随机种子为0
sss = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=0)# 获取test0_ds的索引
indices=list(range(len(test0_ds)))# 获取test0_ds的标签
y_test0=[y for _,y in test0_ds]# 对索引和标签进行分割
for test_index, val_index in sss.split(indices, y_test0):# 打印测试集和验证集的索引print("test:", test_index, "val:", val_index)# 打印测试集和验证集的大小print(len(val_index),len(test_index))

# 从torch.utils.data中导入Subset类
from torch.utils.data import Subset# 从test0_ds中选取val_index索引的子集,赋值给val_ds
val_ds=Subset(test0_ds,val_index)
# 从test0_ds中选取test_index索引的子集,赋值给test_ds
test_ds=Subset(test0_ds,test_index)import collections
import numpy as np# 获取标签
y_test=[y for _,y in test_ds]
y_val=[y for _,y in val_ds]# 统计测试集和验证集的标签数量
counter_test=collections.Counter(y_test)
counter_val=collections.Counter(y_val)# 打印测试集和验证集的标签数量
print(counter_test)
print(counter_val)

from torchvision import utils
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline# 设置随机种子为0
np.random.seed(0)# 定义一个函数,用于显示图像
def show(img,y=None,color=True):# 将图像转换为numpy数组npimg = img.numpy()# 将图像的维度从(C,H,W)转换为(H,W,C)npimg_tr=np.transpose(npimg, (1,2,0))# 显示图像plt.imshow(npimg_tr)# 如果有标签,则显示标签if y is not None:plt.title("label: "+str(y))# 定义网格大小
grid_size=4
# 随机生成4个索引
rnd_inds=np.random.randint(0,len(train_ds),grid_size)
print("image indices:",rnd_inds)# 从训练集中获取这4个索引对应的图像和标签
x_grid=[train_ds[i][0] for i in rnd_inds]
y_grid=[train_ds[i][1] for i in rnd_inds]# 将这4个图像拼接成一个网格
x_grid=utils.make_grid(x_grid, nrow=4, padding=2)
print(x_grid.shape)# 调用helper函数显示网格
plt.figure(figsize=(10,10))
show(x_grid,y_grid)

 

# 设置随机种子为0 
np.random.seed(0)# 设置网格大小
grid_size=4
# 从验证数据集中随机选择grid_size个索引
rnd_inds=np.random.randint(0,len(val_ds),grid_size)
print("image indices:",rnd_inds)# 从验证数据集中选择对应的图像
x_grid=[val_ds[i][0] for i in rnd_inds]
# 从验证数据集中选择对应的标签
y_grid=[val_ds[i][1] for i in rnd_inds]# 将图像排列成网格
x_grid=utils.make_grid(x_grid, nrow=4, padding=2)
print(x_grid.shape)# 调用辅助函数
plt.figure(figsize=(10,10))
# 显示网格图像和标签
show(x_grid,y_grid)

 

 

import numpy as np# 计算训练集中每个样本的RGB均值
meanRGB=[np.mean(x.numpy(),axis=(1,2)) for x,_ in train_ds]  
# 计算训练集中每个样本的RGB标准差
stdRGB=[np.std(x.numpy(),axis=(1,2)) for x,_ in train_ds]  meanR=np.mean([m[0] for m in meanRGB])  # 计算所有样本的R通道均值的平均值
meanG=np.mean([m[1] for m in meanRGB])  
meanB=np.mean([m[2] for m in meanRGB])  stdR=np.mean([s[0] for s in stdRGB])  # 计算所有样本的R通道标准差的平均值
stdG=np.mean([s[1] for s in stdRGB])  
stdB=np.mean([s[2] for s in stdRGB])  print(meanR,meanG,meanB)  # 打印R、G、B通道的均值
print(stdR,stdG,stdB)  # 打印R、G、B通道的标准差

# 定义训练数据的转换器
train_transformer = transforms.Compose([# 随机水平翻转,翻转概率为0.5transforms.RandomHorizontalFlip(p=0.5),  # 随机垂直翻转,翻转概率为0.5transforms.RandomVerticalFlip(p=0.5),  # 将图像转换为张量transforms.ToTensor(),# 对图像进行归一化,均值和标准差分别为meanR, meanG, meanB和stdR, stdG, stdBtransforms.Normalize([meanR, meanG, meanB], [stdR, stdG, stdB])])# 定义测试数据的转换器
test0_transformer = transforms.Compose([# 将图像转换为张量transforms.ToTensor(),# 对图像进行归一化,均值和标准差分别为meanR, meanG, meanB和stdR, stdG, stdBtransforms.Normalize([meanR, meanG, meanB], [stdR, stdG, stdB]),])   # 将训练数据集的转换器赋值给训练数据集的transform属性
train_ds.transform=train_transformer
# 将测试数据集的转换器赋值给测试数据集的transform属性
test0_ds.transform=test0_transformerimport torch
import numpy as np
import matplotlib.pyplot as plt# 设置随机种子
np.random.seed(0)
torch.manual_seed(0)# 定义网格大小
grid_size=4# 从训练数据集中随机选择grid_size个样本的索引
rnd_inds=np.random.randint(0,len(train_ds),grid_size)
print("image indices:",rnd_inds)# 根据索引从训练数据集中获取对应的样本
x_grid=[train_ds[i][0] for i in rnd_inds]
y_grid=[train_ds[i][1] for i in rnd_inds]# 将样本转换为网格形式
x_grid=utils.make_grid(x_grid, nrow=4, padding=2)
print(x_grid.shape)# 创建一个10x10的图像
plt.figure(figsize=(10,10))
# 显示网格和对应的标签
show(x_grid,y_grid)

from torch.utils.data import DataLoader# 创建训练数据集的DataLoader,batch_size为32,shuffle为True,表示每次迭代时都会打乱数据集
train_dl = DataLoader(train_ds, batch_size=32, shuffle=True)
# 创建验证数据集的DataLoader,batch_size为64,shuffle为False,表示每次迭代时不会打乱数据集
val_dl = DataLoader(val_ds, batch_size=64, shuffle=False)  # 遍历训练数据集
for x, y in train_dl:# 打印x的形状print(x.shape)# 打印y的形状print(y.shape)# 跳出循环break

# 遍历val_dl中的每个元素,x和y分别表示输入和标签
for x, y in val_dl:# 打印输入的形状print(x.shape)# 打印标签的形状print(y.shape)# 退出循环break

# 从datasets库中导入FashionMNIST数据集,并将其设置为训练集
fashion_train=datasets.FashionMNIST(path2data, train=True, download=True)

搭建模型

使用torchvision为多分类任务构建一个模型。torchvision软件包提供了用于图像分类的多个最先进的深度学习模型的实现,包括 AlexNet、VGG、ResNet、SqueezeNet、DenseNet、Inception、GoogleNet、ShuffleNet。这些模型在 ImageNet 数据集上进行了训练,其中包含来自 1,000 个班级的 1400 多万张图像。可以分别使用具有随机初始化权重的架构、预训练权重进行尝试。

from torchvision import models
import torch# 创建一个resnet18模型,pretrained参数设置为False,表示不使用预训练的权重
model_resnet18 = models.resnet18(pretrained=False)
# 打印模型ResNet18
print(model_resnet18)

from torch import nn
# 定义类别数量
num_classes=10
# 获取模型ResNet18的全连接层输入特征数量
num_ftrs = model_resnet18.fc.in_features 
# 将全连接层替换为新的全连接层,输出特征数量为类别数量
model_resnet18.fc = nn.Linear(num_ftrs, num_classes)# 定义设备为GPU
device = torch.device("cuda:0")
# 将模型移动到GPU上
model_resnet18.to(device)

from torchsummary import summary# 打印模型结构,输入大小为(3, 224, 224),即3个通道,224x224大小的图像
summary(model_resnet18, input_size=(3, 224, 224))

# 遍历模型ResNet18的参数
for w in model_resnet18.parameters():# 将参数转换为CPU数据w=w.data.cpu()# 打印参数的形状print(w.shape)break# 计算参数的最小值
min_w=torch.min(w)
# 计算w1,其中w1 = (-1/(2*min_w))*w + 0.5 
w1 = (-1/(2*min_w))*w + 0.5 
# 打印w1的最小值和最大值
print(torch.min(w1).item(),torch.max(w1).item())# 计算网格大小
grid_size=len(w1)
# 生成网格
x_grid=[w1[i] for i in range(grid_size)]
x_grid=utils.make_grid(x_grid, nrow=8, padding=1)
print(x_grid.shape)# 创建一个5x5的图像
plt.figure(figsize=(5,5))
show(x_grid)

采用预训练权重

from torchvision import models
import torch# 加载预训练的resnet18模型
resnet18_pretrained = models.resnet18(pretrained=True)# 定义分类的类别数
num_classes=10
# 获取resnet18模型的最后一层全连接层的输入特征数
num_ftrs = resnet18_pretrained.fc.in_features
# 将最后一层全连接层替换为新的全连接层,新的全连接层的输出特征数为num_classes
resnet18_pretrained.fc = nn.Linear(num_ftrs, num_classes)# 定义设备为cuda:0
device = torch.device("cuda:0")
# 将模型移动到cuda:0设备上
resnet18_pretrained.to(device) 

# 遍历resnet18_pretrained的参数
for w in resnet18_pretrained.parameters():# 将参数转换为cpu格式w=w.data.cpu()print(w.shape)break# 计算w的最小值
min_w=torch.min(w)
# 计算w1,其中w1=(-1/(2*min_w))*w + 0.5
w1 = (-1/(2*min_w))*w + 0.5 
# 打印w1的最小值和最大值
print(torch.min(w1).item(),torch.max(w1).item())# 计算w1的网格大小
grid_size=len(w1)
# 将w1转换为网格形式
x_grid=[w1[i] for i in range(grid_size)]
x_grid=utils.make_grid(x_grid, nrow=8, padding=1)
print(x_grid.shape)# 创建一个5x5的图像
plt.figure(figsize=(5,5))
show(x_grid)

 

定义损失函数

定义损失函数的目的是将模型优化为预定义的指标。分类任务的标准损失函数是交叉熵损失或对数损失。在定义损失函数时,需要考虑模型输出的数量及其激活函数。对于多类分类任务,输出数设置为类数,输出激活函数确确定损失函数。

输出激活输出数量损失函数
None num_classes nn.CrossEntropyLoss
log_Softmax num_classes nn.NLLLoss
torch.manual_seed(0)# 定义输入数据的维度
n,c=4,5
# 生成随机输入数据,并设置requires_grad=True,表示需要计算梯度
y = torch.randn(n, c, requires_grad=True)
# 打印输入数据的形状
print(y.shape)# 定义交叉熵损失函数,reduction参数设置为"sum",表示将所有样本的损失相加
loss_func = nn.CrossEntropyLoss(reduction="sum")
# 生成随机目标数据,表示每个样本的类别
target = torch.randint(c,size=(n,))
# 打印目标数据的形状
print(target.shape)# 计算损失
loss = loss_func(y, target)
# 打印损失值
print(loss.item())

# 反向传播,计算梯度
loss.backward()
# 打印输出y的值
print (y.data)

定义优化器

torch.optim 包提供了通用优化器的实现。优化器将保持当前状态,并根据计算出的梯度更新参数。对于分类任务,随机梯度下降 (SGD) 和 Adam 优化器非常常用。Adam 优化器在速度和准确性方面通常优于 SGD,因此这里选择 Adam 优化器。

from torch import optim
# 定义优化器,使用Adam优化算法,优化model_resnet18的参数,学习率为1e-4
opt = optim.Adam(model_resnet18.parameters(), lr=1e-4)
# 定义一个函数,用于获取优化器的学习率
def get_lr(opt):# 遍历优化器的参数组for param_group in opt.param_groups:# 返回学习率return param_group['lr']# 调用函数,获取当前学习率
current_lr=get_lr(opt)
# 打印当前学习率
print('current lr={}'.format(current_lr))

 

from torch.optim.lr_scheduler import CosineAnnealingLR# 创建学习率调度器,T_max表示周期长度,eta_min表示最小学习率
lr_scheduler = CosineAnnealingLR(opt,T_max=2,eta_min=1e-5)
# 定义一个空列表lrs
lrs=[]
# 循环10次
for i in range(10):# 调用lr_scheduler.step()方法lr_scheduler.step()# 调用get_lr()方法获取当前学习率lr=get_lr(opt)# 打印当前epoch和对应的学习率print("epoch %s, lr: %.1e" %(i,lr))# 将当前学习率添加到列表lrs中lrs.append(lr)
# 绘制lrs列表中的数据
plt.plot(lrs)

 

 

训练和迁移学习

到目前为止,已经创建了数据集并定义了模型、损失函数和优化器,接下来将进行训练和验证。首先使用随机初始化的权重训练模型。然后使用预先训练的权重训练模型,这也称为迁移学习。迁移学习将从一个问题中学到的知识(权重)用于其他类似问题。训练和验证脚本可能很长且重复。为了提高代码可读性并避免代码重复,将先构建一些辅助函数。

# 定义一个函数metrics_batch,用于计算预测结果和目标之间的正确率
def metrics_batch(output, target):# 将输出结果的最大值所在的索引作为预测结果pred = output.argmax(dim=1, keepdim=True)# 计算预测结果和目标之间的正确率corrects=pred.eq(target.view_as(pred)).sum().item()# 返回正确率return corrects
def loss_batch(loss_func, output, target, opt=None):# 计算batch的损失loss = loss_func(output, target)# 计算batch的评估指标metric_b = metrics_batch(output,target)# 如果有优化器,则进行反向传播和参数更新if opt is not None:opt.zero_grad()loss.backward()opt.step()# 返回损失和评估指标return loss.item(), metric_bdevice = torch.device("cuda")# 定义一个函数loss_epoch,用于计算模型在数据集上的损失
def loss_epoch(model,loss_func,dataset_dl,sanity_check=False,opt=None):# 初始化运行损失和运行指标running_loss=0.0running_metric=0.0# 获取数据集的长度len_data=len(dataset_dl.dataset)# 遍历数据集for xb, yb in dataset_dl:# 将数据移动到GPU上xb=xb.to(device)yb=yb.to(device)# 获取模型输出output=model(xb)# 计算当前批次的损失和指标loss_b,metric_b=loss_batch(loss_func, output, yb, opt)# 累加损失和指标running_loss+=loss_bif metric_b is not None:running_metric+=metric_b# 如果是sanity_check模式,则只计算一个批次if sanity_check is True:break# 计算平均损失和指标loss=running_loss/float(len_data)metric=running_metric/float(len_data)# 返回平均损失和指标return loss, metricdef train_val(model, params):# 获取参数num_epochs=params["num_epochs"]loss_func=params["loss_func"]opt=params["optimizer"]train_dl=params["train_dl"]val_dl=params["val_dl"]sanity_check=params["sanity_check"]lr_scheduler=params["lr_scheduler"]path2weights=params["path2weights"]# 初始化损失和指标历史记录loss_history={"train": [],"val": [],}metric_history={"train": [],"val": [],}# 复制模型参数best_model_wts = copy.deepcopy(model.state_dict())# 初始化最佳损失best_loss=float('inf')# 遍历每个epochfor epoch in range(num_epochs):# 获取当前学习率current_lr=get_lr(opt)print('Epoch {}/{}, current lr={}'.format(epoch, num_epochs - 1, current_lr))# 训练模型model.train()train_loss, train_metric=loss_epoch(model,loss_func,train_dl,sanity_check,opt)# 记录训练损失和指标loss_history["train"].append(train_loss)metric_history["train"].append(train_metric)# 评估模型model.eval()with torch.no_grad():val_loss, val_metric=loss_epoch(model,loss_func,val_dl,sanity_check)# 如果验证损失小于最佳损失,则更新最佳损失和最佳模型参数if val_loss < best_loss:best_loss = val_lossbest_model_wts = copy.deepcopy(model.state_dict())# 将最佳模型参数保存到本地文件torch.save(model.state_dict(), path2weights)print("Copied best model weights!")# 记录验证损失和指标loss_history["val"].append(val_loss)metric_history["val"].append(val_metric)# 更新学习率lr_scheduler.step()# 打印训练损失、验证损失和准确率print("train loss: %.6f, dev loss: %.6f, accuracy: %.2f" %(train_loss,val_loss,100*val_metric))print("-"*10) # 加载最佳模型参数model.load_state_dict(best_model_wts)# 返回模型、损失历史和指标历史return model, loss_history, metric_history

用随机权重进行训练

import copy# 定义交叉熵损失函数,reduction参数设置为"sum",表示将所有样本的损失相加
loss_func = nn.CrossEntropyLoss(reduction="sum")
# 定义Adam优化器,优化模型参数,学习率为1e-4
opt = optim.Adam(model_resnet18.parameters(), lr=1e-4)
# 定义余弦退火学习率调度器,T_max参数设置为5,eta_min参数设置为1e-6
lr_scheduler = CosineAnnealingLR(opt,T_max=5,eta_min=1e-6)# 定义训练参数字典
params_train={"num_epochs": 3,  # 训练轮数"optimizer": opt,  # 优化器"loss_func": loss_func,  # 损失函数"train_dl": train_dl,  # 训练数据集"val_dl": val_dl,  # 验证数据集"sanity_check": False,  # 是否进行sanity check"lr_scheduler": lr_scheduler,  # 学习率调度器"path2weights": "./models/resnet18.pt",  # 模型权重保存路径
}# 训练和验证模型
model_resnet18,loss_hist,metric_hist=train_val(model_resnet18,params_train)

# 获取训练参数中的训练轮数
num_epochs=params_train["num_epochs"]# 绘制训练和验证损失曲线
plt.title("Train-Val Loss")
plt.plot(range(1,num_epochs+1),loss_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),loss_hist["val"],label="val")
plt.ylabel("Loss")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()# 绘制训练和验证准确率曲线
plt.title("Train-Val Accuracy")
plt.plot(range(1,num_epochs+1),metric_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),metric_hist["val"],label="val")
plt.ylabel("Accuracy")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()

用预训练权重进行训练

import copy# 定义损失函数,使用交叉熵损失,并设置reduction为sum
loss_func = nn.CrossEntropyLoss(reduction="sum")
# 定义优化器,使用Adam优化器,并设置学习率为1e-4
opt = optim.Adam(resnet18_pretrained.parameters(), lr=1e-4)
# 定义学习率调度器,使用余弦退火调度器,设置最大周期为5,最小学习率为1e-6
lr_scheduler = CosineAnnealingLR(opt,T_max=5,eta_min=1e-6)# 定义训练参数
params_train={"num_epochs": 3,  # 设置训练周期为3"optimizer": opt,  # 设置优化器"loss_func": loss_func,  # 设置损失函数"train_dl": train_dl,  # 设置训练数据集"val_dl": val_dl,  # 设置验证数据集"sanity_check": False,  # 设置是否进行sanity check"lr_scheduler": lr_scheduler,  # 设置学习率调度器"path2weights": "./models/resnet18_pretrained.pt",  # 设置权重保存路径
}# 调用train_val函数进行训练和验证,并返回训练后的模型、损失历史和指标历史
resnet18_pretrained,loss_hist,metric_hist=train_val(resnet18_pretrained,params_train)

# 获取训练参数中的训练轮数
num_epochs=params_train["num_epochs"]# 绘制训练和验证损失曲线
plt.title("Train-Val Loss")
plt.plot(range(1,num_epochs+1),loss_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),loss_hist["val"],label="val")
plt.ylabel("Loss")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()# 绘制训练和验证准确率曲线
plt.title("Train-Val Accuracy")
plt.plot(range(1,num_epochs+1),metric_hist["train"],label="train")
plt.plot(range(1,num_epochs+1),metric_hist["val"],label="val")
plt.ylabel("Accuracy")
plt.xlabel("Training Epochs")
plt.legend()
plt.show()

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

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

相关文章

新电脑如何设置 npm 源及查看源、安装 cnpm、pnpm 和 yarn 的详细教程

当你获得一台新电脑&#xff0c;或需要在现有电脑上优化 JavaScript 和 Node.js 的开发环境时&#xff0c;正确配置 npm 是一步不可少的过程。本教程将详细指导你如何设置 npm 源&#xff0c;查看当前源&#xff0c;以及如何安装 cnpm、pnpm 和 yarn。 1. 设置 npm 源 npm (N…

one-api 源码调试配置

本文主要介绍通过 VSCode 调试 one-api 源码。 一、环境配置 1.1 VSCode 和 one-api 安装 首先,确保已经安装了 VSCode(下载链接)和 one-api 源码(下载链接)已下载并安装了依赖 1.2 安装 Go 插件 在 VSCode 中,安装 Go 插件。 1.3 安装 dlv 调试包 可以通过下载源码…

【黑马java基础】多线程

什么是线程&#xff1f; 线程(Thread)是一个程序内部的一条执行流程。 这个是一条执行流程&#xff0c;虽然有循环&#xff0c;但是最后只有一条流程往前推进&#xff0c;所以视为一条。 程序中如果只有一条执行流程&#xff0c;那这个程序就是单线程的程序。 程序是指令序列…

Ubuntu20.04安装Elasticsearch

简介 ELK&#xff08;Elasticsearch, Logstash, Kibana&#xff09;是一套开源的日志管理和分析工具&#xff0c;用于收集、存储、分析和可视化日志数据。以下是如何在Ubuntu服务器上安装和配置ELK堆栈以便发送和分析日志信息的步骤。 安装Elasticsearch 首先&#xff0c;安…

vue3——利用自定义指令实现下拉框分页懒加载

需求&#xff1a;下拉框一开始请求第一页的内容&#xff0c;滚动到最后的时候&#xff0c;请求第二页的内容&#xff0c;如此反复&#xff0c;直到所有数据加载完成。 selectLoadMore.ts //自定义指令&#xff1a;实现下拉框下拉到末尾时&#xff0c;加载下一页的内容 // 使用…

【系统架构设计师】十八、架构设计实践(信息系统架构设计理论与实践2)

目录 四、企业信息系统的总体框架 4.1 战略系统 4.2 业务系统 4.3 应用系统 4.4 企业信息基础设施 4.5 业务流程重组BPR 4.6 业务流程管理BPM 五、信息系统架构设计方法 5.1 行业标准的体系架构框架 5.2 架构开发方法 5.3 信息化总体架构方法 5.4 信息化建设生命周…

防火墙——网络环境支持

目录 网络环境支持 防火墙的组网 web连接上防火墙 web管理口 让防火墙接到网络环境中 ​编辑 管理员用户管理 缺省管理员 接口 配置一个普通接口 创建安全区域 路由模式 透明模式 混合模式 防火墙的安全策略 防火墙转发流程 与传统包过滤的区别 创建安全策略 …

DDoS攻击:威胁与防护策略

DDoS&#xff08;分布式拒绝服务&#xff09;攻击是网络安全领域的一大挑战&#xff0c;对企业造成严重的影响。本文将深入探讨DDoS攻击的原理和防护方法。 DDoS攻击的原理 DDoS攻击通过大量请求&#xff0c;使目标系统无法响应正常请求。攻击者利用多台计算机发送大量请求&am…

气膜羽毛球馆的维护和运营成本解析—轻空间

随着人们对健康生活方式的追求不断增加&#xff0c;羽毛球这项运动也愈发受到欢迎。然而&#xff0c;传统的羽毛球馆往往存在建设周期长、成本高、维护复杂等问题。气膜羽毛球馆作为一种新型的运动场馆解决方案&#xff0c;因其快速搭建、环保节能、舒适环境等优势而逐渐被广泛…

跨平台桌面应用程序框架Electron

用于构建跨平台桌面应用程序的框架。Electron 由 GitHub 开发&#xff0c;它允许开发者使用 Web 技术&#xff08;如 HTML、CSS 和 JavaScript&#xff09;来创建桌面软件。Electron 基于 Node.js 和 Chromium&#xff0c;因此可以提供丰富的功能和性能。 Electron 的主要优点…

netty入门-5 ServerBootstrap与Bootstarp

前言 本来这篇应该紧接着说明Future和Promise。 但是考虑前文第三篇即用到了ServerBootstrap来启动一个服务器&#xff0c;并且我读的闪电侠netty&#xff0c;先写的服务器与客户端启动这部分。索性就先写出来了。主要内容来自闪电侠netty ServerBootstrap ServerBootstrap就…

LabVIEW和IQ测试仪进行WiFi测试

介绍一个使用LabVIEW和LitePoint IQxel-MW IQ测试仪进行WiFi测试的系统。包括具体的硬件型号、如何实现通讯、开发中需要注意的事项以及实现的功能。 使用的硬件​ IQ测试仪型号: LitePoint IQxel-MW 电脑: 配置高效的台式机或笔记本电脑 路由器: 支持802.11ax (Wi-Fi 6) 的…

C语言 | Leetcode C语言题解之第282题给表达式添加运算符

题目&#xff1a; 题解&#xff1a; #define MAX_COUNT 10000 // 解的个数足够大 #define NUM_COUNT 100 // 操作数的个数足够大 long long num[NUM_COUNT] {0};long long calc(char *a) { // 计算表达式a的值// 将数字和符号&#xff0c;入栈memset(num, 0, sizeof(num));in…

探索自注意力机制:目标检测领域的革新者

探索自注意力机制&#xff1a;目标检测领域的革新者 在深度学习的目标检测领域&#xff0c;自注意力机制&#xff08;Self-Attention Mechanism&#xff09;以其独特的能力&#xff0c;为处理图像中的目标提供了一种全新的视角。自注意力机制允许模型在处理图像时&#xff0c;…

Android MVVM最佳实践(LifecyclesRetrofit)

当结合MVVM架构、Lifecycle以及网络请求时&#xff0c;通常会使用Retrofit库来进行网络请求操作。以下是如何在Android应用中整合Retrofit进行网络请求&#xff0c;并与MVVM架构和Lifecycle结合的示例&#xff1a; 1. 添加依赖项 确保在项目的build.gradle文件中添加Retrofit…

开发环境搭建:步入C++编程世界的基石

在探索C++这一强大而灵活的编程语言时,搭建一个高效、舒适的开发环境是每位初学者的首要任务。开发环境不仅影响着编程的效率,还直接关系到编程体验和学习效果。本文将详细阐述如何为C++编程搭建一个全面的开发环境,从选择合适的IDE(集成开发环境)、配置编译器,到管理项目…

2024大家都想掌握的4种PDF翻译技巧

借着互联网的东风现在全球化的交流越发频繁&#xff0c;很多时候都会遇到跨语言交流的问题。外语不好的小伙伴阅读外国文献的时候应该都很头疼吧&#xff0c;这时候pdf翻译成中文的工具就可以解决这个问题啦。 1.福昕翻译 直通车&#xff1a;https://fanyi.pdf365.cn/ 这个…

@Builder注释导致@RequestBody的前端json反序列化失败,HTTP400

项目里发生了一个bug&#xff0c;就是前端请求一个接口时候&#xff0c;报了HTTP 400 Bad Request 通常来说这个问题是前后端的参数没对齐&#xff0c;比如前端传了个String&#xff0c;但后端对应的是Integer。 所以我就排查了半天&#xff0c;结果没发现啥错误&#xff0c;…

PSINS工具箱函数介绍——insplot

insplot是一个绘图命令,用于将avp数据绘制出来 本文所述的代码需要基于PSINS工具箱,工具箱的讲解: PSINS初学指导基于PSINS的相关程序设计(付费专题)使用方法 此函数使用起来也很简单,直接后面加avp即可,如: insplot(avp);其中,avp为: 每行表示一个时间1~3列为姿态…

量化交易策略解读

光大证券-20190606-重构情绪体系&#xff0c;探知市场温度——市场情绪体系系列报告之二.pdf 市场情绪与股市择时体系研究 市场情绪的重要性 市场情绪反映了投资者心理状态的集体体现&#xff0c;对市场走势有同步或滞后的影响&#xff0c;并在某些情况下预示市场转折点。 择…