PyTorch深度学习快速入门（下）

news2024/9/9 0:43:46

PyTorch深度学习快速入门（下）

  • 一、现有网络模型的使用及修改
    • （一）背景知识
    • （二）修改网络模型的三种方法
  • 二、网络模型的保存与加载
    • （一）保存网络模型的两种方法
    • （二）加载网络模型的两种方法
  • 三、完整的模型训练套路
    • （一）背景知识
    • （二）代码实战
  • 四、GPU 训练
    • （一）训练方式1 — 调用 .cuda( ) 来改
    • （二）训练方式2 — 调用 .to( device ) 来改
  • 五、完整的模型验证套路（测试 / demo）
  • 六、看看GitHub上的开源项目
    • （一）看一个项目，先看README
    • （二）再看 train.py 文件中的整体架构
    • （三）将函数中 required=True 的地方用 default= ……替换

一、现有网络模型的使用及修改

（一）背景知识

（1）本质：迁移学习，即利用现有的网络，去改变它的结构(微调)
（2）所用模型与数据集的解介绍
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（3）pretrained设置为True或False的区别

  • False：只是加载了网络架构，参数都是初始化的默认参数
  • True：从网络中下载每个卷积层在数据集上训练好的参数
    在这里插入图片描述

（二）修改网络模型的三种方法

import torchvision
from torch import nn

# traindata = torchvision.datasets.ImageNet("./data_image_net",split='train',download=True,
#                                           transform=torchvision.transforms.ToTensor())
# The dataset is no longer publicly accessible. You need to download the archives externally and place them in the root directory.

# False：只是加载了网络架构，参数都是初始化的默认参数
# True：从网络中下载每个卷积层在数据集上训练好的参数
vgg16_false = torchvision.models.vgg16(pretrained=False)
vgg16_true = torchvision.models.vgg16(pretrained=True)

train_data = torchvision.datasets.CIFAR10("./dataset",train=True,
                                          transform=torchvision.transforms.ToTensor(),download=True)

print(vgg16_true)
# CIFAR10 只把数据分成了 10 类，而加载的 vgg16 这个模型把数据分成了 1000 个类，需要修改
# vgg16_true.add_module('add_linear',nn.Linear(1000,10)) # 加在 VGG 大类中加
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10)) #在 classifier 最后加
print(vgg16_true)

print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096,10) # 修改网络模型
print(vgg16_false)

在这里插入图片描述

二、网络模型的保存与加载

（一）保存网络模型的两种方法

  • 保存方式一：保存了 模型结构 + 模型参数
  • 保存方式二：将网络模型中的参数保存成字典，没有了结构，只保存了模型参数（官方推荐，文件小）
    在这里插入图片描述

model_save.py文件

import torch
import torchvision
from torch import nn

vgg16 = torchvision.models.vgg16(pretrained=False)

# 保存方式一：保存了 模型结构 + 模型参数
# pth文件是 PyTorch 中常用的一种文件格式，主要用于 保存和加载 模型的参数
torch.save(vgg16,"vgg16_method1.pth")

# 保存方式二：将网络模型中的参数保存成字典，没有了结构，只保存了模型参数（官方推荐，文件小）
torch.save(vgg16.state_dict(),"vgg16_method2.pth")

# 陷阱
class Li(nn.Module):
	def __init__(self):
		super().__init__()
		self.conv = nn.Conv2d(3,64,3)

	def forward(self,x):
		x = self.conv(x)
		return x

li = Li()
torch.save(li,"li_method1.pth")

运行完程序后，在终端中输入 dir即可查看到文件相关信息
在这里插入图片描述

mac 里面的 ls(list) == windows 里面的 dir(directory)

（二）加载网络模型的两种方法

  • 加载模型方式一 对应 保存方式一
  • 加载模型方式二 对应 保存方式二：字典形式，无结构

另：如果要恢复网络模型结构
Step1：新建网络模型结构（默认没有参数）
Step2：通过字典形式加载参数（别人训练好的参数）

model_load.py文件

# import torch
# import torchvision
from model_save import * # *代表导入当前目录下的所有函数 （陷阱的解决方法）

# 加载模型方式一：--> 保存方式一
model = torch.load("vgg16_method1.pth")
print(model)

