Anchor

最新推荐文章于 2024-05-14 11:00:23 发布
最新推荐文章于 2024-05-14 11:00:23 发布
阅读量667 收藏
点赞数
分类专栏： 计算机视觉 文章标签： python 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AliceH1226/article/details/121519908
版权

什么是锚框：
是预生成的bbox。预定义的锚框平铺在整个图像上，最终的bbox由它们生成。

为什么要用锚框：
如果没有预生成的bbox，那么是随机生成一个框，这个框的位置和大小和形状是不确定的，由这个框回归到最终的bbox会比较费劲，因为目标在图像中的位置不确定，目标的大小和形状不确定。

锚框怎么生成：
对于每一个cell,都生成若干个尺寸不同的锚框。因为目标的位置不确定，所以锚框需要铺满整张图。
因为目标的大小和形状不确定，所以锚框矮胖高瘦正方大的小的都取。如果feature map是7*7，那么有49个cell,每个cell都有锚框，那么整张图就有锚框。如果7*7的feature map 是由原图下采样至32倍得到的，feature map的锚框的大小乘以32就得到原图的锚框。首先对于一个cell，确定好这个cell的所有锚框的大小和形状和锚框的个数，那其他的cell也用这样大小形状和这么多个锚框，那么feature map的锚框就确定好了，乘以下采样的倍数就得到原图的锚框。实现的时候用numpy可以最大程度利用硬件效率，而用循环则会非常低效。



import numpy as np
import cv2

def generate_anchors(scales, aspect_ratios):
    '''
    基础anchor的生成
    input:
        scales: array([128, 256, 512])  scales表示anchor面积的开平方，面积公式 s = width * height = scales**2
        ratios: array([0.5, 1, 2])  h/w ratios
    output:
        anchor: array()
    '''
    # 基于以下公式计算单位w、单位h（单位表示面积为1）
    # w * h = S      |->  w = h * ratio
    # w / h = ratio  -->  h = w / raito
    # S = w * h = h * ratio * h = h2r      --> h = sqrt(S / r)
    # S = w * h = w * w / ratio = w2/ratio --> w = sqrt(S * r)
    h_ratios = np.sqrt(aspect_ratios)
    w_ratios = 1 / h_ratios
    # 此时的scale代表长宽的缩放大小，不是面积的缩放大小，故可直接与单位w、单位h相乘
    # 得到的是“边长”
    ws = (w_ratios[:, None] * scales[None, :]).reshape(-1)
    hs = (h_ratios[:, None] * scales[None, :]).reshape(-1)
    # 把边长/2即为中心点到左上右下点之间的曼哈顿距离的两个值
    # 然后分别掷以正负号，表示左上点（负）和右下点（正）
    base_anchors = np.stack([-ws, -hs, ws, hs], axis=1) / 2
    # 对数值做四舍五入
    return base_anchors.round()

def grid_anchors(grid_size, stride, cell_anchor):
    '''
    把基础anchor套在网格特征图上
    input:
        grid_size: tuple()
        stride: list()
        cell_anchor: array()
    output:
        anchor: list() or array()
    '''
    # 预留anchor list
    anchors = []
    # 确定特征图的长宽、原图到特征图在两个坐标轴上的下采样比例
    grid_height, grid_width = grid_size
    stride_height, stride_width = stride
    # 生成以stride为间隔，以特征图尺度为数量的list
    # 例如[0,32,64,96,128,160,192,224,256],间隔32位stride，总共9个数为特征图尺度
    shifts_x = np.arange(0, grid_width, dtype=np.float32) * stride_width
    shifts_y = np.arange(0, grid_height, dtype=np.float32) * stride_height


  
    # 将shifts_x和shifts_y制作成网格（x就是[x自己行,y列]，并展平
    shift_y, shift_x = np.meshgrid(shifts_y, shifts_x)# 括号内维度分别是22, 33，shift_y,shift_x维度都是(33, 22)

    
    # shift_x.shape:(33, 22)
    # shift_y.shape:(33, 22)
    shift_x = shift_x.reshape(-1)
    shift_y = shift_y.reshape(-1)
    # shift_x.shape:(726,)
    # shift_y.shape:(726,)

    
    
    # 堆叠在一起，N个[x_center, y_center, x_center, y_center]
    # 这就是需要套anchor的位置，做成4维的就可以直接和之前计算的anchor相加了
    shifts = np.stack((shift_x, shift_y, shift_x, shift_y), axis=1)



    # 将位置与anchor相加，reshape是为了：[100,1,4]+[1,9,4]=[100,9,4]
    # 之后再reshape到[900,4]
    # cell_anchor.shape:(n, 4), cell_anchor.reshape(1, -1, 4):(1, n, 4), cell_anchor.reshape(1, -1, 4).reshape(-1, 4).shape(n, 4)

    # shifts.shape:(726, 4)
    # shifts.reshape(-1, 1, 4).shape:(726, 1, 4)
    # cell_anchor.reshape(1, -1, 4).shape:(1, 9, 4)
    # (shifts.reshape(-1, 1, 4) + cell_anchor.reshape(1, -1, 4)).shape:(726, 9, 4)

   
    anchors.append(
        (shifts.reshape(-1, 1, 4) + cell_anchor.reshape(1, -1, 4)).reshape(-1, 4)
    )
    return anchors


