前言

代碼倉庫地址：https://github.com/Oneflow-Inc/one-yolov5歡迎star one-yolov5項目 獲取最新的動態(tài)。如果您有問題，歡迎在倉庫給我們提出寶貴的意見。如果對您有幫助，歡迎來給我Star呀~

由于文章中一些鏈接會被微信公眾號吃掉，所以推薦訪問文章的原始地址獲得更好的閱讀體驗。https://start.oneflow.org/oneflow-yolo-doc/source_code_interpretation/utils/autoanchor_py.html

源碼解讀： utils/autoanchor.py

摘要

維度聚類（Dimension Clusters）。當把 YOLO 結合 anchor boxes 使用時，我們會遇到兩個問題： 首先 anchor boxes 的尺寸是手工挑選的。雖然網絡可以通過學習適當地調整 anchor boxes 形狀，但是如果我們從一開始就為網絡選擇更好的 anchor boxes ，就可以讓網絡更容易學習并獲得更好的檢測結果。

圖1：VOC 和 COCO 上的聚類框尺寸。我們在邊界框的維度(dimensions of bounding boxes) 上運行 K-means聚類，以獲得我們模型良好的初始 anchor boxes 。左圖顯示了我們通過 k 的各種選擇獲得的 Avg IoU 。我們發(fā)現(xiàn) k = 5 為召回與模型的復雜性提供了良好的折中。 右圖顯示了在 VOC 和 COCO 上聚類簇的相對中心, 并且這兩種不同的 k 對應方案都喜歡更稀疏的，更高的框，此外在 COCO 的尺寸的變化比 VOC 更大。

我們不用手工選擇 anchor boxes，而是在訓練集的邊界框上的維度上運行 K-means 聚類算法，自動找到良好的 anchor boxes 。 如果我們使用具有歐幾里得距離的標準 K-means，那么較大的框會比較小的框產生更多的誤差。 但我們真正想要的是獨立于框的大小的，能獲得良好的 IoU 分數的 anchor boxes 。 因此對于距離的度量方式我們使用:

我們用不同的 值運行 K-means算法，并繪制最接近聚類中心的平均 Avg IoU（見圖1）。為了在模型復雜度和高召回率之間的良好折中，我們選擇 k = 5 （也就是5種anchor boxes）簇的相對中心 與手工選取的 anchor boxes 顯著不同，它有更少的短且寬的框，并且有更多既長又窄的框。

表1中，我們將聚類策略得到的 anchor boxes 和手工選取的 anchor boxes 在最接近的 Avg IoU 上進行比較。通過聚類策略得到的僅5種 anchor boxes 的 Avg IoU 為61.0，其性能類似于9個通過網絡學習的 anchor boxes 的60.9 (即Avg IoU已經達到了Faster RCNN的水平)。 而且使用9種 anchor boxes 會得到更高的 Avg IoU 。這表明使用 K-means生成 anchor boxes 可以更好地表示模型并使其更容易學習。

表1： VOC 2007 上聚類得結果比使用手工選取的 anchor boxes 結果要好得多。

什么是K-means?

K-means是非常經典且有效的聚類方法，通過計算樣本之間的距離（相似程度）將較近的樣本聚為同一類別（簇）。

在 yolov5/one-yolov5 項目中使用 K-means 必須滿足下面的條件：

1. train.py的parse_opt下的參數noautoanchor必須為False
2. hpy.scratch.yaml下的anchors參數注釋掉。

使用K-means時主要關注兩點

1. 如何表示樣本與樣本之間的距離（核心問題），這個一般需要根據具體場景去設計，不同的方法聚類效果也不同，最常見的就是歐式距離，在目標檢測領域常見的是IoU。
2. 分為幾類，這個也是需要根據應用場景取選擇的，也是一個超參數。

K-means算法主要流程

