PyTorch笔记9----------Cifar10图像分类

1.图像分类网络模型框架解读

  • 分类网络的基本结构
    • 数据加载模块：对训练数据加载
    • 数据重组：组合成网络需要的形式，例如预处理、增强、各种网络处理、loss函数计算
    • 优化器
  • 数据加载模块
    • 使用公开数据集：torchvision.datasets
    • 使用自定义数据集：torch.utils.data下的Dataset、DataLoader
  • 数据增强模块
    • 使用torchvision.transforms

2.Cifar10数据读取

Cifar10数据集下载链接：https://pan.baidu.com/s/1Dc6eQ54CCLFdCA2ORuFChg 提取码: 5279

下在好的数据集解压后的文件

创建两个文件夹dataTrain和dataTest用于存储数据集的图片

将数据集中的训练集图片和测试集图片存入自建的文件夹中，代码如下:

import os
import cv2
import numpy as np
import glob
def unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='bytes')return dict
label_name = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck'
]
# train_list = glob.glob('cifar-10-batches-py/data_batch_*') #下载训练集图片时使用此行
train_list = glob.glob('cifar-10-batches-py/test_batch*')
# save_path = 'cifar-10-batches-py/dataTrain' #下载训练集图片时使用此行
save_path = 'cifar-10-batches-py/dataTest'
for l in train_list:l_dict = unpickle(l)for im_idx,im_data in enumerate(l_dict[b'data']):im_label = l_dict[b'labels'][im_idx]im_name = l_dict[b'filenames'][im_idx]im_label_name = label_name[im_label]im_data = np.reshape(im_data,[3,32,32])im_data = np.transpose(im_data,(1,2,0))if not os.path.exists("{}/{}".format(save_path,im_label_name)):os.mkdir("{}/{}".format(save_path,im_label_name))cv2.imwrite("{}/{}/{}".format(save_path,im_label_name,im_name.decode("utf-8")),im_data)

3.自定数据集加载

from torchvision import transforms
from torch.utils.data import  DataLoader, Dataset
import os
from PIL  import Image
import numpy as np
import glob 
label_name = ['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck'
]
label_dict = {}
for idx,name in enumerate(label_name):label_dict[name] = idx
def default_loader(path):return Image.open(path).convert('RGB')
#数据增强方法
train_transform = transforms.Compose([transforms.RandomResizedCrop((28,28)), #随机裁剪transforms.RandomHorizontalFlip(), #随机水平翻转transforms.RandomVerticalFlip(), #随机垂直翻转transforms.RandomRotation(90), #随机旋转transforms.RandomGrayscale(0.1), #随机灰度化transforms.ColorJitter(0.3,0.3,0.3,0.3), #随机颜色调整transforms.ToTensor() #转换为张量
])
class MyDataset(Dataset):def __init__(self,im_list,transform=None,loader=default_loader): super(MyDataset,self).__init__()imgs = []for im_item in im_list:im_label_name = im_item.split("/")[-2]imgs.append([im_item,label_dict[im_label_name]])self.imgs = imgsself.transform = transformself.loader = loaderdef __getitem__(self,index):im_path,im_label = self.img[index]im_data = self.loader(im_path)if self.transform is not None:im_data = self.transform(im_data)return im_data,im_labeldef __len__(self):return len(self.imgs)
im_train_list = glob.glob("cifar-10-batches-py/dataTrain/*/*.png") #获取训练集图片路径列表
im_test_list = glob.glob("cifar-10-batches-py/dataTest/*/*.png") #获取测试集图片路径列表
train_dataset = MyDataset(im_train_list,transform=train_transform) #创建训练集数据集
test_dataset = MyDataset(im_test_list,transform=transforms.ToTensor()) #创建测试集数据集
train_data_loader = DataLoader(dataset=train_dataset,batch_size=6,shuffle=True,num_workers=4)#创建训练集数据加载器
test_data_loader = DataLoader(dataset=train_dataset,batch_size=6,shuffle=False,num_workers=4)#创建测试集数据加载器
print("num_of_train:",len(train_dataset))
print("num_of_test:",len(test_dataset))

代码运行结果：

num_of_train: 50000
num_of_test: 10000

 4.VGG网络搭建

  • 模型网络搭建
