PyTorch应用实战三：构建神经网络

文章目录

  • 神经网络
  • 1.继承Module构建神经网络
  • 2.结构化构建神经网络
  • 3.函数式操作
  • 附：系列文章

神经网络

构建神经网络的一般步骤如下：

  1. 确定网络的结构：这包括输入层、输出层和隐藏层的数量以及每层中的节点数等。

  2. 收集和准备数据：这包括收集训练数据、清洗数据、转换数据格式等。

  3. 初始化权重：权重是神经元之间的连接强度，需要在训练前随机初始化。

  4. 前向传播计算：根据输入数据和权重计算输出结果。

  5. 计算损失函数：损失函数衡量预测输出和真实输出之间的误差。

  6. 反向传播计算：反向传播是一种优化算法，用于调整权重以最小化损失函数。

  7. 更新权重：根据反向传播算法计算出的梯度更新权重，以优化模型。

  8. 重复以上步骤：反复执行前向传播和反向传播，调整权重，直到损失函数收敛。

  9. 测试和评估模型：使用测试数据集对模型进行评估和测试。

  10. 使用模型进行预测：使用已训练的模型对新数据进行预测。

1.继承Module构建神经网络

构建神经网络

import torch
import torch.nn as nn
from torch import optim
from torchvision import datasets, transforms
from torch.nn.functional import conv2d, cross_entropy 
class SimpleCNN(nn.Module):def __init__(self, in_channel=1):super(SimpleCNN, self).__init__()self.conv1 = nn.Conv2d(in_channel, 4, 5, 2, 0)self.relu1 = nn.ReLU()self.conv2 = nn.Conv2d(4, 8, 3, 2, 0)self.relu2 = nn.ReLU()self.linear = nn.Linear(200, 10)def forward(self, x):x = self.conv1(x)x = self.relu1(x)x = self.conv2(x)x = self.relu2(x)x = x.view(-1, 200)x = self.linear(x)return x

这个程序定义了一个简单的CNN模型 SimpleCNN，用于进行图像分类任务。它包含以下几个部分：

  1. 导入所需的 PyTorch 模块。这些模块是 torch、nn、optim、datasets、transforms 和 nn.functional。
  2. 定义了一个名为 SimpleCNN 的类，继承了 nn.Module。
  3. 在 __init__ 函数中定义模型的结构。这个模型包含两层卷积层和一个全连接层：
    • 第1层卷积层：输入通道数为 in_channel，输出通道数为 4，卷积核大小为 5x5，步长为 2，填充为 0。
    • 第1个ReLU激活函数：将卷积层的输出进行非线性变换。
    • 第2层卷积层：输入通道数为 4，输出通道数为 8，卷积核大小为 3x3，步长为 2，填充为 0。
    • 第2个ReLU激活函数：再次对卷积层的输出进行非线性变换。
    • 平铺层：将卷积层的输出展成一维向量。
    • 全连接层：输入大小为 200，输出大小为 10，用于输出分类结果。
  4. 在 forward 函数中实现模型的前向传播过程。将输入 x 依次经过卷积层、ReLU激活函数、卷积层、ReLU激活函数和全连接层处理，最终输出分类结果。
#测试
model = SimpleCNN()
data = torch.randn(3, 1, 28, 28)
output = model(data)
output.shape

torch.Size([3, 10])

卷积层计算

(28-5)/2+1=12
(12-3)/2+1=5

3×1×28×28
3×4×12×12
3×8×5×5
3×200
3×10

神经网络模型

model

SimpleCNN((conv1): Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))(relu1): ReLU()(conv2): Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))(relu2): ReLU()(linear): Linear(in_features=200, out_features=10, bias=True)
)

for key, value in model._modules.items():print(key, value)

conv1 Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))
relu1 ReLU()
conv2 Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))
relu2 ReLU()
linear Linear(in_features=200, out_features=10, bias=True)

model = SimpleCNN()
model.parameters()for p in model.parameters():print(p.shape)

torch.Size([4, 1, 5, 5])
torch.Size([4])
torch.Size([8, 4, 3, 3])
torch.Size([8])
torch.Size([10, 200])
torch.Size([10])