1. 手動設定簇的個數k，假設k=2；
2. 在所有樣本中隨機選取k個樣本作為簇的初始中心，如下圖（random clusters）中兩個黃色的小星星代表隨機初始化的兩個簇中心；
3. 計算每個樣本離每個簇中心的距離（這里以歐式距離為例），然后將樣本劃分到離它最近的簇中。如下圖（step 0）用不同的顏色區(qū)分不同的簇；
4. 更新簇的中心，計算每個簇中所有樣本的均值（方法不唯一）作為新的簇中心。如下圖（step 1）所示，兩個黃色的小星星已經移動到對應簇的中心；
5. 重復第3步到第4步直到簇中心不在變化或者簇中心變化很小滿足給定終止條件。如下圖（step2）所示，最終聚類結果。

什么是BPR?

BPR（BPR best possible recall來源于論文: FCOS.

原論文解釋：

BPR is defined as the ratio of the number of ground-truth boxes a detector can recall at the most divided by all ground-truth boxes. A ground-truth box is considered being recalled if the box is assigned to at least one sample (i.e., a location in FCOS or an anchor box in anchor-based detectors) during training.

BPR (best possible recall): 最多能被召回的 ground truth 框數量 / 所有 ground truth 框數量。最大值為1 越大越好 小于0.98就需要使用K-means + 遺傳進化算法選擇出與數據集更匹配的anchor boxes框。

什么是白化操作whiten？

白化的目的是去除輸入數據的冗余信息。假設訓練數據是圖像，由于圖像中相鄰像素之間具有很強的相關性，所以用于訓練時輸入是冗余的；白化的目的就是降低輸入的冗余性。

輸入數據集X，經過白化處理后，新的數據X’滿足兩個性質：

1. 特征之間相關性較低；
2. 所有特征具有相同的方差=1

常見的作法是：對每一個數據做一個標準差歸一化處理（除以標準差）。scipy.cluster.vq.kmeans() 函數輸入的數據就是必須是白化后的數據。相應輸出的 anchor boxes 也是白化后的anchor，所以需要將anchor boxes 都乘以標準差恢復到原始圖像尺度。

YOLOv5 中的 autoanchor.py 代碼解析

1. 導入需要的包

importnumpyasnp#numpy矩陣操作模塊
importoneflowasflow#OneFlow深度學習模塊
importyaml#操作yaml文件模塊
fromtqdmimporttqdm#Python進度條模塊

fromutils.generalimportLOGGER,colorstr#日志模塊

PREFIX=colorstr("AutoAnchor:")

2.check_anchor_order

這個函數用于確認當前anchors和stride的順序是否是一致的，因為我們的m.anchors是相對各個feature map

（每個feature map的感受野不同 檢測的目標大小也不同 適合的anchor大小也不同）所以必須要順序一致 否則效果會很不好。

這個函數一般用于check_anchors最后階段。

defcheck_anchor_order(m):
"""用在check_anchors函數的最后確定anchors和stride的順序是一致的
CheckanchororderagainststrideorderforYOLOv5Detect()modulem,andcorrectifnecessary
:paramsm:model中的最后一層Detect層
"""
#CheckanchororderagainststrideorderforYOLOv5Detect()modulem,andcorrectifnecessary
#計算anchor的面積anchorarea[9]
a=m.anchors.prod(-1).mean(-1).view(-1)#meananchorareaperoutputlayer
#計算最大anchor與最小anchor面積差
da=a[-1]-a[0]#deltaa
#計算最大stride與最小stride差
#m.stride:modelstrides
#https://github.com/Oneflow-Inc/one-yolov5/blob/bf8c66e011fcf5b8885068074ffc6b56c113a20c/models/yolo.py#L144-L152
ds=m.stride[-1]-m.stride[0]#deltas
#flow.sign(x):當x大于/小于0時，返回1/-1
#如果這里anchor與stride順序不一致，則重新調整順序，但注意這里要拋出warning
ifdaand(da.sign()!=ds.sign()):#sameorder
LOGGER.info(f"{PREFIX}Reversinganchororder")
m.anchors[:]=m.anchors.flip(0)

3. kmean_anchors

這個函數才是這個這個文件的核心函數。功能：使用 K-means + 遺傳算法 算出更符合當前數據集的anchors。

這里不僅僅使用了 K-means 聚類，還使用了 Genetic Algorithm 遺傳算法，在 K-means 聚類的結果上進行 mutation（變異）。接下來簡單介紹下代碼流程：

