• 一項機器學習任務時常常有以下的幾個重要步驟，

  • 首先是數(shù)據(jù)的預處理，其中重要的步驟包括數(shù)據(jù)格式的統(tǒng)一、異常數(shù)據(jù)的消除和必要的數(shù)據(jù)變換；

  • 然后劃分訓練集、驗證集、測試集，常見的方法包括：按比例隨機選取，KFold方法（我們可以使用sklearn帶的test_train_split函數(shù)、kfold來實現(xiàn)）。

  • 選擇模型，并設(shè)定損失函數(shù)和優(yōu)化方法，以及對應的超參數(shù)（當然可以使用sklearn這樣的機器學習庫中模型自帶的損失函數(shù)和優(yōu)化器）。

  • 最后用模型去擬合訓練集數(shù)據(jù)，并在驗證集/測試集上計算模型表現(xiàn)。

• 深度學習和機器學習在流程上類似，但在代碼實現(xiàn)上有較大的差異。首先，由于深度學習所需的樣本量很大，一次加載全部數(shù)據(jù)運行可能會超出內(nèi)存容量而無法實現(xiàn)；同時還有批（batch）訓練等提高模型表現(xiàn)的策略，需要每次訓練讀取固定數(shù)量的樣本送入模型中訓練，因此深度學習在數(shù)據(jù)加載上需要有專門的設(shè)計。

• 在模型實現(xiàn)上，深度學習和機器學習也有很大差異。由于深度神經(jīng)網(wǎng)絡層數(shù)往往較多，同時會有一些用于實現(xiàn)特定功能的層（如卷積層、池化層、批正則化層、LSTM層等），因此深度神經(jīng)網(wǎng)絡往往需要“逐層”搭建，或者預先定義好可以實現(xiàn)特定功能的模塊，再把這些模塊組裝起來。這種“定制化”的模型構(gòu)建方式能夠充分保證模型的靈活性。

• 上述步驟完成后就可以開始訓練了。我們前面介紹了GPU的概念和GPU用于并行計算加速的功能，不過程序默認是在CPU上運行的，因此在代碼實現(xiàn)中，需要把模型和數(shù)據(jù)“放到”GPU上去做運算，同時還需要保證損失函數(shù)和優(yōu)化器能夠在GPU上工作。如果使用多張GPU進行訓練，還需要考慮模型和數(shù)據(jù)分配、整合的問題。此外，后續(xù)計算一些指標還需要把數(shù)據(jù)“放回”CPU。這里涉及到了一系列有關(guān)于GPU的配置和操作。

• 深度學習中訓練和驗證過程最大的特點在于讀入數(shù)據(jù)是按批的，每次讀入一個批次的數(shù)據(jù)，放入GPU中訓練，然后將損失函數(shù)反向傳播回網(wǎng)絡最前面的層，同時使用優(yōu)化器調(diào)整網(wǎng)絡參數(shù)。這里會涉及到各個模塊配合的問題。訓練/驗證后還需要根據(jù)設(shè)定好的指標計算模型表現(xiàn)。

• 對于一個PyTorch項目，我們需要導入一些Python常用的包來幫助我們快速實現(xiàn)功能。常見的包有os、numpy等，此外還需要調(diào)用PyTorch自身一些模塊便于靈活使用，比如torch、torch.nn、torch.utils.data.Dataset、torch.utils.data.DataLoader、torch.optimizer等等。

  • import os import numpy as np import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader import torch.optim as optimizer # 根據(jù)前面我們對深度學習任務的梳理，有如下幾個超參數(shù)可以統(tǒng)一設(shè)置，方便后續(xù)調(diào)試時修改： batch_size = 16 # 批次的大小 lr = 1e-4 # 優(yōu)化器的學習率 max_epochs = 100 # 制定GPU 方案一： os.environ['CUDA_VISIBLE_DEVICES'] = '0,1' # 指明調(diào)用的GPU為0,1號 # 方案二：使用“device”，后續(xù)對要使用GPU的變量用.to(device)即可 device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu") # 指明調(diào)用的GPU為1號

• PyTorch數(shù)據(jù)讀入是通過Dataset+DataLoader的方式完成的，Dataset定義好數(shù)據(jù)的格式和數(shù)據(jù)變換形式，DataLoader用iterative的方式不斷讀入批次數(shù)據(jù)?？梢远x自己的Dataset類來實現(xiàn)靈活的數(shù)據(jù)讀取，定義的類需要繼承PyTorch自身的Dataset類。主要包含三個函數(shù)：

  • __init__: 用于向類中傳入外部參數(shù)，同時定義樣本集

  • __getitem__: 用于逐個讀取樣本集合中的元素，可以進行一定的變換，并將返回訓練/驗證所需的數(shù)據(jù)

  • __len__: 用于返回數(shù)據(jù)集的樣本數(shù)

  • 給出一個例子，其中圖片存放在一個文件夾，另外有一個csv文件給出了圖片名稱對應的標簽。這種情況下需要自己來定義Dataset類：

  • class MyDataset(Dataset):def __init__(self, data_dir, info_csv, image_list, transform=None):"""Args:data_dir: path to image directory.info_csv: path to the csv file containing image indexeswith corresponding labels.image_list: path to the txt file contains image names to training/validation settransform: optional transform to be applied on a sample."""label_info = pd.read_csv(info_csv)image_file = open(image_list).readlines()self.data_dir = data_dirself.image_file = image_fileself.label_info = label_infoself.transform = transformdef __getitem__(self, index):"""Args:index: the index of itemReturns:image and its labels"""image_name = self.image_file[index].strip('\n')raw_label = self.label_info.loc[self.label_info['Image_index'] == image_name]label = raw_label.iloc[:,0]image_name = os.path.join(self.data_dir, image_name)image = Image.open(image_name).convert('RGB')if self.transform is not None:image = self.transform(image)return image, labeldef __len__(self):return len(self.image_file)

• 構(gòu)建好Dataset后，就可以使用DataLoader來按批次讀入數(shù)據(jù)了，實現(xiàn)代碼如下：

  • from torch.utils.data import DataLoader train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=4, shuffle=True, drop_last=True) val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, num_workers=4, shuffle=False)

  • • batch_size：樣本是按“批”讀入的，batch_size就是每次讀入的樣本數(shù)

    • num_workers：有多少個進程用于讀取數(shù)據(jù)，Windows下該參數(shù)設(shè)置為0，Linux下常見的為4或者8，根據(jù)自己的電腦配置來設(shè)置

    • shuffle：是否將讀入的數(shù)據(jù)打亂，一般在訓練集中設(shè)置為True，驗證集中設(shè)置為False

    • drop_last：對于樣本最后一部分沒有達到批次數(shù)的樣本，使其不再參與訓練

  AI performance = data(70%) + model(CNN、RNN、Transformer、Bert、GPT 20%) + trick(loss、warmup、optimizer、attack-training etc 10%) 記住：數(shù)據(jù)決定了AI的上線，模型和trick只是去逼近這個上線，還是那句老話：garbage in， garbage out?！ヌ谹lex