import torch
import torch.nn as nn
import torch.nn.functional as F
#定义vgg网络
class VGGbase(nn.Module):#定义vgg网络的初始化函数def __init__(self):super(VGGbase,self).__init__() #调用父类的初始化函数#定义第一个卷积层，图像大小：28*28self.conv1 = nn.Sequential(nn.Conv2d(3,64,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(64),nn.ReLU())self.max_pooling1 = nn.MaxPool2d(kernel_size=2,stride=2) #定义最大池化层#定义第二个卷积层，图像大小：14*14self.conv2_1 = nn.Sequential(nn.Conv2d(64,128,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(128),nn.ReLU())self.conv2_2 = nn.Sequential(nn.Conv2d(128,128,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(128),nn.ReLU())self.max_pooling2 = nn.MaxPool2d(kernel_size=2,stride=2) #定义最大池化层#定义第三个卷积层，图像大小：7*7self.conv3_1 = nn.Sequential(nn.Conv2d(128,256,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(256),nn.ReLU())self.conv3_2 = nn.Sequential(nn.Conv2d(256,256,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(256),nn.ReLU())self.max_pooling3 = nn.MaxPool2d(kernel_size=2,stride=2,padding=1) #定义最大池化层##定义第四个卷积层，图像大小：4*4self.conv4_1 = nn.Sequential(nn.Conv2d(256,512,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(512),nn.ReLU())self.conv4_2 = nn.Sequential(nn.Conv2d(512,512,kernel_size=3,stride=1,padding=1),nn.BatchNorm2d(512),nn.ReLU())self.max_pooling4 = nn.MaxPool2d(kernel_size=2,stride=2,padding=1) #定义最大池化层#定义FC层self.fc = nn.Linear(4608, 10)#定义vgg网络的前向传播函数def forward(self,x):batchsize = x.size(0)out = self.conv1(x)out = self.max_pooling1(out)out = self.conv2_1(out)out = self.conv2_2(out)out = self.max_pooling2(out)out = self.conv3_1(out)out = self.conv3_2(out)out = self.max_pooling3(out)out = self.conv4_1(out)out = self.conv4_2(out)out = self.max_pooling4(out)out = out.view(batchsize,-1) #将输出的三维特征图转换为一维向量out = self.fc(out)out = F.log_softmax(out,dim=1) #使用log_softmax函数作为激活函数return out
def VGGNet():return VGGbase()
  • 模型训练
import torch
import torch.nn as nn
import torchvision
from vggnet import  VGGNet
from cifar10Data import train_data_loader, test_data_loader
import os
import tensorboardX
# 定义训练设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 训练轮数
epoch_num = 200
# 学习率
lr = 0.01
# 加载网络
net = VGGNet().to(device)
#定义loss
loss_func = nn.CrossEntropyLoss()
#定义优化器
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
# 学习率衰减
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)
if not os.path.exists("log"):os.mkdir("log")
writer = tensorboardX.SummaryWriter("log")
step_n = 0
for epoch in range(epoch_num):print("epoch is:",epoch)#训练for i,data in enumerate(train_data_loader):net.train()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()writer.add_scalar("train loss",loss.item(),global_step=step_n)im = torchvision.utils.make_grid(inputs)writer.add_image("train image",im,global_step=step_n)step_n += 1if not os.path.exists("models"):os.mkdir("models")torch.save(net.state_dict(),"models/{}.path".format(epoch+1))scheduler.step()sum_loss = 0#测试for i,data in enumerate(train_data_loader):net.eval()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()sum_loss += loss.item()im = torchvision.utils.make_grid(inputs)writer.add_image("test image", im, global_step=step_n)test_loss = sum_loss * 1.0 / len(train_data_loader)writer.add_scalar("teest loss", test_loss, global_step=epoch+1)print('test_step:', i, 'loss is:', test_loss)
writer.close()
  • 训练结果
epoch is: 0
test_step: 8333 loss is: 2.306014501994137
epoch is: 1
test_step: 8333 loss is: 2.220694358253868
epoch is: 2
test_step: 8333 loss is: 2.1626519183618202
epoch is: 3
  • 图表结果

5. ResNet网络搭建

  • 模型网络搭建