# 加载模型方式二：--> 保存方式二：字典形式，无结构
# model = torch.load("vgg16_method2.pth")
# 如果要恢复网络模型结构
# Step1：新建网络模型结构，但是没有参数
vgg16 = torchvision.models.vgg16(pretrained=False)
# Step2：通过字典形式加载参数（别人训练好的参数）
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)
# 此方式在自己的数据集上训练达到理想的效果了之后

# 陷阱
model = torch.load("li_method1.pth")
print(model)
# Can't get attribute 'Li' on <module '__main__' from 'D:\\Python\\pythonProject3\\model_load.py'>
# 要把 model_save 中的网络架构复制过来才行，或者直接 import 过来

注：
加载模型的时候，要把 model_save 中的网络架构复制过来才行，或者直接 import 过来

三、完整的模型训练套路

（一）背景知识

（1）有 Dropout，BatchNorm 层才需要在 训练/测试前 把网络设置成 训练/测试模式
在这里插入图片描述
在这里插入图片描述
（2）分类问题中，正确率指标的计算方法
在这里插入图片描述

outputs = torch.tensor([0.1,0.2],
                       [0.3,0.4])
# print(outputs.argmax(1)) # 填 1 的时候横向看，填 0 的时候纵向看（填标号的方向）
# 输出 tensor([1,1]) --> 横向来看：第一行预测在 1 位置，第二行也预测在 1 位置
preds = outputs.argmax(1)
targets = torch.tensor([0,1])
# print(preds == targets) # 输出 tensor([False,True])
print((preds == targets).sum()) # 输出 tensor(1) 计算出对应位置相等的个数，这里正确的个数为1

（3）tensor 类型加不加 .item( ) 的区别

a = torch.tensor(5)
print(a) # 打印 tensor(5)
print(a.item()) # 打印 5

（4）验证集 != 测试集

数据集分3部分：
1）训练集：训练神经网络（平时练习）
2）验证集：看网络效果、修改参数，防止模型过拟合（模拟考）
3）测试集：是最后一步，看网络怎么样（高考）

（5）训练网络的大体流程
准备数据集、dataloader加载数据集，搭建网络模型，创建网络模型实例，定义损失函数，定义优化器，设置网络训练的参数，开始训练，验证模型，最后保存模型。可以将训练结果展示

（二）代码实战

model.py

import torch
from torch import nn

class Li(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Conv2d(3,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,64,5,1,2),
			nn.MaxPool2d(2),
			nn.Flatten(),
			nn.Linear(64*4*4,64),
			nn.Linear(64,10)
		)

	def forward(self,x):
		x = self.model(x)
		return x

# 可测试网络的正确性
if __name__ == '__main__': # 相当于 main
    li = Li()
    input = torch.ones((64,3,32,32)) # batch_size = 64，代表有 64 张图片
    output = li(input)
    print(output.shape)
	# 输出 torch.Size([64, 10]) 
	# 含义：返回 64 行数据，每一行数据上面有 10 个数据（代表每一张图片在 10 个类别当中的概率）
# 另：__name__ == '__main__':下的代码只有在文件作为脚本直接执行时，才会被执行
#                            而该.py脚本被 import 到其他脚本中去时，其下的代码就不会被执行

train.py

import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import * # 1、被引用的 python 文件首字母不能为数字符号  2、两个文件必须在一个文件夹底下

# 准备数据集 (下载数据集，并加载到内存中)
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
										  transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
										 transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度 (批量处理数据，提供一个迭代访问的接口)
train_data_size = len(train_data) # ctr + D 复制此行内容到下一行
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}")
print(f"测试数据集的长度为：{test_data_size}")
# 利用DataLoader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64) # DataLoader 是类，Dataloader 是库
test_dataloader = DataLoader(test_data,batch_size=64)

# 搭建神经网络
# 创建网络模型
li = Li()

# 创建损失函数 mse用于回归，crossentropy 用于分类
loss_fn = nn.CrossEntropyLoss() # 参数为 optional 即为可选的
# 优化器 SGD(随机梯度下降)  parameter：参数
# learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.parameters(),lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10

# 添加 tensorboard，画图出来
writer = SummaryWriter("../logs_train")