导入数据集

train_batch_size = 100  #一共60000个数据,100个数据一组,一共600组(N=100)
test_batch_size = 100   #一共10000个数据,100个数据一组,一共100组(N=100)
# 训练集
train_loader = torch.utils.data.DataLoader(datasets.MNIST('./data',train=True,download=True,  transform=transforms.Compose([transforms.ToTensor(),  #转为tensortransforms.Normalize((0.5),(0.5)) #正则化])),batch_size = train_batch_size, shuffle=True  #打乱位置
)
# 测试集
test_loader = torch.utils.data.DataLoader(datasets.MNIST('./data',train=False,download=True,transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5),(0.5))])),batch_size = test_batch_size, shuffle=False
)

这段代码主要用于加载 MNIST 数据集，并生成对应的数据加载器 train_loader 和 test_loader。具体包含以下几个步骤：

  1. 定义训练集的批次大小 train_batch_size，设为 100。
  2. 定义测试集的批次大小 test_batch_size，也设为 100。
  3. 调用 torch.utils.data.DataLoader 函数生成训练集加载器 train_loader，加载器将使用 datasets.MNIST 函数加载 MNIST 数据集，并进行以下操作：
    • 设置 MNIST 数据集的路径为 ./data。
    • 将数据集设置为训练集，下载数据集。
    • 对数据进行 transforms.Compose 序列变换操作，包括：
      • transforms.ToTensor()：将数据转为 Tensor 类型。
      • transforms.Normalize((0.5),(0.5))：将数据进行正则化。
    • 将训练集数据划分为大小为 train_batch_size 的批次，进行随机打乱。
  4. 调用 torch.utils.data.DataLoader 函数生成测试集加载器 test_loader，加载器将使用 datasets.MNIST 函数加载 MNIST 数据集，并进行相同的处理流程，但测试集不需要随机打乱。

这样生成的 train_loader 和 test_loader 可以用于对数据进行批量加载，方便后续的模型训练和评估。

训练测试

alpha = 0.1  #学习率
epochs = 100  #训练次数
interval = 100  #打印间隔
for epoch in range(epochs):optimizer = optim.SGD(model.parameters(), lr=0.1)for i, (data, label) in enumerate(train_loader):output = model(data)optimizer.zero_grad()  #梯度归零loss = cross_entropy(output, label)  #交叉熵函数loss.backward()   #反向求导optimizer.step()  #更新参数if i % interval == 0:print("Epoch %03d [%03d/%03d]\tLoss:%.4f"%(epoch, i, len(train_loader), loss.item()))correct_num = 0total_num = 0with torch.no_grad():for data, label in test_loader:output = model(data)pred = output.max(1)[1]correct_num += (pred == label).sum().item()total_num += len(data)acc = correct_num / total_numprint('...Testing @ Epoch %03d\tAcc:%.4f'%(epoch, acc))