import torch
import torch.nn as nn
import torch.nn.functional as F
# 定义ResNet内部结构
class ResBlock(nn.Module):def __init__(self,in_channel,out_channel,stride=1):super(ResBlock,self).__init__()#主干分支self.layer = nn.Sequential(nn.Conv2d(in_channel,out_channel,kernel_size=3,stride=stride,padding=1),nn.BatchNorm2d(out_channel),nn.ReLU(),nn.Conv2d(out_channel, out_channel, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(out_channel),)#跳连分支,需要判断是否需要跳连分支self.shortcut = nn.Sequential()if in_channel != out_channel or stride > 1:self.shortcut = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, padding=1),nn.BatchNorm2d(out_channel),)def forward(self, x):out1 =  self.layer(x)out2 = self.shortcut(x)out = out1 + out2out = F.relu(out)return out#ResNet模型搭建
class ResNet(nn.Module):def make_layer(self,block,out_channel,stride,num_block):layers_list = []for i in range(num_block):if i == 0:in_stride = strideelse:in_stride = 1layers_list.append(block(self.in_channel,out_channel,in_stride))self.in_channel = out_channelreturn nn.Sequential(*layers_list)def __init__(self,ResBlock):super(ResNet,self).__init__()self.in_channel = 32self.conv1 = nn.Sequential(nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(32),nn.ReLU(),)self.layer1 = self.make_layer(ResBlock,64,2,2)self.layer2 = self.make_layer(ResBlock, 128, 2, 2)self.layer3 = self.make_layer(ResBlock, 256, 2, 2)self.layer4 = self.make_layer(ResBlock, 512, 2, 2)self.fc = nn.Linear(512,10)def forward(self, x):out = self.conv1(x)out = self.layer1(out)out = self.layer2(out)out = self.layer3(out)out = self.layer4(out)out = F.avg_pool2d(out, 2)out = out.view(out.size(0), -1)out = self.fc(out)return out
def resnet():return ResNet(ResBlock)
  • 模型训练
import torch
import torch.nn as nn
import torchvision
from resnet import  resnet
from cifar10Data import train_data_loader, test_data_loader
import os
import tensorboardX
# 定义训练设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 训练轮数
epoch_num = 200
# 学习率
lr = 0.01
# 加载网络
net = resnet().to(device)
#定义loss
loss_func = nn.CrossEntropyLoss()
#定义优化器
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
# 学习率衰减
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)
if not os.path.exists("log1"):os.mkdir("log1")
writer = tensorboardX.SummaryWriter("log1")
step_n = 0
for epoch in range(epoch_num):print("epoch is:",epoch)#训练for i,data in enumerate(train_data_loader):net.train()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()writer.add_scalar("train loss",loss.item(),global_step=step_n)im = torchvision.utils.make_grid(inputs)writer.add_image("train image",im,global_step=step_n)step_n += 1if not os.path.exists("models"):os.mkdir("models")torch.save(net.state_dict(),"models/{}.path".format(epoch+1))scheduler.step()sum_loss = 0#测试for i,data in enumerate(train_data_loader):net.eval()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()sum_loss += loss.item()im = torchvision.utils.make_grid(inputs)writer.add_image("test image", im, global_step=step_n)test_loss = sum_loss * 1.0 / len(train_data_loader)writer.add_scalar("teest loss", test_loss, global_step=epoch+1)print('test_step:', i, 'loss is:', test_loss)
writer.close()
  • 训练结果
epoch is: 0
test_step: 8333 loss is: 2.3071022295024948
epoch is: 1
test_step: 8333 loss is: 2.226925660673022
epoch is: 2
test_step: 8333 loss is: 2.155742327815656
epoch is: 3
test_step: 8333 loss is: 2.11763518281998
epoch is: 4
test_step: 8333 loss is: 2.0863706607283063
  • 图表结果

6.MobileNetv1网络搭建

  • 模型网络搭建