• 嘗試模型初始化方法，不同的分布，分布參數(shù)。

  • 在深度學習模型的訓練中，權(quán)重的初始值極為重要。一個好的初始值，會使模型收斂速度提高，使模型準確率更精確。一般情況下，我們不使用全0初始值訓練網(wǎng)絡。為了利于訓練和減少收斂時間，我們需要對模型進行合理的初始化。PyTorch也在torch.nn.init中為我們提供了常用的初始化方法。torch.nn.init — PyTorch 1.13 documentation

  • 眾所周知，訓練的開始（即前幾次迭代）非常重要。 如果做得不當，你會得到不好的結(jié)果 - 有時候，網(wǎng)絡根本就不會學到任何東西！ 因此，初始化神經(jīng)網(wǎng)絡權(quán)重的方式是良好訓練的關(guān)鍵因素之一。

  • 神經(jīng)網(wǎng)絡訓練基本上包括重復以下兩個步驟：

    • 一個前向步驟，包括權(quán)重和輸入/激活函數(shù)之間的大量矩陣乘法（我們稱激活函數(shù)為一個層的輸出，它將成為下一層的輸入，即隱藏層的激活函數(shù)結(jié)果）

    • 反向傳播步驟，包括更新網(wǎng)絡權(quán)重以最小化損失函數(shù)（使用參數(shù)的梯度）

  • “Xavier初始化”，2010年在論文“Understanding the difficulty of training deep feedforward neural networks”中提出，Xavier的初始化是通過從標準正態(tài)分布中選擇權(quán)重來完成的，每個元素都要除以輸入維度大小的平方根。Xavier的初始化工作相當好，對于對稱非線性，如sigmoid和Tanh。然而，對于目前最常用的非線性函數(shù)ReLu，它的工作效果并不理想。xavier初始化方法中服從均勻分布U(?a,a) ，分布的參數(shù)a = gain * sqrt(6/fan_in+fan_out)，這里有一個gain，增益的大小是依據(jù)激活函數(shù)類型來設(shè)定

    • for m in model.modules():if isinstance(m, (nn.Conv2d, nn.Linear)):nn.init.xavier_uniform_(m.weight) # 也可以使用 gain 參數(shù)來自定義初始化的標準差來匹配特定的激活函數(shù)： for m in model.modules():if isinstance(m, (nn.Conv2d, nn.Linear)):nn.init.xavier_uniform_(m.weight(), gain=nn.init.calculate_gain('relu'))

  • 2015年在“Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification”一文中提出的“Kaiming初始化”

    • for m in model.modules():if isinstance(m, (nn.Conv2d, nn.Linear)):nn.init.kaiming_normal_(m.weight, mode='fan_in')

  • 實際上，這兩種方案非常相似：“主要”區(qū)別在于Kaiming初始化考慮了每次矩陣乘法后的ReLU激活函數(shù)。

  • 正交初始化（Orthogonal Initialization）,主要用以解決深度網(wǎng)絡下的梯度消失、梯度爆炸問題，在RNN中經(jīng)常使用的參數(shù)初始化方法。

    • for m in model.modules():if isinstance(m, (nn.Conv2d, nn.Linear)):nn.init.orthogonal(m.weight)

  • 模型初始化

    • def weights_init(m):classname = m.__class__.__name__if classname.find('Conv2d') != -1:nn.init.xavier_normal_(m.weight.data)nn.init.constant_(m.bias.data, 0.0)elif classname.find('Linear') != -1:nn.init.xavier_normal_(m.weight)nn.init.constant_(m.bias, 0.0) net = Net() net.apply(weights_init) #apply函數(shù)會遞歸地搜索網(wǎng)絡內(nèi)的所有module并把參數(shù)表示的函數(shù)應用到所有的module上。 # 常常將各種初始化方法定義為一個initialize_weights()的函數(shù)并在模型初始后進行使用。(自定義初始化函數(shù)) # 這段代碼流程是遍歷當前模型的每一層，然后判斷各層屬于什么類型，然后根據(jù)不同類型層，設(shè)定不同的權(quán)值初始化方法。 def initialize_weights(self):for m in self.modules():# 判斷是否屬于Conv2dif isinstance(m, nn.Conv2d):torch.nn.init.xavier_normal_(m.weight.data)# 判斷是否有偏置if m.bias is not None:torch.nn.init.constant_(m.bias.data,0.3)elif isinstance(m, nn.Linear):torch.nn.init.normal_(m.weight.data, 0.1)if m.bias is not None:torch.nn.init.zeros_(m.bias.data)elif isinstance(m, nn.BatchNorm2d):m.weight.data.fill_(1) m.bias.data.zeros_() # 模型的定義，可嘗試初始化下面的MLP網(wǎng)絡 class MLP(nn.Module):# 聲明帶有模型參數(shù)的層，這里聲明了兩個全連接層def __init__(self, **kwargs):# 調(diào)用MLP父類Block的構(gòu)造函數(shù)來進行必要的初始化。這樣在構(gòu)造實例時還可以指定其他函數(shù)super(MLP, self).__init__(**kwargs)self.hidden = nn.Conv2d(1,1,3)self.act = nn.ReLU()self.output = nn.Linear(10,1) # 定義模型的前向計算，即如何根據(jù)輸入x計算返回所需要的模型輸出def forward(self, x):o = self.act(self.hidden(x))return self.output(o) mlp = MLP() print(list(mlp.parameters())) print("-------初始化-------") initialize_weights(mlp) print(list(mlp.parameters()))

  • Mishkin等人在2016年的一篇論文《All you need is a good Init》中介紹了LSUV。LSUV Init是一種數(shù)據(jù)驅(qū)動的方法，它具有最小的計算量和非常低的計算開銷。初始化是一個2部分的過程，首先初始化標準正交矩陣的權(quán)值(與高斯噪聲相反，它只是近似正交)。下一部分是迭代一個小批處理并縮放權(quán)重，以便激活的方差為1。作者斷言，在大范圍內(nèi)，小批量大小對方差的影響可以忽略不計。

    • 使用單位方差將權(quán)重初始化為高斯噪聲。

    • 使用SVD或QR將它們分解為正交坐標。

    • 使用第一個微型批處理在網(wǎng)絡中進行迭代，并在每次迭代比例時權(quán)重以使輸出方差接近1。重復直到輸出方差為1或發(fā)生最大迭代。

  • 上文的gain值是可以通過torch.nn.init.calculate_gain(nonlinearity, param=None)計算的,關(guān)于計算增益如下表：
  • 1 . torch.nn.init.uniform_(tensor, a=0.0, b=1.0) 2 . torch.nn.init.normal_(tensor, mean=0.0, std=1.0) 3 . torch.nn.init.constant_(tensor, val) 4 . torch.nn.init.ones_(tensor) 5 . torch.nn.init.zeros_(tensor) 6 . torch.nn.init.eye_(tensor) 7 . torch.nn.init.dirac_(tensor, groups=1) 8 . torch.nn.init.xavier_uniform_(tensor, gain=1.0) 9 . torch.nn.init.xavier_normal_(tensor, gain=1.0) 10 . torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan__in', nonlinearity='leaky_relu') 11 . torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu') 12 . torch.nn.init.orthogonal_(tensor, gain=1) 13 . torch.nn.init.sparse_(tensor, sparsity, std=0.01) 14 . torch.nn.init.calculate_gain(nonlinearity, param=None)

  • 可以發(fā)現(xiàn)這些函數(shù)除了calculate_gain，所有函數(shù)的后綴都帶有下劃線，意味著這些函數(shù)將會直接原地更改輸入張量的值。