for i in range(epoch):
	print(f"-----------第{i+1}轮训练开始-----------")

	# Step1：训练步骤开始
	li.train() # 有 Dropout, BatchNorm 层才需要调用
	for data in train_dataloader:
		imgs,targets = data
		outputs = li(imgs)  # 是 10 个类别中的某一个，也就是训练的标准
		loss = loss_fn(outputs,targets)

		# 优化器优化模型 --> 梯度清零、反向传播、参数优化、变量加一
		optimizer.zero_grad()
		loss.backward()
		optimizer.step()

		total_train_step = total_train_step + 1
		if total_train_step % 100 == 0:
			print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
			writer.add_scalar("train_loss",loss.item(),total_train_step)

	# Step2：测试步骤开始（不需要调优，在现有的模型上测试），看看模型有没有训练好，是否达到需求
	li.eval() # 有 Dropout，BatchNorm 层才需要调用
	total_test_loss = 0  # 想求整个数据集上的 loss
	total_accuracy = 0  # 想知道整体正确的个数，正确率：分类问题中特有的衡量指标
	with torch.no_grad():  # 不调优了
		for data in test_dataloader:
			imgs,targets = data
			outputs = li(imgs)
			loss = loss_fn(outputs,targets)
			total_test_loss = total_test_loss + loss.item()
			accuracy = (outputs.argmax(1) == targets).sum()  # outputs.argmax(1) 横向比较单张图片的各种类别概率，求最大
			total_accuracy = total_accuracy + accuracy  # 整个测试集上正确的个数
	total_test_step = total_test_step + 1
	print(f"整体测试集上的Loss：{total_test_loss}")
	print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
	writer.add_scalar("test_loss",total_test_loss,total_test_step) # 深色线：平滑处理，浅色线：真实曲线
	writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)

	# Step3：保存每一轮训练的模型结果
	torch.save(li,f"li_{i}.pth")
	# torch.save(li.state_dict(),f"li_{}.pth")
	print("模型已保存")

writer.close()

在这里插入图片描述
在这里插入图片描述

四、GPU 训练

用GPU训练，只需要改动代码中网络模型、数据（输入图片&标注）、损失函数这三个部分即可

（一）训练方式1 — 调用 .cuda( ) 来改

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time # 用来计时

# 准备数据集
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
										  transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
										 transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}") 
print(f"测试数据集的长度为：{test_data_size}") 
# 加载数据集
train_dataloader = DataLoader(train_data,batch_size=64) # DataLoader是类，Dataloader是库
test_dataloader = DataLoader(test_data,batch_size=64)

# 搭建神经网络
class Li(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Conv2d(3,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,64,5,1,2),
			nn.MaxPool2d(2),
			nn.Flatten(),
			nn.Linear(64*4*4,64),
			nn.Linear(64,10)
		)

	def forward(self,x):
		x = self.model(x)
		return x


# <<<<<<<<<<<网络模型>>>>>>>>>>>>>
li = Li()
#################################################################
if torch.cuda.is_available():
	li = li.cuda() # Moves all model parameters and buffers to the GPU
#################################################################

# <<<<<<<<<<<损失函数>>>>>>>>>>>>>
loss_fn = nn.CrossEntropyLoss()
#################################################################
if torch.cuda.is_available():
	loss_fn = loss_fn.cuda()
#################################################################

# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.parameters(),lr=learning_rate)

total_train_step = 0
total_test_step = 0
epoch = 10


writer = SummaryWriter("../logs_train")
start_time = time.time() # 用 time 库中的 .time() 记录当前时间