import torch
import torch.nn.functional as F
import torch.nn as nn
class mobilenet(nn.Module):def conv_dw(self,in_channel, out_channel, stride):return nn.Sequential(nn.Conv2d(in_channels=in_channel, out_channels=in_channel, kernel_size=3, stride=stride, padding=1,groups=in_channel, bias=False),nn.BatchNorm2d(in_channel),nn.ReLU(),nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=1, stride=1, padding=0, bias=False),nn.BatchNorm2d(out_channel),nn.ReLU(),)def __init__(self):super(mobilenet, self).__init__()self.conv1 = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1),nn.BatchNorm2d(32),nn.ReLU(),)self.conv_dw2 = self.conv_dw(32, 32, 1)self.conv_dw3 = self.conv_dw(32, 64, 2)self.conv_dw4 = self.conv_dw(64, 64, 1)self.conv_dw5 = self.conv_dw(64, 128, 2)self.conv_dw6 = self.conv_dw(128, 128, 1)self.conv_dw7 = self.conv_dw(128, 256, 2)self.conv_dw8 = self.conv_dw(256, 256, 1)self.conv_dw9 = self.conv_dw(256, 512, 2)self.fc = nn.Linear(512,10)def forward(self, x):out = self.conv1(x)out = self.conv_dw2(out)out = self.conv_dw3(out)out = self.conv_dw4(out)out = self.conv_dw5(out)out = self.conv_dw6(out)out = self.conv_dw7(out)out = self.conv_dw8(out)out = self.conv_dw9(out)out = F.avg_pool2d(out, 2)out = out.view(-1,512)out = self.fc(out)return out
def mobilenetv1_small():return mobilenet()
  • 模型训练
import torch
import torch.nn as nn
import torchvision
from mobilenetv1 import  mobilenetv1_small
from cifar10Data import train_data_loader, test_data_loader
import os
import tensorboardX
# 定义训练设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 训练轮数
epoch_num = 200
# 学习率
lr = 0.01
# 加载网络
net = mobilenetv1_small().to(device)
#定义loss
loss_func = nn.CrossEntropyLoss()
#定义优化器
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
# 学习率衰减
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)
if not os.path.exists("log2"):os.mkdir("log2")
writer = tensorboardX.SummaryWriter("log2")
step_n = 0
for epoch in range(epoch_num):print("epoch is:",epoch)#训练for i,data in enumerate(train_data_loader):net.train()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()writer.add_scalar("train loss",loss.item(),global_step=step_n)im = torchvision.utils.make_grid(inputs)writer.add_image("train image",im,global_step=step_n)step_n += 1if not os.path.exists("models"):os.mkdir("models")torch.save(net.state_dict(),"models/{}.path".format(epoch+1))scheduler.step()sum_loss = 0#测试for i,data in enumerate(train_data_loader):net.eval()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()sum_loss += loss.item()im = torchvision.utils.make_grid(inputs)writer.add_image("test image", im, global_step=step_n)test_loss = sum_loss * 1.0 / len(train_data_loader)writer.add_scalar("test loss", test_loss, global_step=epoch+1)print('test_step:', i, 'loss is:', test_loss)
writer.close()
  • 训练结果
epoch is: 0
test_step: 8333 loss is: 2.3168991455678207
epoch is: 1
test_step: 8333 loss is: 58.0813152680072
epoch is: 2
test_step: 8333 loss is: 239.99653513472458
epoch is: 3
test_step: 8333 loss is: 1036.717976929159
epoch is: 4
test_step: 8333 loss is: 110.44223031090523
  • 图表结果

7.Inception网络搭建

  • 模型网络搭建
import torch
import torch.nn as nn
import torch.nn.functional as F
def ConvBNRelu(in_channel, out_channel, kernel_size):return nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size, padding=kernel_size//2),nn.BatchNorm2d(out_channel),nn.ReLU(inplace=True),)
class BaseInception(nn.Module):def __init__(self,in_channel,out_channel_list,reduce_channel_list):super(BaseInception, self).__init__()self.branch1_conv = ConvBNRelu(in_channel, out_channel_list[0], 1)self.branch2_conv1 = ConvBNRelu(in_channel, reduce_channel_list[0], 1)self.branch2_conv2 = ConvBNRelu(reduce_channel_list[0], out_channel_list[1], 3)self.branch3_conv1 = ConvBNRelu(in_channel, reduce_channel_list[1], 1)self.branch3_conv2 = ConvBNRelu(reduce_channel_list[1], out_channel_list[2], 5)self.branch4_pool = nn.MaxPool2d(3, 1, padding=1)self.branch4_conv = ConvBNRelu(in_channel, out_channel_list[3], 3)def forward(self, x):out1 = self.branch1_conv(x)out2 = self.branch2_conv1(x)out2 = self.branch2_conv2(out2)out3 = self.branch3_conv1(x)out3 = self.branch3_conv2(out3)out4 = self.branch4_pool(x)out4 = self.branch4_conv(out4)out = torch.cat([out1, out2, out3, out4], 1)return outclass InceptionNet(nn.Module):def __init__(self):super(InceptionNet, self).__init__()self.block1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=1),nn.BatchNorm2d(64),nn.ReLU(),)self.block2 = nn.Sequential(nn.Conv2d(64,128,kernel_size=3,stride=2,padding=1),nn.BatchNorm2d(128),nn.ReLU(),)self.block3 = nn.Sequential(BaseInception(in_channel=128, out_channel_list=[64, 64, 64, 64], reduce_channel_list=[16, 16]),nn.MaxPool2d(3, stride=2, padding=1))self.block4 = nn.Sequential(BaseInception(in_channel=256, out_channel_list=[96, 96, 96, 96], reduce_channel_list=[32, 32]),nn.MaxPool2d(3, stride=2, padding=1))self.fc = nn.Linear(384,10)def forward(self, x):out = self.block1(x)out = self.block2(out)out = self.block3(out)out = self.block4(out)out = F.avg_pool2d(out, 2)out = out.view(out.size(0), -1)out = self.fc(out)return out
def InceptionNetSmall():return InceptionNet()
  • 模型训练