• warmup cosine lr scheduler，先熱身(學習率逐漸攀升)，再進行余弦衰減。

  • 學習率的選擇是深度學習中一個困擾人們許久的問題，學習速率設(shè)置過小，會極大降低收斂速度，增加訓練時間；學習率太大，可能導致參數(shù)在最優(yōu)解兩側(cè)來回振蕩。但是當我們選定了一個合適的學習率后，經(jīng)過許多輪的訓練后，可能會出現(xiàn)準確率震蕩或loss不再下降等情況，說明當前學習率已不能滿足模型調(diào)優(yōu)的需求。此時我們就可以通過一個適當?shù)膶W習率衰減策略來改善這種現(xiàn)象，提高我們的精度。這種設(shè)置方式在PyTorch中被稱為scheduler。torch.optim — PyTorch 1.13 documentation

  • Pytorch學習率調(diào)整策略通過 torch.optim.lr_sheduler 接口實現(xiàn)。pytorch提供的學習率調(diào)整策略分為三大類，

    • 有序調(diào)整：等間隔調(diào)整(Step)，多間隔調(diào)整(MultiStep)，指數(shù)衰減(Exponential)，余弦退火(CosineAnnealing);

    • 自適應調(diào)整：依訓練狀況伺機而變，通過監(jiān)測某個指標的變化情況(loss、accuracy)，當該指標不怎么變化時，就是調(diào)整學習率的時機(ReduceLROnPlateau);

    • 自定義調(diào)整：通過自定義關(guān)于epoch的lambda函數(shù)調(diào)整學習率(LambdaLR)。

  • 在訓練神經(jīng)網(wǎng)絡的過程中，學習率是最重要的超參數(shù)之一，作為當前較為流行的深度學習框架，PyTorch已經(jīng)在torch.optim.lr_scheduler為我們封裝好了一些動態(tài)調(diào)整學習率的方法供我們使用，如下面列出的這些scheduler。

  • lr_scheduler.LambdaLR

  • lr_scheduler.MultiplicativeLR

  • lr_scheduler.StepLR

  • lr_scheduler.MultiStepLR

  • lr_scheduler.ExponentialLR

  • lr_scheduler.CosineAnnealingLR

  • lr_scheduler.ReduceLROnPlateau

  • lr_scheduler.CyclicLR

  • lr_scheduler.OneCycleLR

  • lr_scheduler.CosineAnnealingWarmRestarts

  • # 選擇一種優(yōu)化器 optimizer = torch.optim.Adam(...) # 選擇上面提到的一種或多種動態(tài)調(diào)整學習率的方法 scheduler1 = torch.optim.lr_scheduler.... scheduler2 = torch.optim.lr_scheduler.... schedulern = torch.optim.lr_scheduler.... # 進行訓練 for epoch in range(100):train(...)validate(...)optimizer.step()# 需要在優(yōu)化器參數(shù)更新之后再動態(tài)調(diào)整學習率 # scheduler的優(yōu)化是在每一輪后面進行的 scheduler1.step() schedulern.step()

  • 在使用官方給出的torch.optim.lr_scheduler時，需要將scheduler.step()放在optimizer.step()后面進行使用。

  • 雖然PyTorch官方給我們提供了許多的API，但是在實驗中也有可能碰到需要我們自己定義學習率調(diào)整策略的情況，而我們的方法是自定義函數(shù)adjust_learning_rate來改變param_group中l(wèi)r的值，在下面的敘述中會給出一個簡單的實現(xiàn)。

  • 假設(shè)我們現(xiàn)在正在做實驗，需要學習率每30輪下降為原來的1/10，假設(shè)已有的官方API中沒有符合我們需求的，那就需要自定義函數(shù)來實現(xiàn)學習率的改變。

  • def adjust_learning_rate(optimizer, epoch):lr = args.lr * (0.1 ** (epoch // 30))for param_group in optimizer.param_groups:param_group['lr'] = lr def adjust_learning_rate(optimizer,...):... optimizer = torch.optim.SGD(model.parameters(),lr = args.lr,momentum = 0.9) for epoch in range(10):train(...)validate(...)adjust_learning_rate(optimizer,epoch)

  • 批量越大，隨機梯度的方差越小，引入的噪聲也越小，訓練也越穩(wěn)定，相應地，可以設(shè)置較大的學習率。批量較小時，需要設(shè)置較小的學習率，否則會影響模型收斂。學習率通常要隨著批量大小的增大而相應地增大。線性縮放規(guī)則：當批量大小增加m倍，學習率增大m倍

• 對抗訓練提升模型魯棒性，方法有很多，我常用的是對抗權(quán)重擾動(AWP, AdversarialWeight Perturbation)。

  • 對抗訓練（Adversarial Training）最初由 Ian Goodfellow 等人提出，作為一種防御對抗攻擊的方法，其思路非常簡單直接，將生成的對抗樣本加入到訓練集中去，做一個數(shù)據(jù)增強，讓模型在訓練的時候就先學習一遍對抗樣本。

  • 2018年，Anish Athalye 等人對ICLR中展示的11種對抗防御方法進行了評估，最后他們只在基于對抗訓練的兩種方法上沒有發(fā)現(xiàn)混淆梯度的跡象，自此之后，對抗訓練成為對抗防御研究的主流。

    • 對抗訓練本身有兩個顯著的問題，一個問題是速度極慢，假設(shè)針對每個樣本進行10次PGD對抗攻擊來獲得對抗樣本，那么一個訓練迭代就對梯度多進行了10次反向傳播，訓練用時至少是正常訓練的十倍（因此最初才會使用FGSM等快速攻擊方法來加快對抗訓練）

    • 另一個問題則是精度較低，一方面是模型在正常樣本上的精度降低了，原來可以達到95%以上的分類精度的模型，進行對抗訓練之后，往往只能達到80%~90%（這意味著模型可能要在穩(wěn)健性和精確度之間取舍）；另一方面模型在對抗攻擊下的精度（Robust Accuracy）也不高，目前最好的結(jié)果依然不超過70%。

    • 但對抗攻擊是一個存在問題——只需要針對大部分樣本都能夠生成一個能夠欺騙模型的對抗樣本，這個攻擊方法就是成功的，而對抗防御則是一個任意問題——一個對抗穩(wěn)健的模型，需要能夠正確識別所有潛在攻擊方法生成的對抗樣本，使用對抗攻擊來證明對抗穩(wěn)健性本身就是不靠譜的，得到的只是模型對抗穩(wěn)健性的上界，因此另有一系列研究（Provable Defense）從對抗訓練出發(fā)，轉(zhuǎn)而追求模型對抗穩(wěn)健性的下界。

• 隨機權(quán)重平均（Stochastic Weight Averaging，SWA），通過對訓練過程中的模型權(quán)重進行Avg融合，提升模型魯棒性，PyTorch有官方實現(xiàn)。SWA是一種通過隨機梯度下降改善深度學習模型泛化能力的方法，而且這種方法不會為訓練增加額外的消耗，這種方法可以嵌入到Pytorch中的任何優(yōu)化器類中。主要還是用于穩(wěn)定模型的訓練。

  • 在優(yōu)化的末期取k個優(yōu)化軌跡上的checkpoints，平均他們的權(quán)重，得到最終的網(wǎng)絡權(quán)重，這樣就會使得最終的權(quán)重位于flat曲面更中心的位置，緩解權(quán)重震蕩問題，獲得一個更加平滑的解，相比于傳統(tǒng)訓練有更泛化的解。

  • 在EMA指數(shù)滑動平均（Exponential Moving Average）我們討論了指數(shù)滑動平均，可以發(fā)現(xiàn)SWA和EMA是有相似之處：都是在訓練之外的操作，不影響訓練過程。與集成學習類似，都是一種權(quán)值的平均，EMA是一種指數(shù)平均，會賦予近期更多的權(quán)重，SWA則是平均賦權(quán)重。

  • EMA指數(shù)移動平均：shadow權(quán)重是通過歷史的模型權(quán)重指數(shù)加權(quán)平均數(shù)來累積的，每次shadow權(quán)重的更新都會受上一次shadow權(quán)重的影響，所以shadow權(quán)重的更新都會帶有前幾次模型權(quán)重的慣性，歷史權(quán)重越久遠，其重要性就越小，這樣可以使得權(quán)重更新更加平滑。

  • import torch import torch.nn as nn def apply_swa(model: nn.Module,checkpoint_list: list,weight_list: list,strict: bool = True):""":param model::param checkpoint_list: 要進行swa的模型路徑列表:param weight_list: 每個模型對應的權(quán)重:param strict: 輸入模型權(quán)重與checkpoint是否需要完全匹配:return:"""checkpoint_tensor_list = [torch.load(f, map_location='cpu') for f in checkpoint_list]for name, param in model.named_parameters():try:param.data = sum([ckpt['model'][name] * w for ckpt, w in zip(checkpoint_tensor_list, weight_list)])except KeyError:if strict:raise KeyError(f"Can't match '{name}' from checkpoint")else:print(f"Can't match '{name}' from checkpoint")return model # 創(chuàng)建EMA平滑的shadow權(quán)重（對應EMA對象初始化和register方法） # 按照正常的訓練流程，反向傳播更新模型權(quán)重 # 更新模型權(quán)重之后，再執(zhí)行EMA平滑，更新shadow權(quán)重（對應update方法） # 重復2-3步，直到valid階段 # 備份模型權(quán)重，加載shadow權(quán)重，使用shadow權(quán)重進行模型的valid工作（對應apply_shadow方法） # 使用shadow權(quán)重作為模型權(quán)重，保存模型 # 恢復模型權(quán)重（對應restore方法），繼續(xù)重復以上步驟2-7。 import torch import torch.nn as nn from torch.utils.data import DataLoader class EMA:def __init__(self, model: nn.Module,decay: float = 0.999):self.model = modelself.decay = decayself.shadow = {}self.backup = {}def register(self):"""創(chuàng)建shadow權(quán)重"""for name, param in self.model.named_parameters():if param.requires_grad:self.shadow[name] = param.data.clone()def update(self):"""EMA平滑操作，更新shadow權(quán)重"""for name, param in self.model.named_parameters():if param.requires_grad:assert name in self.shadownew_average = (1.0 - self.decay) * param.data + self.decay * self.shadow[name]self.shadow[name] = new_average.clone()def apply_shadow(self):"""使用shadow權(quán)重作為模型權(quán)重，并創(chuàng)建原模型權(quán)重備份"""for name, param in self.model.named_parameters():if param.requires_grad:assert name in self.shadowself.backup[name] = param.dataparam.data = self.shadow[name]def restore(self):"""恢復模型權(quán)重"""for name, param in self.model.named_parameters():if param.requires_grad:assert name in self.backupparam.data = self.backup[name]self.backup = {} # EMA需要在每步訓練時，同步更新shadow權(quán)重，但其計算量與模型的反向傳播相比，成本很小，因此實際上并不會拖慢很對模型的訓練進度； # SWA可以在訓練結(jié)束，進行手動加權(quán)，完全不增加額外的訓練成本； # 實際使用兩者可以配合使用，可以帶來一點模型性能提升。

• 數(shù)據(jù)增強：resize、crop、flip、ratate、blur、HSV變化、affine（仿射）、perspective（透視）、Mixup、cutout、cutmix、Random Erasing（隨機擦除）、Mosaic（馬賽克）、CopyPaste、GANs domain transfer等）

  • 在機器學習/深度學習中，我們經(jīng)常會遇到模型過擬合的問題，為了解決過擬合問題，我們可以通過加入正則項或者減少模型學習參數(shù)來解決，但是最簡單的避免過擬合的方法是增加數(shù)據(jù)，但是在許多場景我們無法獲得大量數(shù)據(jù)，例如醫(yī)學圖像分析。數(shù)據(jù)增強技術(shù)的存在是為了解決這個問題，這是針對有限數(shù)據(jù)問題的解決方案。數(shù)據(jù)增強一套技術(shù)，可提高訓練數(shù)據(jù)集的大小和質(zhì)量，以便我們可以使用它們來構(gòu)建更好的深度學習模型。 在計算視覺領(lǐng)域，生成增強圖像相對容易。即使引入噪聲或裁剪圖像的一部分，模型仍可以對圖像進行分類，數(shù)據(jù)增強有一系列簡單有效的方法可供選擇，有一些機器學習庫來進行計算視覺領(lǐng)域的數(shù)據(jù)增強，比如：imgaug 官網(wǎng)它封裝了很多數(shù)據(jù)增強算法，給開發(fā)者提供了方便。

  • imgaug是計算機視覺任務中常用的一個數(shù)據(jù)增強的包，相比于torchvision.transforms，它提供了更多的數(shù)據(jù)增強方法，因此在各種競賽中，人們廣泛使用imgaug來對數(shù)據(jù)進行增強操作Readthedocs：imgaug

  • imgaug僅僅提供了圖像增強的一些方法，但是并未提供圖像的IO操作，因此我們需要使用一些庫來對圖像進行導入，建議使用imageio進行讀入，如果使用的是opencv進行文件讀取的時候，需要進行手動改變通道，將讀取的BGR圖像轉(zhuǎn)換為RGB圖像。除此以外，當我們用PIL.Image進行讀取時，因為讀取的圖片沒有shape的屬性，所以我們需要將讀取到的img轉(zhuǎn)換為np.array()的形式再進行處理。因此官方的例程中也是使用imageio進行圖片讀取。官方提供notebook例程：notebook

  • 關(guān)于PyTorch中如何使用imgaug每一個人的模板是不一樣的，我在這里也僅僅給出imgaug的issue里面提出的一種解決方案，大家可以根據(jù)自己的實際需求進行改變。 具體鏈接：how to use imgaug with pytorch

    • import numpy as np from imgaug import augmenters as iaa from torch.utils.data import DataLoader, Dataset from torchvision import transforms # 構(gòu)建pipline tfs = transforms.Compose([iaa.Sequential([iaa.flip.Fliplr(p=0.5),iaa.flip.Flipud(p=0.5),iaa.GaussianBlur(sigma=(0.0, 0.1)),iaa.MultiplyBrightness(mul=(0.65, 1.35)),]).augment_image,# 不要忘記了使用ToTensor()transforms.ToTensor() ]) # 自定義數(shù)據(jù)集 class CustomDataset(Dataset):def __init__(self, n_images, n_classes, transform=None):# 圖片的讀取，建議使用imageioself.images = np.random.randint(0, 255,(n_images, 224, 224, 3),dtype=np.uint8)self.targets = np.random.randn(n_images, n_classes)self.transform = transformdef __getitem__(self, item):image = self.images[item]target = self.targets[item]if self.transform:image = self.transform(image)return image, targetdef __len__(self):return len(self.images) def worker_init_fn(worker_id):imgaug.seed(np.random.get_state()[1][0] + worker_id) custom_ds = CustomDataset(n_images=50, n_classes=10, transform=tfs) custom_dl = DataLoader(custom_ds, batch_size=64,num_workers=4, pin_memory=True, worker_init_fn=worker_init_fn)

  • 關(guān)于num_workers在Windows系統(tǒng)上只能設(shè)置成0，但是當我們使用Linux遠程服務器時，可能使用不同的num_workers的數(shù)量，這是我們就需要注意worker_init_fn()函數(shù)的作用了。它保證了我們使用的數(shù)據(jù)增強在num_workers>0時是對數(shù)據(jù)的增強是隨機的。

• 知識蒸餾

  • 在訓練的時候，我們可以去花費一切的資源和算力去訓練模型，得到的結(jié)果也是非常好的，但是在應用落地的時候，也就是需要在一些嵌入式設(shè)備使用的時候，那么這么龐大的模型肯定是不能夠在手機端或者其他設(shè)備上運行的，或者需要的推理時間非常長，那么這個模型就只能在實驗室待著了。為了解決這樣的現(xiàn)象，就提出了知識蒸餾的算法理論，就是將龐大的教師模型的重要的東西讓學生模型來逼近和訓練，讓參數(shù)量少的學生模型能夠和教師模型的效果差不多，或者比老師模型效果更好。這就是知識蒸餾的簡單原理。

  • 在說到知識蒸餾之前，首先說一下標簽問題，在我們剛學習分類任務的時候，比如手寫數(shù)字集，它的標簽就是0,1-9,或者直接就是用獨熱編碼的形式來作為標簽。那么這樣的做法到底好不好呢，對于這樣的問題就有人說這樣的標簽容易讓網(wǎng)絡訓練的過于絕對化，其實馬也有一部分像驢，或者說驢也有一部分像馬，如果將馬的標簽變成1，驢和汽車都是0，那么是不是就讓驢和汽車的概率等同了，或者說驢和馬的潛在關(guān)系直接被網(wǎng)絡 忽略了。所以就又提出了soft targets。就是把標簽要保持驢和馬的潛在關(guān)系。這樣的話這個網(wǎng)絡就能夠?qū)W到更多的潛在知識。

  • import torch import torch.nn as nn import torch.nn.functional as F import torchvision from torchvision import transforms from torch.utils.data import DataLoader from torchinfo import summary # 準備數(shù)據(jù)集 #設(shè)置隨機種子 torch.manual_seed(0) device=torch.device("cuda" if torch.cuda.is_available() else "cpu") #使用cuda進行加速卷積運算 torch.backends.cudnn.benchmark=True #載入訓練集 train_dataset=torchvision.datasets.MNIST(root="dataset/",train=True,transform=transforms.ToTensor(),download=True) test_dateset=torchvision.datasets.MNIST(root="dataset/",train=False,transform=transforms.ToTensor(),download=True) train_dataloder=DataLoader(train_dataset,batch_size=32,shuffle=True) test_dataloder=DataLoader(test_dateset,batch_size=32,shuffle=True) ## 構(gòu)建教師網(wǎng)絡 class Teacher_model(nn.Module):def __init__(self,in_channels=1,num_class=10):super(Teacher_model, self).__init__()self.fc1=nn.Linear(784,1200)self.fc2=nn.Linear(1200,1200)self.fc3=nn.Linear(1200,10)self.relu=nn.ReLU()self.dropout=nn.Dropout(0.5)def forward(self,x):x=x.view(-1,784)x=self.fc1(x)x=self.dropout(x)x=self.relu(x)x = self.fc2(x)x = self.dropout(x)x = self.relu(x)x = self.fc3(x)return x model=Teacher_model() model=model.to(device) #損失函數(shù)和優(yōu)化器 loss_function=nn.CrossEntropyLoss() optim=torch.optim.Adam(model.parameters(),lr=0.0001) # 教師網(wǎng)絡訓練 epoches=6 for epoch in range(epoches):model.train()for image,label in train_dataloder:image,label=image.to(device),label.to(device)optim.zero_grad()out=model(image)loss=loss_function(out,label)loss.backward()optim.step()model.eval()num_correct=0num_samples=0with torch.no_grad():for image,label in test_dataloder:image=image.to(device)label=label.to(device)out=model(image)pre=out.max(1).indicesnum_correct+=(pre==label).sum()num_samples+=pre.size(0)acc=(num_correct/num_samples).item()model.train()print("epoches:{},accurate={}".format(epoch,acc)) teacher_model=model #構(gòu)建學生模型 class Student_model(nn.Module):def __init__(self,in_channels=1,num_class=10):super(Student_model, self).__init__()self.fc1 = nn.Linear(784, 20)self.fc2 = nn.Linear(20, 20)self.fc3 = nn.Linear(20, 10)self.relu = nn.ReLU()#self.dropout = nn.Dropout(0.5)def forward(self, x):x = x.view(-1, 784)x = self.fc1(x)#x = self.dropout(x)x = self.relu(x)x = self.fc2(x)#x = self.dropout(x)x = self.relu(x)x = self.fc3(x)return x model=Student_model() model=model.to(device) #損失函數(shù)和優(yōu)化器 loss_function=nn.CrossEntropyLoss() optim=torch.optim.Adam(model.parameters(),lr=0.0001) # 學生網(wǎng)絡訓練及預測 epoches=6 for epoch in range(epoches):model.train()for image,label in train_dataloder:image,label=image.to(device),label.to(device)optim.zero_grad()out=model(image)loss=loss_function(out,label)loss.backward()optim.step()model.eval()num_correct=0num_samples=0with torch.no_grad():for image,label in test_dataloder:image=image.to(device)label=label.to(device)out=model(image)pre=out.max(1).indicesnum_correct+=(pre==label).sum()num_samples+=pre.size(0)acc=(num_correct/num_samples).item()model.train()print("epoches:{},accurate={}".format(epoch,acc)) # 知識蒸餾參數(shù)設(shè)置 開始進行知識蒸餾算法 teacher_model.eval() model=Student_model() model=model.to(device) #蒸餾溫度 T=7 hard_loss=nn.CrossEntropyLoss() alpha=0.3 soft_loss=nn.KLDivLoss(reduction="batchmean") optim=torch.optim.Adam(model.parameters(),lr=0.0001) # 學生網(wǎng)絡的訓練和預測結(jié)果 epoches=5 for epoch in range(epoches):model.train()for image,label in train_dataloder:image,label=image.to(device),label.to(device)with torch.no_grad():teacher_output=teacher_model(image)optim.zero_grad()out=model(image)loss=hard_loss(out,label)ditillation_loss=soft_loss(F.softmax(out/T,dim=1),F.softmax(teacher_output/T,dim=1)) # 老師教學生重點loss_all=loss*alpha+ditillation_loss*(1-alpha)loss.backward()optim.step()model.eval()num_correct=0num_samples=0with torch.no_grad():for image,label in test_dataloder:image=image.to(device)label=label.to(device)out=model(image)pre=out.max(1).indicesnum_correct+=(pre==label).sum()num_samples+=pre.size(0)acc=(num_correct/num_samples).item()model.train()print("epoches:{},accurate={}".format(epoch,acc))

  • 知識蒸餾Pytorch代碼實戰(zhàn)_嗶哩嗶哩_bilibili

• 結(jié)構(gòu)重參數(shù)化

  • 結(jié)構(gòu)重參數(shù)化（structural re-parameterization）指的是首先構(gòu)造一系列結(jié)構(gòu)（一般用于訓練），并將其參數(shù)等價轉(zhuǎn)換為另一組參數(shù)（一般用于推理），從而將這一系列結(jié)構(gòu)等價轉(zhuǎn)換為另一系列結(jié)構(gòu)。在現(xiàn)實場景中，訓練資源一般是相對豐富的，我們更在意推理時的開銷和性能，因此我們想要訓練時的結(jié)構(gòu)較大，具備好的某種性質(zhì)（更高的精度或其他有用的性質(zhì)，如稀疏性），轉(zhuǎn)換得到的推理時結(jié)構(gòu)較小且保留這種性質(zhì)（相同的精度或其他有用的性質(zhì)）。換句話說，“結(jié)構(gòu)重參數(shù)化”這個詞的本意就是：用一個結(jié)構(gòu)的一組參數(shù)轉(zhuǎn)換為另一組參數(shù)，并用轉(zhuǎn)換得到的參數(shù)來參數(shù)化（parameterize）另一個結(jié)構(gòu)。只要參數(shù)的轉(zhuǎn)換是等價的，這兩個結(jié)構(gòu)的替換就是等價的。

  • ACNet (ICCV-2019)：Reparam(KxK) = KxK-BN + 1xK-BN + Kx1-BN。這一記法表示用三個平行分支（KxK，1xK，Kx1）的加和來替換一個KxK卷積。注意三個分支各跟一個BN，三個分支分別過BN之后再相加。這樣做可以提升卷積網(wǎng)絡的性能。

  • RepVGG (CVPR-2021)：Reparam(3x3) = 3x3-BN + 1x1-BN + BN。對每個3x3卷積，在訓練時給它構(gòu)造并行的恒等和1x1卷積分支，并各自過BN后相加。我們簡單堆疊這樣的結(jié)構(gòu)得到形成了一個VGG式的直筒型架構(gòu)。推理時的這個架構(gòu)僅有一路3x3卷積夾ReLU，連分支結(jié)構(gòu)都沒有，可以說“一卷到底”，效率很高。這樣簡單的結(jié)構(gòu)在ImageNet上可以達到超過80%的準確率，比較精度和速度可以超過或打平RegNet等SOTA模型。

  • 重參數(shù)其實就是在測試的時候?qū)τ柧毜木W(wǎng)絡結(jié)構(gòu)進行壓縮。比如三個并聯(lián)的卷積（kernel size相同）結(jié)果的和，其實就等于用求和之后的卷積核進行一次卷積的結(jié)果。所以，在訓練的時候可以用三個卷積來提高模型的學習能力，但是在測試部署的時候，可以無損壓縮為一次卷積，從而減少參數(shù)量和計算量。

  • 在步長（stride）為1的情況下，對于3×3卷積，需要對它的四周進行大小為1的padding（白色部分）；對于1×3卷積，對它的左右兩邊進行大小為1的padding（白色部分）；對于3×1卷積，對它的上下兩邊進行大小為1的padding（白色部分）。這樣三個卷積的輸出大小一致，可以直接相加。

  • def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=1, dilation=1, groups=1, padding_mode='zeros', use_affine=True, bias=True):super(ACBlock, self).__init__()# 表示模型處于非部署模式(訓練階段)self.deploy = False # 非部署模式，定義一個3×3卷積、一個3×1卷積和一個1×3卷積# 首先定義3×3卷積self.square_conv = nn.Conv2d(in_channels=in_channels,out_channels=out_channels,kernel_size=(kernel_size, kernel_size),stride=stride,padding=padding,dilation=dilation,groups=groups,bias=bias,padding_mode=padding_mode)self.square_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)# 計算3×1卷積和1×3卷積的padding大小# 對于k×k卷積，當希望保持輸出尺寸時，# 一般采用 kernel_size // 2作為padding的大小.# 例如，對3×3卷積，padding大小為1；# 對于5×5卷積，padding大小為2，以此類推。# 當padding的大小能夠保持或增大輸出尺寸時，# 計算1×3卷積和3×1卷積的paddingif padding - kernel_size // 2 >= 0:self.crop = 0hor_padding = [padding - kernel_size // 2, padding]ver_padding = [padding, padding - kernel_size // 2]else:raise Exception("No support for negative padding!")# 定義3×1卷積self.ver_conv = nn.Conv2d(in_channels=in_channels,out_channels=out_channels,kernel_size=(kernel_size, 1),stride=stride,padding=ver_padding,dilation=dilation,groups=groups,bias=bias,padding_mode=padding_mode)# 定義1×3卷積self.hor_conv = nn.Conv2d(in_channels=in_channels,out_channels=out_channels,kernel_size=(1, kernel_size),stride=stride,padding=hor_padding,dilation=dilation,groups=groups,bias=bias,padding_mode=padding_mode)self.ver_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)self.hor_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine) def forward(self, input):if self.deploy:return self.fused_conv(input)else:square_outputs = self.square_conv(input)square_outputs = self.square_bn(square_outputs)ver_input = inputhor_input = inputvertical_outputs = self.ver_conv(ver_input)vertical_outputs = self.ver_bn(vertical_outputs)horizontal_outputs = self.hor_conv(hor_input)horizontal_outputs = self.hor_bn(horizontal_outputs)result = square_outputs + vertical_outputs + horizontal_outputsreturn result

  • 然后實現(xiàn)一個switch_to_deploy方法來對block進行重參數(shù)化：

  • # 因為我們是要將三個卷積重參數(shù)化為一個卷積，所以 # 只需要計算出重參數(shù)化后新卷積的參數(shù)即可， # 即卷積層的weight和bias參數(shù). # 新的weight和bias由get_equivalent_kernel_bias() # 方法計算得到. deploy_k, deploy_b = self.get_equivalent_kernel_bias() # 將部署模式設(shè)為True, # 這樣forward會使用重參數(shù)化后的卷積 self.deploy = True # 定義一個新的卷積用來保存重參數(shù)化的參數(shù) self.fused_conv = nn.Conv2d(in_channels=self.square_conv.in_channels,out_channels=self.square_conv.out_channels,kernel_size=self.square_conv.kernel_size,stride=self.square_conv.stride,padding=self.square_conv.padding,dilation=self.square_conv.dilation,groups=self.square_conv.groups,bias=True,padding_mode=self.square_conv.padding_mode) # 刪除原來三條分支的卷積和BN self.__delattr__('square_conv') self.__delattr__('square_bn') self.__delattr__('hor_conv') self.__delattr__('hor_bn') self.__delattr__('ver_conv') self.__delattr__('ver_bn') # 將重參數(shù)化的參數(shù)送進新的卷積 self.fused_conv.weight.data = deploy_k self.fused_conv.bias.data = deploy_b

  • 然后來看get_equivalent_kernel_bias方法的實現(xiàn)：

  • def get_equivalent_kernel_bias(self):# 重參數(shù)化卷積和BN層# 具體方法在上一篇DBBNet文中介紹了#（重參數(shù)化方法一：卷積層與BN層的合并）hor_k, hor_b = self._fuse_bn_tensor(self.hor_conv, self.hor_bn)ver_k, ver_b = self._fuse_bn_tensor(self.ver_conv, self.ver_bn)square_k, square_b = self._fuse_bn_tensor(self.square_conv, self.square_bn)# 將不同尺寸卷積進行重參數(shù)化# 具體方法在上一篇DBBNet文中介紹了# （重參數(shù)化方法六：多尺度卷積）self._add_to_square_kernel(square_k, hor_k)self._add_to_square_kernel(square_k, ver_k)return square_k, hor_b + ver_b + square_b # 重參數(shù)化卷積和BN層 def _fuse_bn_tensor(self, conv, bn):std = (bn.running_var + bn.eps).sqrt()t = (bn.weight / std).reshape(-1, 1, 1, 1)return conv.weight * t, bn.bias - bn.running_mean * bn.weight / std # 將不同尺寸卷積進行重參數(shù)化def _add_to_square_kernel(self, square_kernel, asym_kernel):asym_h = asym_kernel.size(2)asym_w = asym_kernel.size(3)square_h = square_kernel.size(2)square_w = square_kernel.size(3)square_kernel[:, :, square_h // 2 - asym_h // 2: square_h // 2 - asym_h // 2 + asym_h,square_w // 2 - asym_w // 2: square_w // 2 - asym_w // 2 + asym_w] += asym_kernel

  • 深度學習理論與實踐—重參數(shù)化卷積神經(jīng)網(wǎng)絡：ACNet & RepVGG - 知乎 (zhihu.com)