for i in range(epoch):
	print(f"-----------第{i+1}轮训练开始-----------")
	# 训练步骤开始
	li.train() 
	for data in train_dataloader:
		# <<<<<<<<<<<数据>>>>>>>>>>>>>
		imgs,targets = data
		########################################
		if torch.cuda.is_available():
			imgs = imgs.cuda()
			targets = targets.cuda()
		########################################
		outputs = li(imgs)  
		loss = loss_fn(outputs,targets)

		optimizer.zero_grad()
		loss.backward()
		optimizer.step()

		total_train_step = total_train_step + 1
		if total_train_step % 100 == 0:
			end_time = time.time() # 用 time 库中的 .time() 记录当前时间
			print(end_time - start_time)
			print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
			writer.add_scalar("train_loss",loss.item(),total_train_step)

	# 测试步骤开始
	li.eval()
	total_test_loss = 0
	total_accuracy = 0 
	with torch.no_grad():  
		for data in test_dataloader:
			# <<<<<<<<<<<数据>>>>>>>>>>>>>
			imgs,targets = data
			########################################
			if torch.cuda.is_available():
				imgs = imgs.cuda()
				targets = targets.cuda()
			########################################
			outputs = li(imgs)
			loss = loss_fn(outputs,targets)
			total_test_loss = total_test_loss + loss.item()
			accuracy = (outputs.argmax(1) == targets).sum()  
			total_accuracy = total_accuracy + accuracy
	print(f"整体测试集上的Loss：{total_test_loss}")
	print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
	writer.add_scalar("test_loss",total_test_loss,total_test_step)
	writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
	total_test_step = total_test_step + 1

	# 保存每一轮训练的结果
	torch.save(li,f"li_{i}.pth")
	# torch.save(li.state_dict(),f"li_{}.pth")
	print("模型已保存")

writer.close()

查看云端GPU的配置
在这里插入图片描述
运行程序
在这里插入图片描述

（二）训练方式2 — 调用 .to( device ) 来改

可以用 device = torch.device(“cuda:序号”) 来指定用电脑中那一张显卡
device = torch.device(“cuda”) 和 device = torch.device(“cuda:0”) 两者无差别

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time 

##########################################################
# <<<<<<<<<<<<<定义训练的设备>>>>>>>>>>>>>>>
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 语法糖
device = torch.device("cuda") # 更常用
##########################################################

# 准备数据集 
train_data = torchvision.datasets.CIFAR10(root="../dataset",train=True,
										  transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="../dataset",train=False,
										 transform=torchvision.transforms.ToTensor(),download=True)
# 数据集的长度
train_data_size = len(train_data) 
test_data_size = len(test_data)
print(f"训练数据集的长度为：{train_data_size}") 
print(f"测试数据集的长度为：{test_data_size}") 
# 加载数据集
train_dataloader = DataLoader(train_data,batch_size=64) 
test_dataloader = DataLoader(test_data,batch_size=64)

# 搭建神经网络
class Li(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Conv2d(3,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,64,5,1,2),
			nn.MaxPool2d(2),
			nn.Flatten(),
			nn.Linear(64*4*4,64),
			nn.Linear(64,10)
		)

	def forward(self,x):
		x = self.model(x)
		return x


# <<<<<<<<<<<<<网络模型>>>>>>>>>>>>>>>
li = Li()
##########################################################
# li = li.to(device) # 将网络转移到设备上去
li.to(device)
##########################################################

# <<<<<<<<<<<<<损失函数>>>>>>>>>>>>>>>
loss_fn = nn.CrossEntropyLoss() 
##########################################################
# loss_fn = loss_fn.to(device)
loss_fn.to(device)
##########################################################

# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(li.parameters(),lr=learning_rate)

total_train_step = 0
total_test_step = 0
epoch = 10

writer = SummaryWriter("../logs_train")
start_time = time.time()

for i in range(epoch):
	print(f"-----------第{i+1}轮训练开始-----------")
	# 训练步骤开始
	li.train()
	for data in train_dataloader:
		imgs,targets = data
		#################################################
		imgs = imgs.to(device)
		targets = targets.to(device)
		#################################################
		outputs = li(imgs) 
		loss = loss_fn(outputs,targets)

		optimizer.zero_grad()
		loss.backward()
		optimizer.step()

		total_train_step = total_train_step + 1
		if total_train_step % 100 == 0:
			end_time = time.time()
			print(end_time - start_time)
			print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
			writer.add_scalar("train_loss",loss.item(),total_train_step)

	# 测试步骤开始
	li.eval()
	total_test_loss = 0
	total_accuracy = 0
	with torch.no_grad():
		for data in test_dataloader:
			imgs,targets = data
			##########################################
			imgs = imgs.to(device)
			targets = targets.to(device)
			##########################################
			outputs = li(imgs)
			loss = loss_fn(outputs,targets)
			total_test_loss = total_test_loss + loss.item()
			accuracy = (outputs.argmax(1) == targets).sum()  
			total_accuracy = total_accuracy + accuracy
	print(f"整体测试集上的Loss：{total_test_loss}")
	print(f"整体测试集上的正确率：{total_accuracy/test_data_size}")
	writer.add_scalar("test_loss",total_test_loss,total_test_step) 
	writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
	total_test_step = total_test_step + 1

	# 保存每一轮训练的结果
	torch.save(li,f"li_{i}.pth")
	# torch.save(li.state_dict(),f"li_{}.pth")
	print("模型已保存")