Epoch 000 [000/600]	Loss:2.2848
Epoch 000 [100/600]	Loss:0.4144
Epoch 000 [200/600]	Loss:0.2014
Epoch 000 [300/600]	Loss:0.2790
Epoch 000 [400/600]	Loss:0.1858
Epoch 000 [500/600]	Loss:0.1649
...Testing @ Epoch 000	Acc:0.9538
Epoch 001 [000/600]	Loss:0.1593
Epoch 001 [100/600]	Loss:0.2436
Epoch 001 [200/600]	Loss:0.0649
Epoch 001 [300/600]	Loss:0.2830
Epoch 001 [400/600]	Loss:0.1208
Epoch 001 [500/600]	Loss:0.0937
...Testing @ Epoch 001	Acc:0.9678
Epoch 002 [000/600]	Loss:0.1210
Epoch 002 [100/600]	Loss:0.0737
Epoch 002 [200/600]	Loss:0.0857
Epoch 002 [300/600]	Loss:0.0712
Epoch 002 [400/600]	Loss:0.2700
Epoch 002 [500/600]	Loss:0.0849
...Testing @ Epoch 002	Acc:0.9708
Epoch 003 [000/600]	Loss:0.1094
Epoch 003 [100/600]	Loss:0.0727
Epoch 003 [200/600]	Loss:0.1756
Epoch 003 [300/600]	Loss:0.1473
Epoch 003 [400/600]	Loss:0.1013
Epoch 003 [500/600]	Loss:0.0879
...Testing @ Epoch 003	Acc:0.9741
Epoch 004 [000/600]	Loss:0.1503
Epoch 004 [100/600]	Loss:0.0832
Epoch 004 [200/600]	Loss:0.0731
Epoch 004 [300/600]	Loss:0.1040
Epoch 004 [400/600]	Loss:0.0720
Epoch 004 [500/600]	Loss:0.0490
...Testing @ Epoch 004	Acc:0.9745
Epoch 005 [000/600]	Loss:0.0720
Epoch 005 [100/600]	Loss:0.1124
Epoch 005 [200/600]	Loss:0.0674
Epoch 005 [300/600]	Loss:0.0477
Epoch 005 [400/600]	Loss:0.1164
Epoch 005 [500/600]	Loss:0.0662
...Testing @ Epoch 005	Acc:0.9758
Epoch 006 [000/600]	Loss:0.0445
Epoch 006 [100/600]	Loss:0.0500
Epoch 006 [200/600]	Loss:0.0236
Epoch 006 [300/600]	Loss:0.1068
Epoch 006 [400/600]	Loss:0.0767
Epoch 006 [500/600]	Loss:0.0549
...Testing @ Epoch 006	Acc:0.9800
Epoch 007 [000/600]	Loss:0.0539
Epoch 007 [100/600]	Loss:0.0319
Epoch 007 [200/600]	Loss:0.1369
Epoch 007 [300/600]	Loss:0.0301
Epoch 007 [400/600]	Loss:0.0881
Epoch 007 [500/600]	Loss:0.0642
...Testing @ Epoch 007	Acc:0.9792
Epoch 008 [000/600]	Loss:0.0564
Epoch 008 [100/600]	Loss:0.0845
Epoch 008 [200/600]	Loss:0.1877
Epoch 008 [300/600]	Loss:0.0963
Epoch 008 [400/600]	Loss:0.0671
Epoch 008 [500/600]	Loss:0.1053
...Testing @ Epoch 008	Acc:0.9757
Epoch 009 [000/600]	Loss:0.0117
Epoch 009 [100/600]	Loss:0.0201
Epoch 009 [200/600]	Loss:0.1933
Epoch 009 [300/600]	Loss:0.0726
Epoch 009 [400/600]	Loss:0.0449
Epoch 009 [500/600]	Loss:0.1415
...Testing @ Epoch 009	Acc:0.9807
Epoch 010 [000/600]	Loss:0.0505
Epoch 010 [100/600]	Loss:0.0410
Epoch 010 [200/600]	Loss:0.0325
Epoch 010 [300/600]	Loss:0.0403
Epoch 010 [400/600]	Loss:0.0249
Epoch 010 [500/600]	Loss:0.0682
...Testing @ Epoch 010	Acc:0.9805
Epoch 011 [000/600]	Loss:0.0816
Epoch 011 [100/600]	Loss:0.1179
Epoch 011 [200/600]	Loss:0.1244
Epoch 011 [300/600]	Loss:0.0465
Epoch 011 [400/600]	Loss:0.1324
Epoch 011 [500/600]	Loss:0.0763
...Testing @ Epoch 011	Acc:0.9799
……

这段代码实现了简单 CNN 模型的训练和测试，具体实现步骤如下：

  1. 定义学习率 alpha，设为 0.1。
  2. 定义训练次数 epochs，设为 100。
  3. 定义打印间隔 interval，设为 100。
  4. 使用 range 函数循环 epochs 次，进行模型训练和测试。
  5. 在每个 epoch 循环中，定义优化器 optimizer，使用随机梯度下降法（SGD）优化器，对模型参数进行更新。
  6. 循环训练数据加载器 train_loader 中的数据，对数据进行前向传播，计算损失函数（交叉熵函数），通过反向传播求解梯度，并通过优化器对模型参数进行更新。
  7. 在每个间隔 interval 打印一次训练进度，输出当前训练的 epoch、批次、总批次数和当前损失函数值，以及测试集的准确率。
  8. 在每个 epoch 循环的末尾，使用 torch.no_grad() 防止梯度更新，在测试集加载器 test_loader 中进行数据的前向传播，计算模型的预测值和真实值，计算模型的准确率并输出。