import torch
import torch.nn as nn
import torchvision
from inception import  InceptionNetSmall
from cifar10Data import train_data_loader, test_data_loader
import os
import tensorboardX
# 定义训练设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# 训练轮数
epoch_num = 200
# 学习率
lr = 0.01
# 加载网络
net = InceptionNetSmall().to(device)
#定义loss
loss_func = nn.CrossEntropyLoss()
#定义优化器
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
# 学习率衰减
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)
if not os.path.exists("log3"):os.mkdir("log3")
writer = tensorboardX.SummaryWriter("log3")
step_n = 0
for epoch in range(epoch_num):print("epoch is:",epoch)#训练for i,data in enumerate(train_data_loader):net.train()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()writer.add_scalar("train loss",loss.item(),global_step=step_n)im = torchvision.utils.make_grid(inputs)writer.add_image("train image",im,global_step=step_n)step_n += 1if not os.path.exists("models"):os.mkdir("models")torch.save(net.state_dict(),"models/{}.path".format(epoch+1))scheduler.step()sum_loss = 0#测试for i,data in enumerate(train_data_loader):net.eval()inputs,labels = datainputs,labels = inputs.to(device),labels.to(device)outputs = net(inputs)loss = loss_func(outputs,labels)optimizer.zero_grad()loss.backward()optimizer.step()sum_loss += loss.item()im = torchvision.utils.make_grid(inputs)writer.add_image("test image", im, global_step=step_n)test_loss = sum_loss * 1.0 / len(train_data_loader)writer.add_scalar("test loss", test_loss, global_step=epoch+1)print('test_step:', i, 'loss is:', test_loss)
writer.close()
  • 训练结果
epoch is: 0
test_step: 8333 loss is: 2.1641721504324485
epoch is: 1
test_step: 8333 loss is: 2.106510695047678
epoch is: 2
test_step: 8333 loss is: 2.0794332600881478
epoch is: 3
test_step: 8333 loss is: 2.0550003183926497
  • 图表结果

8.Pytorch提供的ResNet18模型

  • pytorch中提供了很多模型，都在torchvision的models中
  • 训练代码与前面的相同，只需要将模型引入，替换net的赋值即可，训练结果也与此前无太大差异，此处就不过多赘述，只给出模型代码
import torch.nn as nn
from torchvision import models
class resnet18(nn.Module):def __init__(self):super(resnet18, self).__init__()self.model = models.resnet18(pretrained=True)self.num_features = self.model.fc.in_featuresself.model.fc = nn.Linear(self.num_features, 10)def forward(self, x):out = self.model(x)return out
def pytorch_resnet18():return resnet18()

全部代码的文件结构为：

知识点为听课总结笔记，课程为B站“2025最新整合！公认B站讲解最强【PyTorch】入门到进阶教程，从环境配置到算法原理再到代码实战逐一解读，比自学效果强得多！”：2025最新整合！公认B站讲解最强【PyTorch】入门到进阶教程，从环境配置到算法原理再到代码实战逐一解读，比自学效果强得多！_哔哩哔哩_bilibili

其实课程后续还有检测和分割，但是这两部分是在讲别人训练好的模型，不好做笔记，大家如果需要可以自己去看看！

所以，Pytorch学习完结撒花！！！！！！！！！！！！

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

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

相关文章

飞凌OK3568开发板QT应用程序编译流程

飞凌OK3568开发板QT应用程序编译流程