if __name__ == '__main__':
    # 读入图片，缩放32倍，以此模拟下采样后的特征图
    image = cv2.imread('img.jpeg')
    feature_map = cv2.resize(image, dsize=(image.shape[1]//32, image.shape[0]//32))
    # 获取图片与特征图的shape，计算长、宽方向上的stride
    image_size = image.shape[:2]
    feature_map_size = feature_map.shape[:2]
    strides = [image_size[0] // feature_map_size[0], image_size[1] // feature_map_size[1]]

    # 给定ratios以及scales
    ratios = np.array([0.5, 1, 2])
    scales = np.array([128, 256, 512])
    # 生成基础anchor
    cell_anchors = generate_anchors(scales, ratios)

    # 将基础anchor匹配到下采样所得到的网格特征图上
    all_anchor = grid_anchors(feature_map_size, strides, cell_anchors)

    # 直接生成的anchor会有超出图像边界的地方，这将会导致绘图失败，因此可以先在原图外面进行一圈填充
    image = cv2.copyMakeBorder(image,400,400,400,400,cv2.BORDER_CONSTANT,value=[255,255,255])
    # 将anchor绘制在填充后的图片上
    for box in all_anchor[0]:
        x1, y1, x2, y2 = int(box[0])+400, int(box[1])+400, int(box[2])+400, int(box[3]+400)
        image = cv2.rectangle(image, (x1, y1), (x2, y2), (0,0,255), 2)

    cv2.imshow('image', image)
    cv2.waitKey()
    cv2.destroyAllWindows()

探索的一些array:

shifts_x:[   0.   32.   64.   96.  128.  160.  192.  224.  256.  288.  320.  352.
  384.  416.  448.  480.  512.  544.  576.  608.  640.  672.  704.  736.
  768.  800.  832.  864.  896.  928.  960.  992. 1024.]
shifts_y:[  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
 448. 480. 512. 544. 576. 608. 640. 672.]
shift_x:[[   0.    0.    0.    0.    0.    0.    0.    0.    0.    0.    0.    0.
     0.    0.    0.    0.    0.    0.    0.    0.    0.    0.]
 [  32.   32.   32.   32.   32.   32.   32.   32.   32.   32.   32.   32.
    32.   32.   32.   32.   32.   32.   32.   32.   32.   32.]
 [  64.   64.   64.   64.   64.   64.   64.   64.   64.   64.   64.   64.
    64.   64.   64.   64.   64.   64.   64.   64.   64.   64.]
 [  96.   96.   96.   96.   96.   96.   96.   96.   96.   96.   96.   96.
    96.   96.   96.   96.   96.   96.   96.   96.   96.   96.]
 [ 128.  128.  128.  128.  128.  128.  128.  128.  128.  128.  128.  128.
   128.  128.  128.  128.  128.  128.  128.  128.  128.  128.]
 [ 160.  160.  160.  160.  160.  160.  160.  160.  160.  160.  160.  160.
   160.  160.  160.  160.  160.  160.  160.  160.  160.  160.]
 [ 192.  192.  192.  192.  192.  192.  192.  192.  192.  192.  192.  192.
   192.  192.  192.  192.  192.  192.  192.  192.  192.  192.]
 [ 224.  224.  224.  224.  224.  224.  224.  224.  224.  224.  224.  224.
   224.  224.  224.  224.  224.  224.  224.  224.  224.  224.]
 [ 256.  256.  256.  256.  256.  256.  256.  256.  256.  256.  256.  256.
   256.  256.  256.  256.  256.  256.  256.  256.  256.  256.]
 [ 288.  288.  288.  288.  288.  288.  288.  288.  288.  288.  288.  288.
   288.  288.  288.  288.  288.  288.  288.  288.  288.  288.]
 [ 320.  320.  320.  320.  320.  320.  320.  320.  320.  320.  320.  320.
   320.  320.  320.  320.  320.  320.  320.  320.  320.  320.]
 [ 352.  352.  352.  352.  352.  352.  352.  352.  352.  352.  352.  352.
   352.  352.  352.  352.  352.  352.  352.  352.  352.  352.]
 [ 384.  384.  384.  384.  384.  384.  384.  384.  384.  384.  384.  384.
   384.  384.  384.  384.  384.  384.  384.  384.  384.  384.]
 [ 416.  416.  416.  416.  416.  416.  416.  416.  416.  416.  416.  416.
   416.  416.  416.  416.  416.  416.  416.  416.  416.  416.]
 [ 448.  448.  448.  448.  448.  448.  448.  448.  448.  448.  448.  448.
   448.  448.  448.  448.  448.  448.  448.  448.  448.  448.]
 [ 480.  480.  480.  480.  480.  480.  480.  480.  480.  480.  480.  480.
   480.  480.  480.  480.  480.  480.  480.  480.  480.  480.]
 [ 512.  512.  512.  512.  512.  512.  512.  512.  512.  512.  512.  512.
   512.  512.  512.  512.  512.  512.  512.  512.  512.  512.]
 [ 544.  544.  544.  544.  544.  544.  544.  544.  544.  544.  544.  544.
   544.  544.  544.  544.  544.  544.  544.  544.  544.  544.]
 [ 576.  576.  576.  576.  576.  576.  576.  576.  576.  576.  576.  576.
   576.  576.  576.  576.  576.  576.  576.  576.  576.  576.]
 [ 608.  608.  608.  608.  608.  608.  608.  608.  608.  608.  608.  608.
   608.  608.  608.  608.  608.  608.  608.  608.  608.  608.]
 [ 640.  640.  640.  640.  640.  640.  640.  640.  640.  640.  640.  640.
   640.  640.  640.  640.  640.  640.  640.  640.  640.  640.]
 [ 672.  672.  672.  672.  672.  672.  672.  672.  672.  672.  672.  672.
   672.  672.  672.  672.  672.  672.  672.  672.  672.  672.]
 [ 704.  704.  704.  704.  704.  704.  704.  704.  704.  704.  704.  704.
   704.  704.  704.  704.  704.  704.  704.  704.  704.  704.]
 [ 736.  736.  736.  736.  736.  736.  736.  736.  736.  736.  736.  736.
   736.  736.  736.  736.  736.  736.  736.  736.  736.  736.]
 [ 768.  768.  768.  768.  768.  768.  768.  768.  768.  768.  768.  768.
   768.  768.  768.  768.  768.  768.  768.  768.  768.  768.]
 [ 800.  800.  800.  800.  800.  800.  800.  800.  800.  800.  800.  800.
   800.  800.  800.  800.  800.  800.  800.  800.  800.  800.]
 [ 832.  832.  832.  832.  832.  832.  832.  832.  832.  832.  832.  832.
   832.  832.  832.  832.  832.  832.  832.  832.  832.  832.]
 [ 864.  864.  864.  864.  864.  864.  864.  864.  864.  864.  864.  864.
   864.  864.  864.  864.  864.  864.  864.  864.  864.  864.]
 [ 896.  896.  896.  896.  896.  896.  896.  896.  896.  896.  896.  896.
   896.  896.  896.  896.  896.  896.  896.  896.  896.  896.]
 [ 928.  928.  928.  928.  928.  928.  928.  928.  928.  928.  928.  928.
   928.  928.  928.  928.  928.  928.  928.  928.  928.  928.]
 [ 960.  960.  960.  960.  960.  960.  960.  960.  960.  960.  960.  960.
   960.  960.  960.  960.  960.  960.  960.  960.  960.  960.]
 [ 992.  992.  992.  992.  992.  992.  992.  992.  992.  992.  992.  992.
   992.  992.  992.  992.  992.  992.  992.  992.  992.  992.]
 [1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024.
  1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024. 1024.]]
shift_y:[[  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
 [  0.  32.  64.  96. 128. 160. 192. 224. 256. 288. 320. 352. 384. 416.
  448. 480. 512. 544. 576. 608. 640. 672.]
(shifts.reshape(-1, 1, 4) + cell_anchor.reshape(1, -1, 4)).shape:(726, 9, 4)

shifts.shape:(726, 4)
shifts:[[   0.    0.    0.    0.]
 [   0.   32.    0.   32.]
 [   0.   64.    0.   64.]
 ...
 [1024.  608. 1024.  608.]
 [1024.  640. 1024.  640.]
 [1024.  672. 1024.  672.]]
shifts.reshape(-1, 1, 4):[[[   0.    0.    0.    0.]]

 [[   0.   32.    0.   32.]]

 [[   0.   64.    0.   64.]]

 ...

 [[1024.  608. 1024.  608.]]

 [[1024.  640. 1024.  640.]]

 [[1024.  672. 1024.  672.]]]
cell_anchor.reshape(1, -1, 4):[[[ -91.  -45.   91.   45.]
  [-181.  -91.  181.   91.]
  [-362. -181.  362.  181.]
  [ -64.  -64.   64.   64.]
  [-128. -128.  128.  128.]
  [-256. -256.  256.  256.]
  [ -45.  -91.   45.   91.]
  [ -91. -181.   91.  181.]
  [-181. -362.  181.  362.]]]
(shifts.reshape(-1, 1, 4) + cell_anchor.reshape(1, -1, 4)):[[[ -91.  -45.   91.   45.]
  [-181.  -91.  181.   91.]
  [-362. -181.  362.  181.]
  ...
  [ -45.  -91.   45.   91.]
  [ -91. -181.   91.  181.]
  [-181. -362.  181.  362.]]

 [[ -91.  -13.   91.   77.]
  [-181.  -59.  181.  123.]
  [-362. -149.  362.  213.]
  ...
  [ -45.  -59.   45.  123.]
  [ -91. -149.   91.  213.]
  [-181. -330.  181.  394.]]

 [[ -91.   19.   91.  109.]
  [-181.  -27.  181.  155.]
  [-362. -117.  362.  245.]
  ...
  [ -45.  -27.   45.  155.]
  [ -91. -117.   91.  245.]
  [-181. -298.  181.  426.]]


 [[ 933.  563. 1115.  653.]
  [ 843.  517. 1205.  699.]
  [ 662.  427. 1386.  789.]
  ...
  [ 979.  517. 1069.  699.]
  [ 933.  427. 1115.  789.]

 [[ 933.  595. 1115.  685.]
  [ 843.  549. 1205.  731.]
  [ 662.  459. 1386.  821.]
  ...
  [ 979.  549. 1069.  731.]
  [ 933.  459. 1115.  821.]
  [ 843.  278. 1205. 1002.]]
 [[ 933.  627. 1115.  717.]
  [ 843.  581. 1205.  763.]
  [ 662.  491. 1386.  853.]
  ...
  [ 979.  581. 1069.  763.]
  [ 933.  491. 1115.  853.]
  [ 843.  310. 1205. 1034.]]]
换个名字就很好
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOv3中anchor机制的理解
苏打水的杯子的博客
11-14 1万+
1、为什么要引入anchor机制？ 如下图人和车的中心点都位于同一网格grid_8中，如果没有anchor机制的话，grid_8就存在属于哪一类的问题，如果属于车类，那只能用来预测车，人类就会被忽略，如果属于人类，那么车类将会被忽略。为了解决同一网络属于两个类的问题，引入了anchor机制，一个grid可以有三个anchor（对于yolo3）,图中的紫色框为anchor,那么横着的anchor框...
YOLO源码详解（五）- YOLO中的7*7个grid和RPN中的9个anchors
木凌的博客
12-08 1万+
本系列作者：木凌 时间：2016年12月。 文章连接：http://blog.csdn.net/u014540717 QQ交流群：554590241 一直不知道7×7的网格到底是干什么的，不就是结果预测7×7×2个框吗，这跟把原图分成7×7有什么关系？不分成7×7就不能预测7×7×2个框吗？之前跟一个朋友讨论，他说7×7的网格是作为回归框的初始位置，我后来的很长一段时间一直这么认为
anchor
03-12
锚 Anchor是由Skip Transport，Inc.开发的各种嵌入式固件库的集合。所有这些库的开发都是为了易于重用，并且不依赖于特定的MCU或RTOS。 图书馆 该存储库组织为在很大程度上彼此独立的库的集合。 您可以自由选择应用程序中最有用的库，而无需全部包含它们。 每个库都组织在一个子目录中，其中一个自述文件提供了特定于该库的信息。 通常，包括一个库，就像将要编译的C源代码一样，将<lib>/src所有.c文件添加到构建系统中，然后将<lib>/include到构建系统的include路径中就这么简单。 记录中 日志记录库使您可以轻松写出一致且有用的调试日志。 这通常是通过UART连接完成的，但是该库与所使用的协议无关。 0:00:00.626 WARN system.c:199: Last reset due to software reset 0:00:00.632
tkinter中布局管理器的那些事儿pack,grid等
lovepipi19的博客
10-19 944
关于tkinter里面anchor和side和sticky的区别 事实上，side和sticky都是表示的对齐方式，但是要对齐，肯定有一个相对的位置，而这个位置就是anchor设定的值，这里我用一个图来表示出来! 清楚的看见只有pack有side属性和anchor属性，一个是相对的点位，一个是对齐方式。 而grid的是sticky属性，因为grid是表格的形式，只需要sticky = tkint...
初窥Tensorflow Object Detection API 源码之（2.2）grid_anchor
DaneSpiritGOD的专栏
02-23 749
GridAnchorGenerator _generate 这篇介绍不打算细讲，只描述基本结构的理解 models/research/object_detection/builders/anchor_generator_builder.py GridAnchorGenerator return grid_anchor_generator.GridAnchor...
（三）目标检测中的几种框【anchor，bbox，先验框，网格单元，ROI，proposal，DenseBox】
weixin_44463519的博客
06-19 4019
本章介绍了在目标检测问题中一些比较常见的“框”，对其概念和原理进行了基础的区分。
【目标检测】YOLO系列Anchor标签分配、边框回归（坐标预测）方式、LOSS计算方式
zhicai_liu的博客
02-05 1万+
1、YOLOv1 标签分配：GT的中心落在哪个grid，那个grid对应的两个bbox中与GT的IOU最大的bbox为正样本，其余为负样本，（由于是回归模型，不是分类模型，其解决类别不平衡的方式为各项loss采取不同的权重），即虽然一个grid分配两个bbox，但是只有一个bbox负责预测一个目标（边框和类别），这样导致YOLOv1最终只能预测7*7=49个目标。 边框回归方式：直接预测(x, y, w, h)，不是像rcnn系列那样的偏移量的概念，虽然其中心点的预测是相对gird左上角的位置，但是其没
目标检测 --- Anchor的生成
qq_44804542的博客
04-14 1725
1.Faster rcnn 1.根据尺寸、比例生成基础的anchor 与特征图大小、步长无关，中心点坐标为base_size的一半 class AnchorGenerator(object): #生成基础的anchor,与特征图无关 def __init__(self, base_size, scales, ratios, scale_major=True, ctr=None): self.base_size = base_size #anchor 基础尺寸 sel
深度学习入门--锚框Anchor的生成处理及可视化（详细说明及代码实现）
qq_15534667的博客
11-23 1684
还不知道如何实现目标检测任务中的锚框如何生成以及可视化吗？快来观看目前最详细的代码解刨！
anchor free 目标检测_《目标检测》系列之二：目标检测中的Anchor机制回顾
weixin_36012152的博客
01-05 924
前段时间，YOLOv4&v5大火，很多人忽视了yolov5在anchor上的一些细节变化，因此，本文从Faster RCNN着手，逐步分析SSD、YOLOv4&v5的anchor机制。1 Faster RCNNFaster RCNN可以看作是RPN(Regio Proposal Network) 和 Fast RCNN 的组合，由下图可以看到，输入图像经过RPN后输出proposa...
winform 使用Anchor属性进行界面布局的方法详解
09-04
主要介绍了winform 使用Anchor属性进行界面布局的方法，有需要的朋友可以参考一下
Anchor机制解读.pdf
06-05
针对目标检测中基于anchor机制进行解读的PDF文件，包括其优缺点总结。
浅谈vue 锚点指令v-anchor的使用
12-13
如下所示： export default { inserted: function(el, binding) { el.onclick = function() {... total = document.getElementById(`anchor-${binding.value}`).offsetTop; } let distance = document.documentEle
yolo v5 代码阅读记录
allrubots的博客
10-16 3025
实验记录
yolov5中anchors的保存/读取
My的博客
07-19 2154
训练样本不同时，yolov5可能会重新计算anchors，这些anchors将保存在模型权重文件中，直接使用detect.py输出时会自动加载计算，但在某些任务（如进行板端后处理过程中），还是需要获取到这些anchors值。......
yolov5源码解析(9)--输出
10-24 1万+
本文章基于yolov5-6.2版本。主要讲解的是yolov5是怎么在最终的特征图上得出物体边框、置信度、物体分类的。
YOLOv5的输出端（Head）详解|CSDN创作打卡
热门推荐
tt丫的博客
01-24 4万+
深度学习入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。 一、Bounding box损失函数 1、IOU_Loss ????IOU是交并比，在这里是指预测的物体框框和真实的物体框框的交集的面积与并集的面积之比。 ????IOU_Loss是根据IOU的损失函数：IOU_Loss = 1 -IOU 但是它存在一些缺点： （1）如果你的预测框和真实框完全不重合，那么你的IOU为0，没有办法呈现出你的预测框距离真实框有多远，损失函数不可导，导致无
目标检测学习笔记
q839039228的博客
08-10 788
吴恩达老师的目标检测课程的学习笔记
【Python】Python中变量或者函数加下划线‘_‘的含义
最新发布
yangweipeng708的博客
05-14 672
理解这些约定可以帮助Python开发者编写更清晰、更Pythonic的代码，并理解其他Python代码中的命名习惯。）通常用来指示特定的编程约定或用法，这些约定主要关乎变量和函数的可访问性以及预期的使用范围。在Python中，变量或函数前面加一个下划线（
Anchor free
08-29
Anchor-free目标检测是一种目标检测算法，它与传统的基于Anchor的目标检测方法相比，不需要使用预定义的Anchor框来检测目标。Anchor-free目标检测的主要思想是通过关键点检测或物体中心点来定位目标。 在Anchor-free目标检测中，有几种常见的方法。一种是通过关键点检测方法来进行目标定位，即通过检测物体的关键点来确定目标的位置和边界框。另一种方法是通过预测物体的中心点来定位目标。这些方法都避免了使用预先定义的Anchor框，从而提高了目标检测的准确性和效率。 Anchor-free目标检测在很多方面都有其优势。例如，它能够在精度上媲美基于Anchor的方法，这是因为它使用了一些技术，如FPN和FocalLoss，来提高检测的准确性。此外，Anchor-free方法还可以减少算法的复杂性，提高检测的速度。 选择使用Anchor-free还是Anchor-based方法取决于具体的应用场景和需求。在训练过程中，如果选择的正负样本保持一致，无论是基于Anchor进行回归还是基于关键点进行回归，得到的检测结果是相近的。因此，根据实际情况选择适合的方法进行目标检测。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [深度学习系列之Anchor based 和 Anchor free 目标检测方法](https://blog.csdn.net/weixin_38716233/article/details/124623978)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值