这样就完成了模型的训练和测试，通过输出可以了解模型的训练进度和测试效果。

2.结构化构建神经网络

构建神经网络

Model = nn.Sequential(nn.Conv2d(1, 4, 5, 2, 0),nn.ReLU(),nn.Conv2d(4, 8, 3, 2, 0),nn.ReLU(),nn.Flatten(),nn.Linear(200, 10)
)

神经网络模型

Model

Sequential((0): Conv2d(1, 4, kernel_size=(5, 5), stride=(2, 2))(1): ReLU()(2): Conv2d(4, 8, kernel_size=(3, 3), stride=(2, 2))(3): ReLU()(4): Flatten(start_dim=1, end_dim=-1)(5): Linear(in_features=200, out_features=10, bias=True)
)

#测试
data = torch.randn(3, 1, 28, 28)
output = Model(data)
output.shape

torch.Size([3, 10])

for p in Model.parameters():print(p.shape)

torch.Size([4, 1, 5, 5])
torch.Size([4])
torch.Size([8, 4, 3, 3])
torch.Size([8])
torch.Size([10, 200])
torch.Size([10])

训练测试

alpha = 0.1  #学习率
epochs = 100  #训练次数
interval = 100  #打印间隔
for epoch in range(epochs):optimizer = optim.SGD(Model.parameters(), lr=0.1)for i, (data, label) in enumerate(train_loader):output = Model(data)optimizer.zero_grad()  #梯度归零loss = cross_entropy(output, label)  #交叉熵函数loss.backward()   #反向求导optimizer.step()  #更新参数if i % interval == 0:print("Epoch %03d [%03d/%03d]\tLoss:%.4f"%(epoch, i, len(train_loader), loss.item()))correct_num = 0total_num = 0with torch.no_grad():for data, label in test_loader:output = Model(data)pred = output.max(1)[1]correct_num += (pred == label).sum().item()total_num += len(data)acc = correct_num / total_numprint('...Testing @ Epoch %03d\tAcc:%.4f'%(epoch, acc))