飞凌OK3568开发板QT应用程序编译流程开发环境：ubuntu20.04（主机）、飞凌OK3568开发板一般在linux系统下开发用于ARM开发板的QT应用程序时，直接在主机上开发然后进行交叉编译即可，但有时候ARM开发板的厂家提供的SDK中可能…
阅读更多...
飞算JavaAI合并项目实战：7天完成3年遗留系统重构

飞算JavaAI合并项目实战：7天完成3年遗留系统重构

引言 企业数字化进程中，遗留系统改造始终是CIO面临的头号难题。某电商平台的实践数据显示：3年以上的Java项目平均存在47%的冗余代码，63%的架构设计不符合当前业务需求，进行系统性重构需要投入相当于原开发量200%的资源。传统&quo…
阅读更多...
卫星速度增量和比冲及推力之间的关系

卫星速度增量和比冲及推力之间的关系

一、定义1.1.比冲（Isp）：比冲是衡量发动机性能的重要指标，反映了单位重量推进剂在发动机中产生的冲量，单位为米/秒（m/s），代表燃料燃烧时喷流速度。这个单位与速度单位“米/秒”相同&a…
阅读更多...
MATLAB绘制各种心形曲线

MATLAB绘制各种心形曲线

1.方程(1)心形线的经典隐函数方程为：(2)参数方程（更平滑的心形）：(3)极坐标心形线(4)参数方程（3D心形）(5)隐函数3D心形2. MATLAB代码clc;close all;clear all;warning off;%清除变量 rand(seed, 100); randn…
阅读更多...
Django REST Framework视图

Django REST Framework视图

Django REST Framework (DRF) 视图类详解DRF 提供了丰富的视图类来构建 API，从基础到高级，满足不同复杂度的需求。以下是 DRF 的主要视图类及其使用场景：1. 基础视图类APIView所有 DRF 视图的基类，相当于 Django 的 View 类的增强…
阅读更多...
Linux面试题及详细答案 120道（1-15）-- 基础概念

Linux面试题及详细答案 120道（1-15）-- 基础概念

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs&…
阅读更多...
week1-[分支结构]中位数

week1-[分支结构]中位数

week1-[分支结构]中位数 题目描述 给定 444 个正整数 a,b,c,da,b,c,da,b,c,d，输出它们的中位数，答案四舍五入保留 111 位小数。 输入格式 输入共 111 行 444 个正整数 a,b,c,da,b,c,da,b,c,d。 输出格式 输出共 111 行 111 个浮点数表示答案。 样例 #1 样…
阅读更多...
[激光原理与应用-259]：理论 - 几何光学 - 平面镜的反射、平面透镜的折射、平面镜的反射成像、平面透镜的成像的规律

[激光原理与应用-259]：理论 - 几何光学 - 平面镜的反射、平面透镜的折射、平面镜的反射成像、平面透镜的成像的规律

一、平面镜的反射规律平面镜的反射遵循镜面反射定律，即光线在光滑表面（反射面平整度远大于波长）发生反射时，满足以下条件：反射光线、入射光线与法线共面：反射光线、入射光线和法线（垂直于反射面…
阅读更多...
相机按键功能解析

相机按键功能解析

相机按键功能解析佳能相机按键机身背面机身正面机身顶部机身侧面 佳能相机按键 机身背面取景器目镜：用于拍摄时观察相机形成的图像。实拍显示/视频拍摄按钮：按下即可开始拍摄或录制视频。光圈/曝光补偿键：调整光圈大小和曝光补偿，…
阅读更多...
51单片机-驱动LED模块教程

51单片机-驱动LED模块教程

本章思维导图： 51单片机驱动LED灯模块 LED灯元器件简介 LED（Light Emitting Diode，发光二极管） 是一种固态半导体器件，通过P-N结中电子与空穴复合直接将电能转化为光能。其核心结构由P型半导体（空穴主导&a…
阅读更多...
Git 完全手册：从入门到团队协作实战（2）

Git 完全手册：从入门到团队协作实战（2）

Hello大家好&#xff01;很高兴我们又见面啦&#xff01;给生活添点passion&#xff0c;开始今天的编程之路&#xff01; 我的博客&#xff1a;<但凡. 我的专栏&#xff1a;《编程之路》、《数据结构与算法之美》、《C修炼之路》、《Linux修炼&#xff1a;终端之内 洞悉真理…
阅读更多...
c语言中堆和栈的区别

c语言中堆和栈的区别