1. 載入數據集，得到數據集中所有數據的wh
2. 將每張圖片中wh的最大值等比例縮放到指定大小img_size，較小邊也相應縮放
3. 將bboxes從相對坐標改成絕對坐標（乘以縮放后的wh）
4. 篩選bboxes，保留wh都大于等于兩個像素的bboxes
5. 使用K-means聚類得到n個anchors（調用K-means包 涉及一個白化操作）
6. 使用遺傳算法隨機對anchors的wh進行變異，如果變異后效果變得更好（使用anchor_fitness方法計算得到的fitness（適應度）進行評估）就將變異后的結果賦值給anchors，如果變異后效果變差就跳過，默認變異1000次

不知道什么是遺傳算法，可以看看這兩個b站視頻：傳算法超細致+透徹理解和霹靂吧啦Wz

defkmean_anchors(path='./data/coco128.yaml',n=9,img_size=640,thr=4.0,gen=1000,verbose=True):
"""在check_anchors中調用
使用K-means+遺傳算法算出更符合當前數據集的anchors
Createskmeans-evolvedanchorsfromtrainingdataset
:paramspath:數據集的路徑/數據集本身
:paramsn:anchors的個數
:paramsimg_size:數據集圖片約定的大小
:paramsthr:閾值由hyp['anchor_t']參數控制
:paramsgen:遺傳算法進化迭代的次數(突變+選擇)
:paramsverbose:是否打印所有的進化(成功的)結果默認傳入是False,只打印最佳的進化結果
:returnk:K-means+遺傳算法進化后的anchors
"""
fromscipy.cluster.vqimportkmeans


#注意一下下面的thr不是傳入的thr，而是1/thr,所以在計算指標這方面還是和check_anchor一樣
thr=1./thr#0.25
prefix=colorstr('autoanchor:')

defmetric(k,wh):#computemetrics
"""用于print_results函數和anchor_fitness函數
計算ratiometric:整個數據集的groundtruth框與anchor對應寬比和高比即:gt_w/k_w,gt_h/k_h+x+best_x用于后續(xù)計算BPR+aat
注意我們這里選擇的metric是groundtruth框與anchor對應寬比和高比而不是常用的iou這點也與nms的篩選條件對應是yolov5中使用的新方法
:paramsk:anchor框
:paramswh:整個數據集的wh[N,2]
:returnx:[N,9]N個groundtruth框與所有anchor框的寬比或高比(兩者之中較小者)
:returnx.max(1)[0]:[N]N個groundtruth框與所有anchor框中的最大寬比或高比(兩者之中較小者)
"""
#[N,1,2]/[1,9,2]=[N,9,2]N個gt_wh和9個anchor的k_wh寬比和高比
#兩者的重合程度越高就越趨近于1遠離1(<1?或?>1)重合程度都越低
r=wh[:,None]/k[None]
#r=gt_height/anchor_heightgt_width/anchor_width有可能大于1，也可能小于等于1
#flow.min(r,1./r):[N,9,2]將所有的寬比和高比統(tǒng)一到<=1
#.min(2):value=[N,9]選出每個groundtruth個和anchor的寬比和高比最小的值index:[N,9]這個最小值是寬比(0)還是高比(1)
#[0]返回value[N,9]每個groundtruth個和anchor的寬比和高比最小的值就是所有groundtruth與anchor重合程度最低的
x=flow.min(r,1./r).min(2)[0]#ratiometric
#x=wh_iou(wh,flow.tensor(k))#IoUmetric
#x.max(1)[0]:[N]返回每個groundtruth和所有anchor(9個)中寬比/高比最大的值
returnx,x.max(1)[0]#x,best_x

defanchor_fitness(k):#mutationfitness
"""用于kmean_anchors函數
適應度計算優(yōu)勝劣汰用于遺傳算法中衡量突變是否有效的標注如果有效就進行選擇操作，無效就繼續(xù)下一輪的突變
:paramsk:[9,2]K-means生成的9個anchorswh:[N,2]:數據集的所有groundtruth框的寬高
:return(best*(best>thr).float()).mean()=適應度計算公式[1]注意和BPR有區(qū)別這里是自定義的一種適應度公式
返回的是輸入此時anchork對應的適應度
"""
_,best=metric(flow.tensor(k,dtype=flow.float32),wh)
return(best*(best>thr).float()).mean()#fitness