Epoch 000 [000/600]	Loss:2.3005
Epoch 000 [100/600]	Loss:0.3855
Epoch 000 [200/600]	Loss:0.2832
Epoch 000 [300/600]	Loss:0.3216
Epoch 000 [400/600]	Loss:0.2495
Epoch 000 [500/600]	Loss:0.0687
...Testing @ Epoch 000	Acc:0.9554
Epoch 001 [000/600]	Loss:0.1364
Epoch 001 [100/600]	Loss:0.2104
Epoch 001 [200/600]	Loss:0.1206
Epoch 001 [300/600]	Loss:0.0859
Epoch 001 [400/600]	Loss:0.1187
Epoch 001 [500/600]	Loss:0.1903
...Testing @ Epoch 001	Acc:0.9668
Epoch 002 [000/600]	Loss:0.1893
Epoch 002 [100/600]	Loss:0.1033
Epoch 002 [200/600]	Loss:0.1633
Epoch 002 [300/600]	Loss:0.1038
Epoch 002 [400/600]	Loss:0.1250
Epoch 002 [500/600]	Loss:0.2345
...Testing @ Epoch 002	Acc:0.9725
Epoch 003 [000/600]	Loss:0.0566
Epoch 003 [100/600]	Loss:0.1781
Epoch 003 [200/600]	Loss:0.0779
Epoch 003 [300/600]	Loss:0.2852
Epoch 003 [400/600]	Loss:0.0428
Epoch 003 [500/600]	Loss:0.1369
...Testing @ Epoch 003	Acc:0.9714
Epoch 004 [000/600]	Loss:0.1098
Epoch 004 [100/600]	Loss:0.1288
Epoch 004 [200/600]	Loss:0.1078
Epoch 004 [300/600]	Loss:0.1325
Epoch 004 [400/600]	Loss:0.0649
Epoch 004 [500/600]	Loss:0.0683
...Testing @ Epoch 004	Acc:0.9739
Epoch 005 [000/600]	Loss:0.0984
Epoch 005 [100/600]	Loss:0.1322
Epoch 005 [200/600]	Loss:0.0641
Epoch 005 [300/600]	Loss:0.0769
Epoch 005 [400/600]	Loss:0.1507
Epoch 005 [500/600]	Loss:0.0377
...Testing @ Epoch 005	Acc:0.9742
Epoch 006 [000/600]	Loss:0.0954
Epoch 006 [100/600]	Loss:0.0889
Epoch 006 [200/600]	Loss:0.0666
Epoch 006 [300/600]	Loss:0.0448
Epoch 006 [400/600]	Loss:0.0285
Epoch 006 [500/600]	Loss:0.0581
...Testing @ Epoch 006	Acc:0.9773
Epoch 007 [000/600]	Loss:0.0305
Epoch 007 [100/600]	Loss:0.0651
Epoch 007 [200/600]	Loss:0.1007
Epoch 007 [300/600]	Loss:0.1537
Epoch 007 [400/600]	Loss:0.0233
Epoch 007 [500/600]	Loss:0.0925
...Testing @ Epoch 007	Acc:0.9750
Epoch 008 [000/600]	Loss:0.1807
Epoch 008 [100/600]	Loss:0.0373
Epoch 008 [200/600]	Loss:0.0600
Epoch 008 [300/600]	Loss:0.2233
Epoch 008 [400/600]	Loss:0.0469
Epoch 008 [500/600]	Loss:0.0817
...Testing @ Epoch 008	Acc:0.9795
Epoch 009 [000/600]	Loss:0.1331
Epoch 009 [100/600]	Loss:0.1417
Epoch 009 [200/600]	Loss:0.0429
Epoch 009 [300/600]	Loss:0.0552
Epoch 009 [400/600]	Loss:0.0117
Epoch 009 [500/600]	Loss:0.0611
...Testing @ Epoch 009	Acc:0.9780
Epoch 010 [000/600]	Loss:0.0386
Epoch 010 [100/600]	Loss:0.2372
Epoch 010 [200/600]	Loss:0.0092
Epoch 010 [300/600]	Loss:0.0623
Epoch 010 [400/600]	Loss:0.0530
Epoch 010 [500/600]	Loss:0.0345
...Testing @ Epoch 010	Acc:0.9797
Epoch 011 [000/600]	Loss:0.1051
Epoch 011 [100/600]	Loss:0.0507
Epoch 011 [200/600]	Loss:0.1075
Epoch 011 [300/600]	Loss:0.0414
Epoch 011 [400/600]	Loss:0.0256
Epoch 011 [500/600]	Loss:0.0631
...Testing @ Epoch 011	Acc:0.9778
Epoch 012 [000/600]	Loss:0.0873
Epoch 012 [100/600]	Loss:0.0693
Epoch 012 [200/600]	Loss:0.0779
Epoch 012 [300/600]	Loss:0.2842
Epoch 012 [400/600]	Loss:0.0314
Epoch 012 [500/600]	Loss:0.0197
...Testing @ Epoch 012	Acc:0.9778
……

3.函数式操作

见《PyTorch应用实战二:实现卷积神经网络进行图像分类》

附：系列文章

序号文章目录直达链接
1PyTorch应用实战一：实现卷积操作https://want595.blog.csdn.net/article/details/132575530
2PyTorch应用实战二：实现卷积神经网络进行图像分类https://want595.blog.csdn.net/article/details/132575702
3PyTorch应用实战三：构建神经网络https://want595.blog.csdn.net/article/details/132575758
4PyTorch应用实战四：基于PyTorch构建复杂应用https://want595.blog.csdn.net/article/details/132625270
5PyTorch应用实战五：实现二值化神经网络https://want595.blog.csdn.net/article/details/132625348
6PyTorch应用实战六：利用LSTM实现文本情感分类https://want595.blog.csdn.net/article/details/132625382

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

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

相关文章

ARMday2

ARMday2