1.栈区(stack):由编译器自动分配释放&#xff0c;栈主要用于存储局部变量、函数参数、函数调用和返回信息等。其操作方式类似于数据结构中的栈。 2.堆区(heap):一般由程序员分配释放&#xff0c;若程序员不释放&#xff0c;则可能会引起内存泄漏。注堆和数据结构中的堆栈不一样…
阅读更多...
华为实验WLAN 基础配置随练

华为实验WLAN 基础配置随练

业务vlan 20 192.168.20.x管理vlan 100 192.168.100.x步骤① 网络互通Core sw:vlan batch 20 100 dhcp enable int vlanif 20IP add 192.168.20.1 24dhcp select interfaceinterface GigabitEthernet0/0/1/2port link-type trunkport trunk pvid vlan 100port trunk allow-pas…
阅读更多...
CMake 如何查找 Python2和Python3

CMake 如何查找 Python2和Python3

问题 在一个CMakeLists.txt文件里面看到了下面的这句话 find_package(Python2 COMPONENTS Interpreter Development NumPy)这个好有趣啊&#xff0c;Python2也是一个C的库吗&#xff0c;也有Python2Config.cmake或者FindPython2.cmake? 回答 find_package(Python2 COMPONENTS …
阅读更多...
心灵笔记：刻意练习

心灵笔记：刻意练习

心灵笔记&#xff1a;刻意练习提要 所有人都以为“杰出”源于“天赋”&#xff0c;而“天才”却说&#xff1a;我的成就源于“正确的练习”&#xff01; 定义&#xff1a;刻意练习是一种有目的、有方法、能带来能力持续提升的结构化训练方式&#xff0c;它并非简单的重复劳动&a…
阅读更多...
langchain入门笔记03：使用fastapi部署本地大模型后端接口，优化局域网内的问答响应速度

langchain入门笔记03：使用fastapi部署本地大模型后端接口，优化局域网内的问答响应速度

文章目录前言一、fastapi的简单入门1&#xff1a;安装必要的包&#xff08;python3.11&#xff09;&#xff1a;2&#xff1a;快速搭建一个fastapi&#xff1a;二、提升问答的响应速度1. fastapi部署后端接口&#xff0c;在局域网内访问的方法2. 局域网内的测试&#xff1a;“未…
阅读更多...
【CDA 新一级】学习笔记第1篇：数据分析的时代背景

【CDA 新一级】学习笔记第1篇：数据分析的时代背景

作者&#xff1a;CDA持证人 张九领我们要学习数据分析&#xff0c;就要从当前时代的数据特点&#xff0c;找到在时代特点下企业需要数据分析的痛点&#xff0c;然后理解数据分析在企业中的作用。当前时代&#xff0c;数据分析的特征是哪些呢&#xff1f;我们用VUCA来概括数据分…
阅读更多...
Vite 为什么比 Webpack 快？原理深度分析

Vite 为什么比 Webpack 快？原理深度分析

Hi&#xff0c;我是布兰妮甜 &#xff01;在现代前端开发中&#xff0c;构建工具的性能直接影响开发体验和生产力。Webpack 作为传统打包工具的代表&#xff0c;长期以来主导着前端构建领域&#xff0c;而 Vite 作为新一代的前端构建工具&#xff0c;凭借其出色的开发服务器启动…
阅读更多...
数字电路上的通讯速度是越快越好还是越慢越好？

数字电路上的通讯速度是越快越好还是越慢越好？

昨天我突发奇想&#xff0c;修改了一下MCU和INA226以及DAC8551的通讯速率。之前的INA226用的是I2C通讯&#xff0c;之前设置的速率是100Kbps&#xff0c;DAC8551是SPI通讯&#xff0c;速率是10Mbps&#xff0c;昨天修改之前输出位置的测试结果如图&#xff1a;可以看到&#xf…
阅读更多...
Google Gemini 的深度研究终于进入 API 阶段

Google Gemini 的深度研究终于进入 API 阶段

Google Gemini 最强大的功能之一是深度研究&#xff0c;但到目前为止&#xff0c;它一直严格限制在 Gemini 界面上。这种情况可能很快就会改变。 通过 Gemini 中的深度研究&#xff0c;您可以搜索几乎任何内容&#xff0c;包括学者、现有研究论文等。 谷歌将深度研究描述为一…
阅读更多...
最新文章

Copyright @ 2022~2023