• Stochastic Depth

  • 隨機深度文章是發(fā)表于ECCV2016，這篇文章早于DenseNet.，DenseNet也是因為隨機深度網(wǎng)絡受到啟發(fā)，才提出來。Deep Network with Stochastic depth，在訓練過程中，隨機去掉很多層，并沒有影響算法的收斂性，說明了ResNet具有很好的冗余性。而且去掉中間幾層對最終的結(jié)果也沒什么影響，說明ResNet每一層學習的特征信息都非常少，也說明了ResNet具有很好的冗余性。
  • 深的網(wǎng)絡在現(xiàn)在表現(xiàn)出了十分強大的能力，但是也存在許多問題。即使在現(xiàn)代計算機上，梯度會消散、前向傳播中信息的不斷衰減、訓練時間也會非常緩慢等問題。
  • ResNet的強大性能在很多應用中已經(jīng)得到了證實，盡管如此，ResNet還是有一個不可忽視的缺陷——更深層的網(wǎng)絡通常需要進行數(shù)周的訓練——因此，把它應用在實際場景下的成本非常高。為了解決這個問題，作者們引入了一個“反直覺”的方法，即在我們可以在訓練過程中任意地丟棄一些層，并在測試過程中使用完整的網(wǎng)絡。
  • 隨機深度網(wǎng)絡的精度比ResNet更高，證明了其具有更好的泛化能力，這是為什么呢？論文中的解釋是，不激活一部分殘差模塊事實上提現(xiàn)了一種模型融合的思想(和dropout解釋一致)，由于訓練時模型的深度隨機，預測時模型的深度確定，實際是在測試時把不同深度的模型融合了起來。
  • 還有一種解釋是，在深度確定時，信息隨著網(wǎng)絡一層層被提取被過濾，當信息到達網(wǎng)絡的高層時已經(jīng)不是非常informative了，高層網(wǎng)絡面對這樣的信息難以得到有效的訓練。不激活一部分block，使得高層的block能接收到更多來自底層的信息，能得到更加充分的訓練，因而模型有了更好的表達能力。在預測時，深度確定并且給各個block加權(quán)，也事實上是一種模型融合。
  • 隨機深度的代碼實現(xiàn)非常簡單，對于一個批次的數(shù)據(jù)，通過伯努利分布來隨機挑選一部分的數(shù)據(jù)跳過連接。為了讓函數(shù)可倒，我們將連接層前向的輸出矩陣乘上一個因子來控制連接的概率。和dropout其實是有異曲同工的作用，但是實際的作用，在不同數(shù)據(jù)集和不同的網(wǎng)絡中表現(xiàn)應該也是不同的，就像dropout很多時候并不一定能提高網(wǎng)絡的性能，具體還得在特定場景進行實驗，從作者的實驗結(jié)果中來看，對于層數(shù)越多的網(wǎng)絡，隨機深度性能越好，同時drop率也要相應增加。
  • def drop_path(x, drop_prob: float = 0., training: bool = False):"""Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).This is the same as the DropConnect impl I created for EfficientNet, etc networks, however,the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted forchanging the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use'survival rate' as the argument."""if drop_prob == 0. or not training:return xkeep_prob = 1 - drop_probshape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensors, not just 2D ConvNetsrandom_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)random_tensor.floor_() # binarizeoutput = x.div(keep_prob) * random_tensorreturn output class DropPath(nn.Module):"""Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""def __init__(self, drop_prob=None):super(DropPath, self).__init__()self.drop_prob = drop_probdef forward(self, x):return drop_path(x, self.drop_prob, self.training) # 在block的前向傳播中，在最后的鏈接處使用def forward(self, x):shortcut = xif self.conv_exp is not None:x = self.conv_exp(x)x = self.conv_dw(x)if self.se is not None:x = self.se(x)x = self.act_dw(x)x = self.conv_pwl(x)if self.drop_path is not None: # 是否使用隨機深度x = self.drop_path(x)if self.use_shortcut:x[:, 0:self.in_channels] += shortcutreturn x