1~100累加 代码 .text .globl _start _start:mov r0, #1 fun:cmp r0,#100addls r1,r1,r0addls r0,r0,#1b fun .end运行结果
阅读更多...
互联网Java工程师面试题·Elasticsearch 篇·第二弹

互联网Java工程师面试题·Elasticsearch 篇·第二弹

12、详细描述一下 Elasticsearch 索引文档的过程。 协调节点默认使用文档 ID 参与计算（也支持通过 routing ），以便为路由提供合适的分片。 shard hash(document_id) % (num_of_primary_shards) 1 、当分片所在的节点接收到来自协调节点…
阅读更多...
每日一题 518零钱兑换2（完全背包）

每日一题 518零钱兑换2（完全背包）

题目 给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。 请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。 假设每一种面额的硬币有无限个。 题目数据保证结果符合 32 位带符号整…
阅读更多...
API基础————包

API基础————包

什么是包，package实际上就是一个文件夹，便于程序员更好的管理维护自己的代码。它可以使得一个项目结构更加清晰明了。 Java也有20年历史了，这么多年有这么多程序员写了无数行代码，其中有大量重复的，为了更加便捷省时地…
阅读更多...
Flv.js编译使用

Flv.js编译使用

Flv.js （https://github.com/bilibili/flv.js）是 HTML5 Flash 视频（FLV）播放器，纯原生 JavaScript 开发，没有用到 Flash。由 bilibili 网站开源。本文讲述其编译使用。 Flv.js目前最新版本是v1.6.2。在htt…
阅读更多...
基于混合蛙跳优化的BP神经网络（分类应用） - 附代码

基于混合蛙跳优化的BP神经网络（分类应用） - 附代码

基于混合蛙跳优化的BP神经网络（分类应用） - 附代码 文章目录 基于混合蛙跳优化的BP神经网络（分类应用） - 附代码1.鸢尾花iris数据介绍2.数据集整理3.混合蛙跳优化BP神经网络3.1 BP神经网络参数设置3.2 混合蛙跳算法应用 4.测试结果…
阅读更多...
gitgitHub

gitgitHub

在git中复制CtrlInsert、粘贴CtrlShif 一、用户名和邮箱的配置 查看用户名 ：git config user.name 查看密码： git config user.password 查看邮箱：git config user.email 查看配置信息： $ git config --list 修改用户名 git co…
阅读更多...
Java笔记七（封装，继承与多态）

Java笔记七（封装，继承与多态）

封装 该露的露，该藏的藏 程序设计追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用 封装（数据的隐藏） 通常，…
阅读更多...
【Pandas】Apply自定义行数

【Pandas】Apply自定义行数

文章目录 1. Series的apply方法2. DataFrame的apply方法2.1 针对列使用apply2.2 针对行使用apply Pandas提供了很多数据处理的API,但当提供的API不能满足需求的时候,需要自己编写数据处理函数, 这个时候可以使用apply函数apply函数可以接收一个自定义函数, 可以将DataFrame的行…
阅读更多...
Linux shell编程学习笔记8：使用字符串

Linux shell编程学习笔记8：使用字符串

一、前言 字符串是大多数编程语言中最常用最有用的数据类型，这在Linux shell编程中也不例外。 本文讨论了Linux Shell编程中的字符串的三种定义方式的差别，以及字符串拼接、取字符串长度、提取字符串、查找子字符串等常用字符串操作,，以及反…
阅读更多...
【2023年11月第四版教材】第18章《项目绩效域》(合集篇)

【2023年11月第四版教材】第18章《项目绩效域》(合集篇)

第18章《项目绩效域》（合集篇） 1 章节内容2 干系人绩效域2.1 绩效要点2.2 执行效果检查2.3 与其他绩效域的相互作用 3 团队绩效域3.1 绩效要点3.2 与其他绩效域的相互作用3.3 执行效果检查3.4 开发方法和生命周期绩效域 4 绩效要点4.1 与其他绩效域的相互…
阅读更多...
20231005使用ffmpeg旋转MP4视频

20231005使用ffmpeg旋转MP4视频