writer.close()

五、完整的模型验证套路（测试 / demo）

利用已经训练好的模型，给它提供输入（应用到实际的环境当中，下面随便找到物体图片就是应用）
在这里插入图片描述

import torch
import torchvision
from PIL import Image
from torch import nn

image_path = "../imgs/dog.png" # ../ 到上一层级文件夹里找
image = Image.open(image_path)
print(image)
# <PIL.PngImagePlugin.PngImageFile image mode=RGBA size=348x238 at 0x135148BC6A0>
# png格式是 4 通道(RGBA)：除 RGB 三通道外，还有一个透明度通道。但我们只想保留其颜色通道
image = image.convert('RGB')

# 要将图片调整成符合要调用的网络模型的大小，才可正常输入
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()])

image = transform(image)
print(image.shape)

class Li(nn.Module):
	def __init__(self):
		super().__init__()
		self.model = nn.Sequential(
			nn.Conv2d(3,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,32,5,1,2),
			nn.MaxPool2d(2),
			nn.Conv2d(32,64,5,1,2),
			nn.MaxPool2d(2),
			nn.Flatten(),
			nn.Linear(64*4*4,64),
			nn.Linear(64,10)
		)

	def forward(self,x):
		x = self.model(x)
		return x

# 加载网络模型
# 注：在CPU上加载GPU上训练的模型，要加映射 map_location
model = torch.load("../complete_model_training/li_29_gpu.pth",map_location=torch.device('cpu'))
print(model)
image = torch.reshape(image,(1,3,32,32)) # 网络训练往往需要bach_sizes
model.eval() # 将模型转化为测试类型
with torch.no_grad(): # with 自动处理对文件的关闭操作
	output = model(image)
print(output)

print(output.argmax(1))

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

六、看看GitHub上的开源项目

（一）看一个项目，先看README

里面有安装、训练、测试模型的方法，需要环境配置的版本，还需要注意什么等
在这里插入图片描述

在这里插入图片描述

（二）再看 train.py 文件中的整体架构

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

（三）将函数中 required=True 的地方用 default= ……替换

在这里插入图片描述
在这里插入图片描述

完

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

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

相关文章

阿里云 服务器安装rabbit

阿里云 服务器安装rabbit

现在我们去服务器安装一个rabbit 进入home 创建一个rabbit文件夹 /home/rabbit vim deployRabbit.sh 脚本内容 #!/bin/bash docker run -d \ --name dev.rabbit \ --network dev-net \ -p 15672:15672 \ -v ./data:/var/lib/rabbitmq \ --hostname dev.rabbit \ rabbitmq:…
阅读更多...
css3 红色阴影边框紧急提醒呼吸灯特效

css3 红色阴影边框紧急提醒呼吸灯特效