• 使用argparse進行調(diào)參

  • 在深度學習中時，超參數(shù)的修改和保存是非常重要的一步，尤其是當我們在服務器上跑我們的模型時，如何更方便的修改超參數(shù)是我們需要考慮的一個問題。這時候，要是有一個庫或者函數(shù)可以解析我們輸入的命令行參數(shù)再傳入模型的超參數(shù)中該多好。到底有沒有這樣的一種方法呢？答案是肯定的，這個就是 Python 標準庫的一部分：Argparse。

  • argsparse是python的命令行解析的標準模塊，內(nèi)置于python，不需要安裝。這個庫可以讓我們直接在命令行中就可以向程序中傳入?yún)?shù)。我們可以使用python file.py來運行python文件。而argparse的作用就是將命令行傳入的其他參數(shù)進行解析、保存和使用。在使用argparse后，我們在命令行輸入的參數(shù)就可以以這種形式python file.py --lr 1e-4 --batch_size 32來完成對常見超參數(shù)的設(shè)置。

  • 總的來說，我們可以將argparse的使用歸納為以下三個步驟。

    • 創(chuàng)建ArgumentParser()對象

    • 調(diào)用add_argument()方法添加參數(shù)

    • 使用parse_args()解析參數(shù) 。

  • # demo.py import argparse # 創(chuàng)建ArgumentParser()對象 parser = argparse.ArgumentParser() # 添加參數(shù) parser.add_argument('-o', '--output', action='store_true', help="shows output") # action = `store_true` 會將output參數(shù)記錄為True # type 規(guī)定了參數(shù)的格式 # default 規(guī)定了默認值 parser.add_argument('--lr', type=float, default=3e-5, help='select the learning rate, default=1e-3') parser.add_argument('--batch_size', type=int, required=True, help='input batch size') # 使用parse_args()解析函數(shù) args = parser.parse_args() if args.output:print("This is some output")print(f"learning rate:{args.lr} ")

  • argparse的參數(shù)主要可以分為可選參數(shù)和必選參數(shù)?？蛇x參數(shù)就跟我們的lr參數(shù)相類似，未輸入的情況下會設(shè)置為默認值。必選參數(shù)就跟我們的batch_size參數(shù)相類似，當我們給參數(shù)設(shè)置required =True后，我們就必須傳入該參數(shù)，否則就會報錯?？吹轿覀兊妮斎敫袷胶?#xff0c;我們可能會有這樣一個疑問，我輸入?yún)?shù)的時候不使用–可以嗎？當我們不實用–后，將會嚴格按照參數(shù)位置進行解析。

  • 通常情況下，為了使代碼更加簡潔和模塊化，我一般會將有關(guān)超參數(shù)的操作寫在config.py，然后在train.py或者其他文件導入就可以。具體的config.py可以參考如下內(nèi)容。

  • import argparse def get_options(parser=argparse.ArgumentParser()): parser.add_argument('--workers', type=int, default=0, help='number of data loading workers, you had better put it 4 times of your gpu') parser.add_argument('--batch_size', type=int, default=4, help='input batch size, default=64') parser.add_argument('--niter', type=int, default=10, help='number of epochs to train for, default=10') parser.add_argument('--lr', type=float, default=3e-5, help='select the learning rate, default=1e-3') parser.add_argument('--seed', type=int, default=118, help="random seed") parser.add_argument('--cuda', action='store_true', default=True, help='enables cuda') parser.add_argument('--checkpoint_path',type=str,default='', help='Path to load a previous trained model if not empty (default empty)') parser.add_argument('--output',action='store_true',default=True,help="shows output") opt = parser.parse_args() if opt.output: print(f'num_workers: {opt.workers}') print(f'batch_size: {opt.batch_size}') print(f'epochs (niters) : {opt.niter}') print(f'learning rate : {opt.lr}') print(f'manual_seed: {opt.seed}') print(f'cuda enable: {opt.cuda}') print(f'checkpoint_path: {opt.checkpoint_path}') return opt if __name__ == '__main__': opt = get_options()

  • 隨后在train.py等其他文件，我們就可以使用下面的這樣的結(jié)構(gòu)來調(diào)用參數(shù)。

    • # 導入必要庫 import config opt = config.get_options() manual_seed = opt.seed num_workers = opt.workers batch_size = opt.batch_size lr = opt.lr niters = opt.niters checkpoint_path = opt.checkpoint_path # 隨機數(shù)的設(shè)置，保證復現(xiàn)結(jié)果 def set_seed(seed):torch.manual_seed(seed)torch.cuda.manual_seed_all(seed)random.seed(seed)np.random.seed(seed)torch.backends.cudnn.benchmark = Falsetorch.backends.cudnn.deterministic = True if __name__ == '__main__':set_seed(manual_seed)for epoch in range(niters):train(model,lr,batch_size,num_workers,checkpoint_path)val(model,lr,batch_size,num_workers,checkpoint_path)

  • argparse給我們提供了一種新的更加便捷的方式，而在一些大型的深度學習庫中人們也會使用json、dict、yaml等文件格式去保存超參數(shù)進行訓練。argparse 官方教程

• 添加注意力機制（SE,CBAM,ECA,CA…）

總結(jié)

以上是生活随笔為你收集整理的模型涨点的思路，深度学习训练的tricks-计算机视觉的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。