網站首頁 編程語言 正文
大多數卷積神經網絡都是直接通過寫一個Model類來定義的，這樣寫的代碼其實是比較好懂的，特別是在魔改網絡的時候也很方便。然后也有一些會通過cfg配置文件進行模型的定義。在yolov5中可以看到是通過yaml文件進行網絡的定義【個人感覺通過配置文件魔改網絡有些不方便，當然每個人習慣不同】，可能很多人也用過，如果自己去寫一個yaml文件，自己能不能定義出來呢？很多人不知道是如何具體通過yaml文件將里面的參數傳入自己定義的網絡中，這也就給自己修改網絡帶來了不便。這篇文章將仿照yolov5的方式，利用yaml定義一個自己的網絡。
定義卷積塊
我們可以先定義一個卷積塊CBL，C指卷積Conv，B指BN層，L為激活函數，這里我用ReLu.
class BaseConv(nn.Module):
def __init__(self, in_channels, out_channels, k=1, s=1, p=None):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.conv = nn.Conv2d(in_channels, out_channels, k, s, autopad(k, p))
self.bn = nn.BatchNorm2d(out_channels)
self.act_fn = nn.ReLU(inplace=True)
def forward(self, x):
return self.act_fn(self.bn(self.conv(x)))
卷積中的autopad是自動補充pad，代碼如下：
def autopad(k, p=None):
if p is None:
p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
return p
定義一個Bottleneck?
可以仿照yolov5定義一個Bottleneck，參考了殘差塊的思想。
class Bottleneck(nn.Module):
def __init__(self, in_channels, out_channels, shortcut=True):
super(Bottleneck, self).__init__()
self.conv1 = BaseConv(in_channels, out_channels, k=1, s=1)
self.conv2 = BaseConv(out_channels, out_channels, k=3, s=1)
self.add = shortcut and in_channels == out_channels
def forward(self, x):
"""
x-->conv1-->conv2-->add
|_________________|
"""
return x + self.conv2(self.conv1(x)) if self.add else self.conv2(self.conv1(x))
攥寫yaml配置文件
然后我們來寫一下yaml配置文件，網絡不要很復雜，就由兩個卷積和兩個Bottleneck組成就行。同理，仿v5的方法，我們的網絡中的backone也是個列表，每行為一個卷積層，每列有4個參數，分別代表from(指該層的輸入通道數為上一層的輸出通道數，所以是-1)，number【yaml中的1，1，2指該層的深度，或者說是重復幾次】，Module_nams【該層的名字】，args【網絡參數，包含輸出通道數，k，s，p等設置】
# define own model
backbone:
[[-1, 1, BaseConv, [32, 3, 1]], # out_channles=32, k=3, s=1
[-1, 1, BaseConv, [64, 1, 1]],
[-1, 2, Bottleneck, [64]]
]
我們現在用yaml工具來打開我們的配置文件，看看都有什么內容
import yaml
# 獲得yaml文件名字
yaml_file = Path('Model.yaml').name
with open(yaml_file,errors='ignore') as f:
yaml_ = yaml.safe_load(f)
print(yaml_)
輸出：?
?{'backbone': [[-1, 1, 'BaseConv', [32, 3, 1]], [-1, 1, 'BaseConv', [64, 1, 1]], [-1, 2, 'Bottleneck', [64]]]}
然后我們可以定義下自己Model類，也就是定義自己的網絡。可以看到與前面讀取yaml文件相比，多了一行 ? ?ch = self.yaml["ch"] = self.yaml["ch"] = 3 ? 這個是在原yaml內容中加入一個key和valuse,3指的3通道，因為我們的圖像是3通道。parse_model是下面要說的傳參過程。
class Model(nn.Module):
def __init__(self, cfg='./Model.yaml', ch=3, ):
super().__init__()
self.yaml = cfg
import yaml
yaml_file = Path(cfg).name
with open(yaml_file, errors='ignore')as f:
self.yaml = yaml.safe_load(f)
ch = self.yaml["ch"] = self.yaml["ch"] = 3
self.backbone = parse_model(deepcopy(self.yaml), ch=[ch])
def forward(self, x):
output = self.backbone(x)
return output傳入參數
這一步也是最關鍵的一步，我們需要定義傳參的函數，將yaml中的卷積參數傳入我們定義的網絡中，這里會用的一個非常非常重要的函數eval(),后面也會介紹到這個函數的用法。
這里先附上完整代碼：
def parse_model(yaml_cfg, ch):
"""
:param yaml_cfg: yaml file
:param ch: init in_channels default is 3
:return: model
"""
layer, out_channels = [], ch[-1]
for i, (f, number, Module_name, args) in enumerate(yaml_cfg['backbone']):
"""
f:上一層輸出通道
number:該模塊有幾層，就是該模塊要重復幾次
Mdule_name：卷積層名字
args:參數，包含輸出通道數，k,s,p等
"""
# 通過eval，將str類型轉自己定義的BaseConv
m = eval(Module_name) if isinstance(Module_name, str) else Module_name
for j, a in enumerate(args):
# 通過eval，將str轉int,獲得輸出通道數
args[j] = eval(a) if isinstance(a, str) else a
# 更新通道
# args[0]是輸出通道
if m in [BaseConv, Bottleneck]:
in_channels, out_channels = ch[f], args[0]
args = [in_channels, out_channels, *args[1:]] # args=[in_channels, out_channels, k, s, p]
# 將參數傳入模型
model_ = nn.Sequential(*[m(*args) for _ in range(number)]) if number > 1 else m(*args)
# 更新通道列表，每次獲取輸出通道
ch.append(out_channels)
layer.append(model_)
return nn.Sequential(*layer)下面開始分析代碼 。
這行代碼是通過列表用來存放每層內容以及輸出通道數。
# 這行代碼是通過列表用來存放每層內容以及輸出通道數
layer, out_channels = [], ch[-1]
然后進入我們的for循環，在每一次循環中可以獲得我們yaml文件中的每一層網絡：f是上一層網絡的輸出通道【用來作為本層的輸入通道】，number【網絡深度，也就是該層重復幾次而已】，Module_name是該層的名字，args是該層的一些參數。
for i, (f, number, Module_name, args) in enumerate(yaml_cfg['backbone']):
接下來會碰到一個很重要的函數eval()。下行的代碼首先需要判斷一下我們的Module_name類型是不是字符串類型，也就是判斷一下yaml中“BaseConv”是不是字符串類型，如果是，則用eval進行對應類型的轉化，轉成我們的BaseConv類型。?
m = eval(Module_name) if isinstance(Module_name, str) else Module_name
這里我將對eval函數在深入點，如果知道這個函數用法的，就可以略去這部分。
我們先舉個例子，比如我現在有個變量a="123"，這個a的類型是什么呢？他是一個str類型，不是int類型。 現在我們用eval函數轉一下，看看會變成什么樣子。
>>> b = eval(a) if isinstance(a,str) else a
>>> b
123
>>> type(b)
<class 'int'>
我們可以看到，經過eval函數以后，會自動識別并轉為int類型。那么我繼續舉例子，如果現在a="BaseConv",經過eval以后會變成什么？可以看到，這里報錯了！這是為什么？這是因為我們沒有導入BaseConv這個類，所以eval函數并不知道我們希望轉為什么類型。所以我們需要用import導入BaseConv這個類才可以。
>>> a="BaseConv"
>>> b = eval(a) if isinstance(a,str) else a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
NameError: name 'BaseConv' is not defined
當我們導入BaseConv以后，在經過eval就可以獲得：
<class 'models.BaseConv'>
接下來是獲得args中的網絡參數，也是通過eval進行轉化
for j, a in enumerate(args):
# 通過eval，將str轉int,獲得輸出通道數
args[j] = eval(a) if isinstance(a, str) else a
獲取通道數，并在每次循環中對通道進行更新：可以仔細看一下ch[f]指的上一層輸出通道，剛開始默認為[3]，那么ch[-1]=3，我們yaml中第一層的BaseConv args[0]為32，表示輸出32通道。因此在第一次循環中有in_channels = 3,out_channels=32。args也要更新，*args前面的"*"并不是指針的意思，也不是乘的意思，而是解壓操作，因此我們第一次循環中得到的args=[3,32,3,1]。
# 更新通道
# args[0]是輸出通道
if m in [BaseConv, Bottleneck]:
in_channels, out_channels = ch[f], args[0]
args = [in_channels, out_channels, *args[1:]] # args=[in_channels, out_channels, k, s, p]
將參數傳入模型
這里用for _ in range(number)來判斷網絡的深度【或者說該模塊重復幾次】，這里的m就是前面經過eval轉化的 <class 'models.BaseConv'>。通過*args解壓操作將args列表中的內容放入m中，再通過*解壓操作放入nn.Sequential。
model_ = nn.Sequential(*[m(*args) for _ in range(number)]) if number > 1 else m(*args)
這樣就可以獲得我們第一次循環BaseConv了。后面的循環也是同樣的反復操作而已。
BaseConv(
(conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
然后是更新通道列表和layer列表，為的是獲取每次循環的輸出通道，沒有這一步，再下一次循環的時候將不能正確得到通道數。
# 更新通道列表，每次獲取輸出通道
ch.append(out_channels)
layer.append(model_)
然后我們就可以對模型調用進行實例化了，可以打印下模型：
Model(
(backbone): Sequential(
(0): BaseConv(
(conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
(1): BaseConv(
(conv): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1))
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
(2): Sequential(
(0): Bottleneck(
(conv1): BaseConv(
(conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
(conv2): BaseConv(
(conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
)
(1): Bottleneck(
(conv1): BaseConv(
(conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
(conv2): BaseConv(
(conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(act_fn): ReLU(inplace=True)
)
)
)
)
)同時我們也可以對模型每層可視化看一下。可以看到和我們定義的模型是一樣的。
完整的代碼
from copy import deepcopy
from models import BaseConv, Bottleneck
import torch.nn as nn
import os
path = os.getcwd()
from pathlib import Path
import torch
def parse_model(yaml_cfg, ch):
"""
:param yaml_cfg: yaml file
:param ch: init in_channels default is 3
:return: model
"""
layer, out_channels = [], ch[-1]
for i, (f, number, Module_name, args) in enumerate(yaml_cfg['backbone']):
"""
f:上一層輸出通道
number:該模塊有幾層，就是該模塊要重復幾次
Mdule_name：卷積層名字
args:參數，包含輸出通道數，k,s,p等
"""
# 通過eval，將str類型轉自己定義的BaseConv
m = eval(Module_name) if isinstance(Module_name, str) else Module_name
for j, a in enumerate(args):
# 通過eval，將str轉int,獲得輸出通道數
args[j] = eval(a) if isinstance(a, str) else a
# 更新通道
# args[0]是輸出通道
if m in [BaseConv, Bottleneck]:
in_channels, out_channels = ch[f], args[0]
args = [in_channels, out_channels, *args[1:]] # args=[in_channels, out_channels, k, s, p]
# 將參數傳入模型
model_ = nn.Sequential(*[m(*args) for _ in range(number)]) if number > 1 else m(*args)
# 更新通道列表，每次獲取輸出通道
ch.append(out_channels)
layer.append(model_)
return nn.Sequential(*layer)
class Model(nn.Module):
def __init__(self, cfg='./Model.yaml', ch=3, ):
super().__init__()
self.yaml = cfg
import yaml
yaml_file = Path(cfg).name
with open(yaml_file, errors='ignore')as f:
self.yaml = yaml.safe_load(f)
ch = self.yaml["ch"] = self.yaml["ch"] = 3
self.backbone = parse_model(deepcopy(self.yaml), ch=[ch])
def forward(self, x):
output = self.backbone(x)
return output
if __name__ == "__main__":
cfg = path + '/Model.yaml'
model = Model()
model.eval()
print(model)
x = torch.ones(1, 3, 512, 512)
output = model(x)
torch.save(model, "model.pth")
# model = torch.load('model.pth')
# model.eval()
# x = torch.ones(1,3,512,512)
# input_name = ['input']
# output_name = ['output']
# torch.onnx.export(model, x, 'myonnx.onnx', verbose=True)原文鏈接：https://blog.csdn.net/Vertira/article/details/127417327
相關推薦
- 2022-06-16 python讀取txt數據的操作步驟_python
- 2022-03-26 C++鏈表節點的添加和刪除介紹_C 語言
- 2022-02-05 Tableau:如何處理Excel中一個sheet中有多張表的問題？
- 2022-09-26 Shell（希爾）排序算法詳解之C語言版
- 2022-12-08 React競態條件Race?Condition實例詳解_React
- 2022-03-14 Response to preflight request doesn't pass access
- 2022-08-22 C#實現打開指定目錄和指定文件的示例代碼_C#教程
- 2023-10-09 雙token登錄
- 最近更新
-
- window11 系統安裝 yarn
- 超詳細win安裝深度學習環境2025年最新版（
- Linux 中運行的top命令 怎么退出？
- MySQL 中decimal 的用法？ 存儲小
- get 、set 、toString 方法的使
- @Resource和 @Autowired注解
- Java基礎操作-- 運算符，流程控制 Flo
- 1. Int 和Integer 的區別，Jav
- spring @retryable不生效的一種
- Spring Security之認證信息的處理
- Spring Security之認證過濾器
- Spring Security概述快速入門
- Spring Security之配置體系
- 【SpringBoot】SpringCache
- Spring Security之基于方法配置權
- redisson分布式鎖中waittime的設
- maven:解決release錯誤：Artif
- restTemplate使用總結
- Spring Security之安全異常處理
- MybatisPlus優雅實現加密？
- Spring ioc容器與Bean的生命周期。
- 【探索SpringCloud】服務發現-Nac
- Spring Security之基于HttpR
- Redis 底層數據結構-簡單動態字符串（SD
- arthas操作spring被代理目標對象命令
- Spring中的單例模式應用詳解
- 聊聊消息隊列，發送消息的4種方式
- bootspring第三方資源配置管理
- GIT同步修改后的遠程分支
提供CDN加速