20231005使用ffmpeg旋转MP4视频 2023/10/5 12:21 百度搜搜：ffmpeg 旋转90度 https://zhuanlan.zhihu.com/p/637790915 【FFmpeg实战】FFMPEG常用命令行 https://blog.csdn.net/weixin_37515325/article/details/127817057 FFMPEG常用命令行 5.视频旋转 顺时针旋转…
阅读更多...
System Generator学习——时间和资源分析

System Generator学习——时间和资源分析

文章目录 前言一、目标二、步骤三、步骤 1 ：系统生成器的时序分析1、时序分析2、解决时间违规问题 四、步骤 2 ：系统生成器中的资源分析总结 前言 在本节实验中，你将学习如何通过在 Simulink 中进行仿真来验证设计的功能，以确保在…
阅读更多...
熟练掌握Junit5框架

熟练掌握Junit5框架

目录 一、注解 1.1 @Test 1.2 @Disabled 1.3 @BeforeAll 1.4 @AfterAll 1.5 @BeforeEach 1.6 @AfterEach 二、参数化 2.1单参数获取数据 2.2 CSV获取参数 2.3 方法获取数据 2.4 多参数获取数据 2.5测试用例执行顺序 2.6断言 2.6.1断言相等 2.6.2断言不相等
阅读更多...
vue3使用v-model控制子组件进行双向数据绑定

vue3使用v-model控制子组件进行双向数据绑定

vue2写法: 中父组件调用子组件: <child :isShow.sync"isShow" v-show"isShow"/> 子组件想要消失, 在子组件写: this.$emit("update:isShow",false); 具体代码就不粘贴了 vue3写法: 父组件核心代码: v-model:a"xxx" 子组…
阅读更多...
aardio 读取 Excel文件，显示在 listview 中

aardio 读取 Excel文件，显示在 listview 中

编写 main.aardio 如下 import win.ui; /*DSG{{*/ winform win.form(text"excel1";right801;bottom500) winform.add( button1{cls"button";text"读取Excel文件";left19;top14;right126;bottom44;z1}; button2{cls"button";text&quo…
阅读更多...
力扣第226翻转二叉数 c++三种方法 ＋注释

力扣第226翻转二叉数 c++三种方法 ＋注释

题目 226. 翻转二叉树 简单 给你一棵二叉树的根节点 root &#xff0c;翻转这棵二叉树&#xff0c;并返回其根节点。 示例 1&#xff1a; 输入&#xff1a;root [4,2,7,1,3,6,9] 输出&#xff1a;[4,7,2,9,6,3,1]示例 2&#xff1a; 输入&#xff1a;root [2,1,3] 输出&am…
阅读更多...
常见的几种排序方式

常见的几种排序方式

常见的几种排序方式 1. 排序的概念2. 常见排序算法的实现2.1 插入排序2.1.1基本思想2.1.2 直接插入排序2.1.3 希尔排序( 缩小增量排序 ) 2.2 选择排序2.2.1基本思想2.2.2 直接选择排序:2.2.3 堆排序 2.3 交换排序2.3.1冒泡排序2.3.2 快速排序 2.4 归并排序2.4.1 基本思想2.4.2 …
阅读更多...
【POST请求-腾讯翻译君-爬虫案例】

【POST请求-腾讯翻译君-爬虫案例】

原因&#xff1a;尝试多个在线翻译平台&#xff0c;由于返回数据存在加密原因&#xff08;暂时不会解密&#xff09;&#xff0c;最总找到 ”腾讯翻译君“ 完成爬虫案例POST请求测试 案例测试网址 腾讯翻译 &#xff1a;https://fanyi.qq.com/ import requests import jsoncla…
阅读更多...
知识图谱小白入门(1):neo4j的安装与CQL的使用

知识图谱小白入门(1):neo4j的安装与CQL的使用

文章目录 序一、安装neo4j1.1 下载neo4j1.2 安装JDK1.3 BUG&#xff1a;dbms failed to start 二、CQL语法2.1 CQL语法创建节点查询节点创建关系查询关系2.2 习题 习题答案 序 知识图谱&#xff0c;是一种实体间的信息与关系知识的网状结构&#xff0c;借用图论中点与边的概念…
阅读更多...
最新文章

Copyright @ 2022~2023