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

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

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

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

  • 最后用模型去擬合訓練集數據，并在驗證集/測試集上計算模型表現。

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

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

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

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

• 對于一個PyTorch項目，我們需要導入一些Python常用的包來幫助我們快速實現功能。常見的包有os、numpy等，此外還需要調用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 # 根據前面我們對深度學習任務的梳理，有如下幾個超參數可以統一設置，方便后續調試時修改： batch_size = 16 # 批次的大小 lr = 1e-4 # 優化器的學習率 max_epochs = 100 # 制定GPU 方案一： os.environ['CUDA_VISIBLE_DEVICES'] = '0,1' # 指明調用的GPU為0,1號 # 方案二：使用“device”，后續對要使用GPU的變量用.to(device)即可 device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu") # 指明調用的GPU為1號

• PyTorch數據讀入是通過Dataset+DataLoader的方式完成的，Dataset定義好數據的格式和數據變換形式，DataLoader用iterative的方式不斷讀入批次數據。可以定義自己的Dataset類來實現靈活的數據讀取，定義的類需要繼承PyTorch自身的Dataset類。主要包含三個函數：

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

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

  • __len__: 用于返回數據集的樣本數

  • 給出一個例子，其中圖片存放在一個文件夾，另外有一個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)

• 構建好Dataset后，就可以使用DataLoader來按批次讀入數據了，實現代碼如下：

  • 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就是每次讀入的樣本數

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

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

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

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

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

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

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

  • 神經網絡訓練基本上包括重復以下兩個步驟：

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

    • 反向傳播步驟，包括更新網絡權重以最小化損失函數（使用參數的梯度）

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

    • for m in model.modules():if isinstance(m, (nn.Conv2d, nn.Linear)):nn.init.xavier_uniform_(m.weight) # 也可以使用 gain 參數來自定義初始化的標準差來匹配特定的激活函數： 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')

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

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

    • 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函數會遞歸地搜索網絡內的所有module并把參數表示的函數應用到所有的module上。 # 常常將各種初始化方法定義為一個initialize_weights()的函數并在模型初始后進行使用。(自定義初始化函數) # 這段代碼流程是遍歷當前模型的每一層，然后判斷各層屬于什么類型，然后根據不同類型層，設定不同的權值初始化方法。 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網絡 class MLP(nn.Module):# 聲明帶有模型參數的層，這里聲明了兩個全連接層def __init__(self, **kwargs):# 調用MLP父類Block的構造函數來進行必要的初始化。這樣在構造實例時還可以指定其他函數super(MLP, self).__init__(**kwargs)self.hidden = nn.Conv2d(1,1,3)self.act = nn.ReLU()self.output = nn.Linear(10,1) # 定義模型的前向計算，即如何根據輸入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是一種數據驅動的方法，它具有最小的計算量和非常低的計算開銷。初始化是一個2部分的過程，首先初始化標準正交矩陣的權值(與高斯噪聲相反，它只是近似正交)。下一部分是迭代一個小批處理并縮放權重，以便激活的方差為1。作者斷言，在大范圍內，小批量大小對方差的影響可以忽略不計。

    • 使用單位方差將權重初始化為高斯噪聲。

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

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

  • 上文的gain值是可以通過torch.nn.init.calculate_gain(nonlinearity, param=None)計算的,關于計算增益如下表：
  • 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)

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

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

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

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

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

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

    • 自定義調整：通過自定義關于epoch的lambda函數調整學習率(LambdaLR)。

  • 在訓練神經網絡的過程中，學習率是最重要的超參數之一，作為當前較為流行的深度學習框架，PyTorch已經在torch.optim.lr_scheduler為我們封裝好了一些動態調整學習率的方法供我們使用，如下面列出的這些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

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

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

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

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

  • 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)

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

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

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

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

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

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

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

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

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

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

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

  • 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: 每個模型對應的權重:param strict: 輸入模型權重與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 # 創建EMA平滑的shadow權重（對應EMA對象初始化和register方法） # 按照正常的訓練流程，反向傳播更新模型權重 # 更新模型權重之后，再執行EMA平滑，更新shadow權重（對應update方法） # 重復2-3步，直到valid階段 # 備份模型權重，加載shadow權重，使用shadow權重進行模型的valid工作（對應apply_shadow方法） # 使用shadow權重作為模型權重，保存模型 # 恢復模型權重（對應restore方法），繼續重復以上步驟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):"""創建shadow權重"""for name, param in self.model.named_parameters():if param.requires_grad:self.shadow[name] = param.data.clone()def update(self):"""EMA平滑操作，更新shadow權重"""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權重作為模型權重，并創建原模型權重備份"""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):"""恢復模型權重"""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權重，但其計算量與模型的反向傳播相比，成本很小，因此實際上并不會拖慢很對模型的訓練進度； # SWA可以在訓練結束，進行手動加權，完全不增加額外的訓練成本； # 實際使用兩者可以配合使用，可以帶來一點模型性能提升。

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

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

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

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

  • 關于PyTorch中如何使用imgaug每一個人的模板是不一樣的，我在這里也僅僅給出imgaug的issue里面提出的一種解決方案，大家可以根據自己的實際需求進行改變。 具體鏈接：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 # 構建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() ]) # 自定義數據集 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)

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

• 知識蒸餾

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

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

  • 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 # 準備數據集 #設置隨機種子 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) ## 構建教師網絡 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) #損失函數和優化器 loss_function=nn.CrossEntropyLoss() optim=torch.optim.Adam(model.parameters(),lr=0.0001) # 教師網絡訓練 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 #構建學生模型 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) #損失函數和優化器 loss_function=nn.CrossEntropyLoss() optim=torch.optim.Adam(model.parameters(),lr=0.0001) # 學生網絡訓練及預測 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.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) # 學生網絡的訓練和預測結果 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代碼實戰_嗶哩嗶哩_bilibili