效果截图 代码 <!DOCTYPE html> <html><head><title>红色呼吸灯紧急特效</title><style>keyframes alarm {0% {box-shadow: 0 0 30px #ff0000;}50% {box-shadow: 0 0 60px #ff0000, inset 0 0 60px #ff0000;}100% {box-shadow: 0 0 30px …
阅读更多...
八、【Python】基础 - 【Python while 循环全解析】：掌握无限循环的艺术

八、【Python】基础 - 【Python while 循环全解析】：掌握无限循环的艺术

&#x1f4a1;&#x1f4da;【Python while 循环全解析】&#xff1a;掌握无限循环的艺术&#x1f4da;&#x1f4a1; 目录 1.基本语法 2.示例 3.注意事项 4.嵌套循环与循环控制语句 5.示例&#xff1a;使用 break 和 continue 6.示例&#xff1a;计数器 7.示例&#xf…
阅读更多...
Web：Url 编码 -13

Web：Url 编码 -13

URL编码概述 HTTP协议只支持iso8859-1字符集。 而此字符集中只有英文数字常见符号。 所以HTTP原生是无法传输非iso8859-1字符的。 为了解决这个问题&#xff0c;提出了一种称之为URL编码的解决方案。 URL编解码详解 将非iso8859-1字符&#xff0c;进行转换 先将字符按照指定码表…
阅读更多...
时间序列分析方法之 -- 自回归移动平均模型（Autoregressive Moving Average, ARMA）原理及Python代码示例

时间序列分析方法之 -- 自回归移动平均模型（Autoregressive Moving Average, ARMA）原理及Python代码示例

目录 原理 适用情况 Python 示例代码 结论 原理 自回归移动平均模型&#xff08;Autoregressive Moving Average, ARMA&#xff09;是一种结合了自回归&#xff08;AR&#xff09;模型和移动平均&#xff08;MA&#xff09;模型的时间序列分析模型。它适用于描述和预测平稳…
阅读更多...
AGI思考探究过程中的意义、价值与乐趣 Ⅰ

AGI思考探究过程中的意义、价值与乐趣 Ⅰ

探究以泛GPT为代表的预训练自回归next token prediction GenAI(即llm)与Alpha系列为代表的RL&#xff0c;再到Sora为代表的DiT视觉生成领域模型的本质普遍性及表象差异&#xff0c;以及为什么要将其两者或三者联系甚至融合起来看待&#xff1f;本质上是尝试对比采用上述三种模型…
阅读更多...
昇思MindSpore 应用学习-Diffusion扩散模型-CSDN

昇思MindSpore 应用学习-Diffusion扩散模型-CSDN

Diffusion扩散模型 本文基于Hugging Face&#xff1a;The Annotated Diffusion Model一文翻译迁移而来&#xff0c;同时参考了由浅入深了解Diffusion Model一文。 本教程在Jupyter Notebook上成功运行。如您下载本文档为Python文件&#xff0c;执行Python文件时&#xff0c;请…
阅读更多...
【项目管理】高手项目经理都在用的6个SOP

【项目管理】高手项目经理都在用的6个SOP

SOP&#xff08;Standard Operating Procedure&#xff09;流程是一种标准化的操作指南&#xff0c;旨在确保组织或团队在各种情况下都能高效、一致地完成任务。SOP流程通常包括详细的步骤、关键控制点和责任分配&#xff0c;以确保质量和安全。SOP流程涉及从日常运营到危机管理…
阅读更多...
五、Spring Boot - 上手篇（1）

五、Spring Boot - 上手篇（1）

&#x1f33b;&#x1f33b;目录 一、快速入门&#xff1a;创建第一个SpringBoot 工程1.1 点击File--->New--->Project...1.2 选择版本和依赖的相关骨架包1.3 设置项目保存目录1.4 项目创建完成&#xff0c;工程主界面如下1.5 项目说明1.6 启动项目1.7 编写 HelloControl…
阅读更多...
2024年7月23日~2024年7月29日周报

2024年7月23日~2024年7月29日周报

目录 一、前言 二、完成情况 2.1 一种具有边缘增强特点的医学图像分割网络 2.2 融合边缘增强注意力机制和 U-Net 网络的医学图像分割 2.3 遇到的困难 三、下周计划 一、前言 上周参加了一些师兄师姐的论文讨论会议&#xff0c;并完成了初稿。 本周继续修改论文&#xff0…
阅读更多...
【Git】 如何将一个分支的某个提交合并到另一个分支

【Git】 如何将一个分支的某个提交合并到另一个分支

【Git】 如何将一个分支的某个提交合并到另一个分支 在使用 Git 进行版本控制时&#xff0c;常常会遇到这样的需求&#xff1a;将某个分支的特定提交合并到另一个分支中。这种情况下&#xff0c;我们可以使用 cherry-pick 命令来实现。本文将详细介绍 cherry-pick 命令的使用方…
阅读更多...
定时任务报错问题，通级下还有其他定时任务却没有报错，如何解决？？

定时任务报错问题，通级下还有其他定时任务却没有报错，如何解决？？

&#x1f3c6;本文收录于《CSDN问答解惑-专业版》专栏&#xff0c;主要记录项目实战过程中的Bug之前因后果及提供真实有效的解决方案&#xff0c;希望能够助你一臂之力&#xff0c;帮你早日登顶实现财富自由&#x1f680;&#xff1b;同时&#xff0c;欢迎大家关注&&收…
阅读更多...
R语言统计分析——条形图

R语言统计分析——条形图

参考资料&#xff1a;R语言实战【第2版】 条形图通过垂直的或水平的条形展示了类别型变量的分布&#xff08;频数&#xff09;。函数barplot()的最简单用法是&#xff1a; barplot(height) 其中height是一个向量或一个矩阵。 本文中数据案例来自“vcd”包&#xff0c;需在第一…
阅读更多...
JQuery异步请求与Flask后端通信、this和event指针汇总

JQuery异步请求与Flask后端通信、this和event指针汇总

目录 一.JQuery与Flask通信的三种方法 1.1$.ajax() 1.2$.get() 1.3$.post() 二.forEach()方法 三.this指针 3.1为什么要用this指针 3.2this的指向 3.3this指针的四种绑定方式 3.3.1默认绑定 3.3.2隐式绑定 3.3.3显式绑定 3.3.4new绑定 3.3.5通过标签调用this指针…
阅读更多...
windows server服务器/linux服务器离线安装pandas

windows server服务器/linux服务器离线安装pandas

windows server服务器/linux服务器离线安装pandas pypi官网下载whl文件速度较慢&#xff0c;推荐使用国内的镜像源来下载&#xff0c;镜像源地址为 清华大学 &#xff1a;https://pypi.tuna.tsinghua.edu.cn/simple/ 阿里云&#xff1a;http://mirrors.aliyun.com/pypi/simple…
阅读更多...
docker安装与container基本使用

docker安装与container基本使用

安装 Homebrew 的 Cask 已经支持 Docker for Mac, mac用户狂喜 brew install --cask --appdir/Applications docker其他入门用法可参考 Docker Hello World- 菜鸟教程 或网上自行搜索博客学习。本文主要记录我运行go-zero-mall用到的一些注意点。当然&#xff0c;gonivinck项…
阅读更多...
vue2+cesium实现报警特效

vue2+cesium实现报警特效

实现效果： 录制_2024_07_29_21_36_33_571 实现步骤如下： 1、安装cesium包：npm install cesium 2、在node-modules中找到刚刚安装的cesium，在文件夹中里面有一个Build文件夹，把Build里面的Cesium复制出来丢到public中 3、在index.html中进行引入： 4、新建一个js文件，…
阅读更多...
前端常见场景、JS计算精度丢失问题(Decimal.js 介绍)

前端常见场景、JS计算精度丢失问题(Decimal.js 介绍)

目录 一. Decimal.js 介绍 二. 常用方法 1. 创建 Decimal 实例 2.加法 add 或 plus 3.减法 sub 或 minus 4.乘法 times 或 mul 5.除法 div 或 dividedBy 6.取模 7.幂运算 8.平方根 9.保留小数位 toFixed方法(四舍五入) 三.项目应用 前端精度丢失问题通常由以下原因…
阅读更多...
无线融合，智能协同：ECWAN打造物联网高效协同网络

无线融合，智能协同：ECWAN打造物联网高效协同网络

关键词&#xff1a;资产管理、ECWAN、无线混合组网、用电监测、用电计量、广域基站、计量插座、边缘协同 在当今快速发展的物联网领域&#xff0c;每天都有数以亿计的设备互相通信&#xff0c;形成庞大而复杂的网络生态。在这样的背景下&#xff0c;ECWAN技术以其灵活、高效和智…
阅读更多...
【Linux】TCP全解析：构建可靠的网络通信桥梁

【Linux】TCP全解析：构建可靠的网络通信桥梁

文章目录 前言1. TCP 协议概述2. TCP报头结构3. 如何理解封装和解包呢&#xff1f;4. TCP的可靠性机制4.1 TCP的确认应答机制 4.2 超时重传机制5. TCP链接管理机制5.1 经典面试题&#xff1a;为什么建立连接是三次握手&#xff1f;5.2 经典面试题&#xff1a;为什么要进行四次挥…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023