defprint_results(k):
"""用于kmean_anchors函數中打印K-means計算相關信息
計算BPR、aat=>打印信息:閾值+BPR+aatanchor個數+圖片大小+metric_all+best_mean+past_mean+Kmeans聚類出來的anchor框(四舍五入)
:paramsk:K-means得到的anchork
:returnk:input
"""
#將K-means得到的anchork按面積從小到大排序
k=k[np.argsort(k.prod(1))]
#x:[N,9]N個groundtruth框與所有anchor框的寬比或高比(兩者之中較小者)
#best:[N]N個groundtruth框與所有anchor框中的最大寬比或高比(兩者之中較小者)
x,best=metric(k,wh0)
#(best>thr).float():True=>1.False->0..mean():求均值
#BPR(bestpossiblerecall):最多能被召回(通過thr)的groundtruth框數量/所有groundtruth框數量[1]0.96223小于0.98才會用K-means計算anchor
#aat(anchorsabovethreshold):[1]3.54360每個target平均有多少個anchors
BPR,aat=(best>thr).float().mean(),(x>thr).float().mean()*n#bestpossiblerecall,anch>thr
f=anchor_fitness(k)
#print(f'{prefix}thr={thr:.2f}:{BPR:.4f}bestpossiblerecall,{aat:.2f}anchorspastthr')
#print(f'{prefix}n={n},img_size={img_size},metric_all={x.mean():.3f}/{best.mean():.3f}-mean/best,'
#f'past_thr={x[x>thr].mean():.3f}-mean:',end='')
print(f"aat:{aat:.5f},fitness:{f:.5f},bestpossiblerecall:{BPR:.5f}")
fori,xinenumerate(k):
print('%i,%i'%(round(x[0]),round(x[1])),end=','ifi1else'
')#usein*.cfg

returnk


#載入數據集
ifisinstance(path,str):#*.yamlfile
withopen(path)asf:
data_dict=yaml.safe_load(f)#modeldict
fromutils.datasetsimportLoadImagesAndLabels
dataset=LoadImagesAndLabels(data_dict['train'],augment=True,rect=True)
else:
dataset=path#dataset

#得到數據集中所有數據的wh
#將數據集圖片的最長邊縮放到img_size,較小邊相應縮放
shapes=img_size*dataset.shapes/dataset.shapes.max(1,keepdims=True)
#將原本數據集中gtboxes歸一化的wh縮放到shapes尺度
wh0=np.concatenate([l[:,3:5]*sfors,linzip(shapes,dataset.labels)])

#統(tǒng)計gtboxes中寬或者高小于3個像素的個數,目標太小發(fā)出警告
i=(wh03.0).any(1).sum()
ifi:
print(f'{prefix}WARNING:Extremelysmallobjectsfound.{i}of{len(wh0)}labelsare)

#篩選出label大于2個像素的框拿來聚類,[...]內的相當于一個篩選器,為True的留下
wh=wh0[(wh0>=2.0).any(1)]#filter>2pixels
#wh=wh*(np.random.rand(wh.shape[0],1)*0.9+0.1)#multiplybyrandomscale0-1

#Kmeans聚類方法:使用歐式距離來進行聚類
print(f'{prefix}Runningkmeansfor{n}anchorson{len(wh)}gtboxes...')
#計算寬和高的標準差->[w_std,h_std]
s=wh.std(0)#sigmasforwhitening
#開始聚類,仍然是聚成n類,返回聚類后的anchorsk(這個anchorsk是白化后數據的anchor框s)
#另外還要注意的是這里的kmeans使用歐式距離來計算的
#運行K-means的次數為30次obs:傳入的數據必須先白化處理'whitenoperation'
#白化處理:新數據的標準差=1降低數據之間的相關度，不同數據所蘊含的信息之間的重復性就會降低，網絡的訓練效率就會提高
#白化操作參考博客:https://blog.csdn.net/weixin_37872766/article/details/102957235
k,dist=kmeans(wh/s,n,iter=30)#points,meandistance
assertlen(k)==n,print(f'{prefix}ERROR:scipy.cluster.vq.kmeansrequested{n}pointsbutreturnedonly{len(k)}')
k*=s#k*s得到原來數據(白化前)的anchor框

wh=flow.tensor(wh,dtype=flow.float32)#filteredwh
wh0=flow.tensor(wh0,dtype=flow.float32)#unfilteredwh0

#輸出新算的anchorsk相關的信息
k=print_results(k)

#Plotwh
#k,d=[None]*20,[None]*20
#foriintqdm(range(1,21)):
#k[i-1],d[i-1]=kmeans(wh/s,i)#points,meandistance
#fig,ax=plt.subplots(1,2,figsize=(14,7),tight_layout=True)
#ax=ax.ravel()
#ax[0].plot(np.arange(1,21),np.array(d)**2,marker='.')
#fig,ax=plt.subplots(1,2,figsize=(14,7))#plotwh
#ax[0].hist(wh[wh[:,0]<100,?0],?400)
#ax[1].hist(wh[wh[:,1]<100,?1],?400)
#fig.savefig('wh.png',dpi=200)

#Evolve類似遺傳/進化算法變異操作
npr=np.random#隨機工具
#f:fitness0.62690
#sh:(9,2)
#mp:突變比例mutationprob=0.9s:sigma=0.1
f,sh,mp,s=anchor_fitness(k),k.shape,0.9,0.1#fitness,generations,mutationprob,sigma
pbar=tqdm(range(gen),desc=f'{prefix}EvolvinganchorswithGeneticAlgorithm:')#progressbar
#根據聚類出來的n個點采用遺傳算法生成新的anchor
for_inpbar:
#重復1000次突變+選擇選擇出1000次突變里的最佳anchork和最佳適應度f
v=np.ones(sh)#v[9,2]全是1
while(v==1).all():
#產生變異規(guī)則mutateuntilachangeoccurs(preventduplicates)
#npr.random(sh)
v=((npr.random(sh)1).clip(0.3,3.0)
#變異(改變這一時刻之前的最佳適應度對應的anchork)
kg=(k.copy()*v).clip(min=2.0)
#計算變異后的anchorkg的適應度
fg=anchor_fitness(kg)
#如果變異后的anchorkg的適應度>最佳適應度k就進行選擇操作
iffg>f:
#選擇變異后的anchorkg為最佳的anchork變異后的適應度fg為最佳適應度f
f,k=fg,kg.copy()

#打印信息
pbar.desc=f'{prefix}EvolvinganchorswithGeneticAlgorithm:fitness={f:.4f}'
ifverbose:
print_results(k)
returnprint_results(k)

4. check_anchors

這個函數是通過計算BPR確定是否需要改變anchors 需要就調用K-means重新計算anchors。

defcheck_anchors(dataset,model,thr=4.0,imgsz=640):
#Checkanchorfittodata,recomputeifnecessary
"""用于train.py中
通過BPR確定是否需要改變anchors需要就調用K-means重新計算anchors
Checkanchorfittodata,recomputeifnecessary
:paramsdataset:自定義數據集LoadImagesAndLabels返回的數據集
:paramsmodel:初始化的模型
:paramsthr:超參中得到界定anchor與label匹配程度的閾值
:paramsimgsz:圖片尺寸默認640
"""
#從model中取出最后一層(Detect)
m=model.module.model[-1]ifhasattr(model,"module")elsemodel.model[-1]#Detect()
#dataset.shapes.max(1,keepdims=True)=每張圖片的較長邊
#shapes:將數據集圖片的最長邊縮放到img_size,較小邊相應縮放得到新的所有數據集圖片的寬高[N,2]
shapes=imgsz*dataset.shapes/dataset.shapes.max(1,keepdims=True)
#產生隨機數scale[img_size,1]
scale=np.random.uniform(0.9,1.1,size=(shapes.shape[0],1))#augmentscale
#[6301,2]所有target(6301個)的wh基于原圖大小shapes*scale:隨機化尺度變化
wh=flow.tensor(np.concatenate([l[:,3:5]*sfors,linzip(shapes*scale,dataset.labels)])).float()#wh

defmetric(k):#computemetric
"""用在check_anchors函數中computemetric
根據數據集的所有圖片的wh和當前所有anchorsk計算BPR(bestpossiblerecall)和aat(anchorsabovethreshold)
:paramsk:anchors[9,2]wh:[N,2]
:returnBPR:bestpossiblerecall最多能被召回(通過thr)的groundtruth框數量/所有groundtruth框數量小于0.98才會用K-means計算anchor
:returnaat:anchorsabovethreshold每個target平均有多少個anchors
"""
#None添加維度所有target(gt)的whwh[:,None][6301,2]->[6301,1,2]
#所有anchor的whk[None][9,2]->[1,9,2]
#r:target的高h寬w與anchor的高h_a寬w_a的比值，即h/h_a,w/w_a[6301,9,2]有可能大于1，也可能小于等于1
r=wh[:,None]/k[None]
#x高寬比和寬高比的最小值無論r大于1，還是小于等于1最后統(tǒng)一結果都要小于1[6301,9]
x=flow.min(r,1/r).min(2)[0]#ratiometric
#best[6301]為每個groundtruth框選擇匹配所有anchors寬高比例值最好的那一個比值
best=x.max(1)[0]#best_x
#aat(anchorsabovethreshold)每個target平均有多少個anchors
aat=(x>1/thr).float().sum(1).mean()#anchorsabovethreshold
#BPR(bestpossiblerecall)=最多能被召回(通過thr)的groundtruth框數量/所有groundtruth框數量小于0.98才會用K-means計算anchor
BPR=(best>1/thr).float().mean()#bestpossiblerecall
returnBPR,aat

stride=m.stride.to(m.anchors.device).view(-1,1,1)#modelstrides
#anchors:[N,2]所有anchors的寬高基于縮放后的圖片大小(較長邊為640較小邊相應縮放)
anchors=m.anchors.clone()*stride#currentanchors
BPR,aat=metric(anchors.cpu().view(-1,2))
s=f"
{PREFIX}{aat:.2f}anchors/target,{BPR:.3f}BestPossibleRecall(BPR)."
#考慮這9類anchor的寬高和groundtruth框的寬高之間的差距,如果BPR<0.98(說明當前anchor不能很好的匹配數據集?ground?truth?框)就會根據K-means算法重新聚類新的anchor
ifBPR>0.98:#thresholdtorecompute
LOGGER.info(f"{s}Currentanchorsareagoodfittodataset")
else:
LOGGER.info(f"{s}Anchorsareapoorfittodataset,attemptingtoimprove...")
na=m.anchors.numel()//2#numberofanchors
try:
#如果BPR<0.98(最大為1?越大越好)?使用K-means?+?遺傳進化算法選擇出與數據集更匹配的anchors框??[9,?2]
anchors=kmean_anchors(dataset,n=na,img_size=imgsz,thr=thr,gen=1000,verbose=False)
exceptExceptionase:
LOGGER.info(f"{PREFIX}ERROR:{e}")
#計算新的anchors的new_BPR
new_BPR=metric(anchors)[0]
#比較K-means+遺傳進化算法進化后的anchors的new_BPR和原始anchors的BPR
#注意:這里并不一定進化后的BPR必大于原始anchors的BPR,因為兩者的衡量標注是不一樣的進化算法的衡量標準是適應度而這里比的是BPR
ifnew_BPR>BPR:#replaceanchors
anchors=flow.tensor(anchors,device=m.anchors.device).type_as(m.anchors)
#替換m的anchor_grid[9,2]->[3,1,3,1,1,2]
m.anchors[:]=anchors.clone().view_as(m.anchors)
#檢查anchor順序和stride順序是否一致不一致就調整
#因為我們的m.anchors是相對各個featuremap所以必須要順序一致否則效果會很不好
check_anchor_order(m)#mustbeinpixel-space(notgrid-space)
m.anchors/=stride
s=f"{PREFIX}Done(optional:updatemodel*.yamltousetheseanchorsinthefuture)"
else:
s=f"{PREFIX}Done(originalanchorsbetterthannewanchors,proceedingwithoriginalanchors)"
LOGGER.info(s)

這個函數會在train.py中調用：

總結

K-means是非常經典且有效的聚類方法，通過計算樣本之間的距離（相似程度）將較近的樣本聚為同一類別（簇）。