• 結構重參數化

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

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

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

  • 重參數其實就是在測試的時候對訓練的網絡結構進行壓縮。比如三個并聯的卷積（kernel size相同）結果的和，其實就等于用求和之后的卷積核進行一次卷積的結果。所以，在訓練的時候可以用三個卷積來提高模型的學習能力，但是在測試部署的時候，可以無損壓縮為一次卷積，從而減少參數量和計算量。

  • 在步長（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

  • 然后實現一個switch_to_deploy方法來對block進行重參數化：

  • # 因為我們是要將三個卷積重參數化為一個卷積，所以 # 只需要計算出重參數化后新卷積的參數即可， # 即卷積層的weight和bias參數. # 新的weight和bias由get_equivalent_kernel_bias() # 方法計算得到. deploy_k, deploy_b = self.get_equivalent_kernel_bias() # 將部署模式設為True, # 這樣forward會使用重參數化后的卷積 self.deploy = True # 定義一個新的卷積用來保存重參數化的參數 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') # 將重參數化的參數送進新的卷積 self.fused_conv.weight.data = deploy_k self.fused_conv.bias.data = deploy_b

  • 然后來看get_equivalent_kernel_bias方法的實現：

  • def get_equivalent_kernel_bias(self):# 重參數化卷積和BN層# 具體方法在上一篇DBBNet文中介紹了#（重參數化方法一：卷積層與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)# 將不同尺寸卷積進行重參數化# 具體方法在上一篇DBBNet文中介紹了# （重參數化方法六：多尺度卷積）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 # 重參數化卷積和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 # 將不同尺寸卷積進行重參數化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

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

• Stochastic Depth

  • 隨機深度文章是發表于ECCV2016，這篇文章早于DenseNet.，DenseNet也是因為隨機深度網絡受到啟發，才提出來。Deep Network with Stochastic depth，在訓練過程中，隨機去掉很多層，并沒有影響算法的收斂性，說明了ResNet具有很好的冗余性。而且去掉中間幾層對最終的結果也沒什么影響，說明ResNet每一層學習的特征信息都非常少，也說明了ResNet具有很好的冗余性。
  • 深的網絡在現在表現出了十分強大的能力，但是也存在許多問題。即使在現代計算機上，梯度會消散、前向傳播中信息的不斷衰減、訓練時間也會非常緩慢等問題。
  • ResNet的強大性能在很多應用中已經得到了證實，盡管如此，ResNet還是有一個不可忽視的缺陷——更深層的網絡通常需要進行數周的訓練——因此，把它應用在實際場景下的成本非常高。為了解決這個問題，作者們引入了一個“反直覺”的方法，即在我們可以在訓練過程中任意地丟棄一些層，并在測試過程中使用完整的網絡。
  • 隨機深度網絡的精度比ResNet更高，證明了其具有更好的泛化能力，這是為什么呢？論文中的解釋是，不激活一部分殘差模塊事實上提現了一種模型融合的思想(和dropout解釋一致)，由于訓練時模型的深度隨機，預測時模型的深度確定，實際是在測試時把不同深度的模型融合了起來。
  • 還有一種解釋是，在深度確定時，信息隨著網絡一層層被提取被過濾，當信息到達網絡的高層時已經不是非常informative了，高層網絡面對這樣的信息難以得到有效的訓練。不激活一部分block，使得高層的block能接收到更多來自底層的信息，能得到更加充分的訓練，因而模型有了更好的表達能力。在預測時，深度確定并且給各個block加權，也事實上是一種模型融合。
  • 隨機深度的代碼實現非常簡單，對于一個批次的數據，通過伯努利分布來隨機挑選一部分的數據跳過連接。為了讓函數可倒，我們將連接層前向的輸出矩陣乘上一個因子來控制連接的概率。和dropout其實是有異曲同工的作用，但是實際的作用，在不同數據集和不同的網絡中表現應該也是不同的，就像dropout很多時候并不一定能提高網絡的性能，具體還得在特定場景進行實驗，從作者的實驗結果中來看，對于層數越多的網絡，隨機深度性能越好，同時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進行調參

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

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

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

    • 創建ArgumentParser()對象

    • 調用add_argument()方法添加參數

    • 使用parse_args()解析參數 。

  • # demo.py import argparse # 創建ArgumentParser()對象 parser = argparse.ArgumentParser() # 添加參數 parser.add_argument('-o', '--output', action='store_true', help="shows output") # action = `store_true` 會將output參數記錄為True # type 規定了參數的格式 # default 規定了默認值 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()解析函數 args = parser.parse_args() if args.output:print("This is some output")print(f"learning rate:{args.lr} ")

  • argparse的參數主要可以分為可選參數和必選參數。可選參數就跟我們的lr參數相類似，未輸入的情況下會設置為默認值。必選參數就跟我們的batch_size參數相類似，當我們給參數設置required =True后，我們就必須傳入該參數，否則就會報錯。看到我們的輸入格式后，我們可能會有這樣一個疑問，我輸入參數的時候不使用–可以嗎？當我們不實用–后，將會嚴格按照參數位置進行解析。

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

  • 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等其他文件，我們就可以使用下面的這樣的結構來調用參數。

    • # 導入必要庫 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 # 隨機數的設置，保證復現結果 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等文件格式去保存超參數進行訓練。argparse 官方教程

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

總結

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

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。