在本文中，您将会了解到关于计算机视觉领域常见的度量指标的新资讯，同时我们还将为您解释计算机视觉领域常见的度量指标有哪些的相关在本文中，我们将带你探索计算机视觉领域常见的度量指标的奥秘，分析计算机视觉领

在本文中，您将会了解到关于计算机视觉领域常见的度量指标的新资讯，同时我们还将为您解释计算机视觉领域常见的度量指标有哪些的相关在本文中，我们将带你探索计算机视觉领域常见的度量指标的奥秘，分析计算机视觉领域常见的度量指标有哪些的特点，并给出一些关于3天带你复现计算机视觉领域经典论文、8个计算机视觉深度学习中常见的Bug、CVPR 2022 | 数据堂亮相计算机视觉领域盛会、CV新手避坑指南：计算机视觉常见的8个错误的实用技巧。

本文目录一览：

• 计算机视觉领域常见的度量指标（计算机视觉领域常见的度量指标有哪些）
• 3天带你复现计算机视觉领域经典论文
• 8个计算机视觉深度学习中常见的Bug
• CVPR 2022 | 数据堂亮相计算机视觉领域盛会
• CV新手避坑指南：计算机视觉常见的8个错误

计算机视觉领域常见的度量指标（计算机视觉领域常见的度量指标有哪些）

一：Precision, Recall, F-score

信息检索、分类、识别、翻译等领域两个最基本指标是召回率(Recall Rate)和准确率(Precision Rate------注意统计学习方法中precesion称为精确率，而准确率为accuracy 是分类正确的样本除以总样本的个数。)，召回率也叫查全率，准确率也叫查准率，概念公式:

            召回率(Recall)=  系统检索到的相关文件 / 系统所有相关的文件总数；；；亦即预测为真实正例除以所有真实正例样本的个数
            准确率(Precision)=  系统检索到的相关文件 / 系统所有检索到的文件总数；；；亦即等于预测为真实正例除以所有被预测为正例样本的个数

图示表示如下：
注意：(1)准确率和召回率是互相影响的，理想情况下肯定是做到两者都高，但是一般情况下准确率高、召回率就低，召回率低、准确率高，当然如果两者都低，那是什么地方出问题了。

        （2）如果是做搜索，那就是保证召回的情况下提升准确率；如果做疾病监测、反垃圾，则是保准确率的条件下，提升召回。

所以，在两者都要求高的情况下，可以用F1(或者称为F-score)来衡量。计算公式如下：

                     F1= 2 * P * R / (P + R)  
二：MAP

MAP:全称mean average precision(平均准确率)。mAP是为解决P，R，F-measure的单点值局限性的，同时考虑了检索效果的排名情况。

计算如下：

假设有两个主题，主题1有4个相关网页，主题2有5个相关网页。某系统对于主题1检索出4个相关网页，其rank分别为1, 2, 4, 7；对于主题2检索出3个相关网页，其rank分别为1,3,5。对于主题1，平均准确率为(1/1+2/2+3/4+4/7)/4=0.83。对于主题 2，平均准确率为(1/1+2/3+3/5+0+0)/5=0.45。则MAP=(0.83+0.45)/2=0.64。”

 

• 目标检测中的mAP是什么含义？（对于目标检测mAP,很容易得带confidence得分，去评估PR曲线）应该在固定IoU=0.5的情况下，设置不同的confidence可以绘制出PR曲线吧！

• 目标检测模型评估指标——mAP计算的讨论

• https://github.com/rafaelpadilla/Object-Detection-Metrics

• mean average precision（MAP）在计算机视觉中是如何计算和应用的？

• 几个易混淆的概念（准确率-召回率，击中率-虚警率，PR曲线和mAP，ROC曲线和AUC）

图像语义分割技术度量标准

• https://blog.csdn.net/u014593748/article/details/71698246
• mIoU是在混淆矩阵下，计算所有像素的分类预测情况，计算TP/TP+FN+FP这也是一种交并比！！！

• MIoU计算的是计算A与B的交集（橙色部分）与A与B的并集（红色+橙色+黄色）之间的比例，在理想状态下A与B重合，两者比例为1 。

 

3天带你复现计算机视觉领域经典论文

学计算机视觉怎么能错过GAN网络？

 

它是图像/视频生成与编辑领域当之无愧的王者！

是深度学习强大能力最直观的展示！

同时也是视觉领域理论研究的热点，是 出论文的好方向！

随着GAN系列网络的不断进步，图像/视频的生成和编辑已完全能以假乱真：最新GAN网络所生成的人脸，可能比你手机拍摄的人脸更清晰更真实；GAN网络所带来的换脸、老片修复等应用，则具有很高的商业价值。

学GAN网络， 如果想要在算法上有所创新，那就一定要理解并掌握GAN领域的经典Paper。

可能你会说，读论文好难！代码复现好难！创新优化更难！！而且现在论文质量参差不齐，该如何甄选？对于一些优秀论文，又该如何寻找论文源代码？如何剖析算法优缺点？如何复现？如何结合实际应用实施呢？

为了让大家在学习GAN网络的过程中少走弯路、少踩坑，深度之眼重磅推出GAN网络论文体验课：

学员走心评价

品牌口碑

如有任何疑问请扫码咨询客服

年轻最有效的资本是时间，让我们带你更有效的学习，帮你节约盲目摸索的时间。让你赚取更多的价值！

订阅须知

Q：课程资料在哪里看？

A：所有的课程资料均会在训练营内上传，报名以后请务必添加客服微信入群！

Q：视频可以电脑看吗？

A：课程视频支持PC端倍速播放。

Q：报名后可以退款吗？

A：本服务为虚拟内容产品，一经购买，概不退款，敬请谅解。

Q：可以开具发票吗？

A：可以开具普通电子发票，请联系微信班主任填写需要的信息即可。

本文分享自微信公众号 - 小白学视觉（NoobCV）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

8个计算机视觉深度学习中常见的Bug

作者 | Arseny Kravchenko
编译 | ronghuaiyang

人是不完美的，我们经常在软件中犯错误。有时这些错误很容易发现：你的代码根本不能工作，你的应用程序崩溃等等。但是有些bug是隐藏的，这使得它们更加危险。

在解决深度学习问题时，由于一些不确定性，很容易出现这种类型的bug：很容易看到web应用程序路由请求是否正确，而不容易检查你的梯度下降步骤是否正确。然而，有很多错误是可以避免的。

我想分享一些我的经验，关于我在过去两年的计算机视觉工作中看到或制造的错误。我之前有谈到过这个话题，很多人告诉我：“是的，我也有很多这样的bug。”我希望我的文章可以帮助你至少避免其中的一些问题。

1. 翻转图片以及关键点

假设在关键点检测的问题上。数据看起来像一对图像和一系列的关键点元组。其中每个关键点是一对x和y坐标。

让我们对这个数据进行基础的增强：

1. def flip_img_and_keypoints(img: np.ndarray, kpts:`Sequence[Sequence[int]]):`
2. img = np.fliplr(img)
3. h, w,`*_ = img.shape`
4. kpts =`[(y, w - x)`for y, x in kpts]
5. return img, kpts

看起来是正确的，嗯？我们把它可视化。

1. image = np.ones((10,`10), dtype=np.float32)`
2. kpts =`[(0,1),(2,`2)]
3. image_flipped, kpts_flipped = flip_img_and_keypoints(image, kpts)
4. img1 = image.copy()
5. for y, x in kpts:
6. img1[y, x]`=`0
7. img2 = image_flipped.copy()
8. for y, x in kpts_flipped:
9. img2[y, x]`=`0
10. _ = plt.imshow(np.hstack((img1, img2)))

不对称，看起来很奇怪！如果我们检查极值呢？

1. image = np.ones((10,`10), dtype=np.float32)`
2. kpts =`[(0,0),(1,`1)]
3. image_flipped, kpts_flipped = flip_img_and_keypoints(image, kpts)
4. img1 = image.copy()
5. for y, x in kpts:
6. img1[y, x]`=`0
7. img2 = image_flipped.copy()
8. for y, x in kpts_flipped:
9. img2[y, x]`=`0
10. ---------------------------------------------------------------------------
11. IndexError`Traceback`(most recent call last)
12. <ipython-input-5-997162463eae>`in`<module>
13. 8 img2 = image_flipped.copy()
14. 9`for y, x in kpts_flipped:`
15. --->`10 img2[y, x]=0`
16. IndexError: index 10`is out of bounds for axis 1`with size 10

不好！这是一个典型的off-by-one错误。正确的代码是这样的:

1. def flip_img_and_keypoints(img: np.ndarray, kpts:`Sequence[Sequence[int]]):`
2. img = np.fliplr(img)
3. h, w,`*_ = img.shape`
4. kpts =`[(y, w - x -1)for y, x in kpts]`
5. return img, kpts

我们通过可视化发现了这个问题，但是，使用“x = 0”点进行单元测试也会有所帮助。一个有趣的事实是：有一个团队中有三个人(包括我自己)独立地犯了几乎相同的错误。

2. 继续是关键点相关的问题

即使在上面的函数被修复之后，仍然存在危险。现在更多的是语义，而不仅仅是一段代码。

假设需要用两只手掌来增强图像。看起来很安全：手是左，右翻转。

但是等等！我们对关键点的语义并不很了解。如果这个关键点的意思是这样的：

1. kpts =`[`
2. (20,`20),`# left pinky
3. (20,`200),`# right pinky
4. ...
5. ]

这意味着增强实际上改变了语义：左变成右，右变成左，但我们不交换数组中的关键点索引。它会给训练带来大量的噪音和更糟糕的度量。

我们应该吸取一个教训：

• 在应用增强或其他花哨的功能之前，了解并考虑数据结构和语义
• 保持你的实验原子性：添加一个小的变化(例如一个新的变换)，检查它如何进行，如果分数提高才加进去。

3. 编写自己的损失函数

熟悉语义分割问题的人可能知道IoU指标。不幸的是，我们不能直接用SGD来优化它，所以常用的方法是用可微损失函数来近似它。

1. def iou_continuous_loss(y_pred, y_true):
2. eps =`1e-6`
3. def _sum(x):
4. return x.sum(-1).sum(-1)
5. numerator =`(_sum(y_true * y_pred)`+ eps)
6. denominator =`(_sum(y_true 2)+ _sum(y_pred `2)
7. - _sum(y_true * y_pred)`+ eps)`
8. return`(numerator / denominator).mean()`

看起来不错，我们先做个小的检查：

1. In`[3]: ones = np.ones((1,3,10,`10))
2. ...: x1 = iou_continuous_loss(ones *`0.01, ones)`
3. ...: x2 = iou_continuous_loss(ones *`0.99, ones)`
4. In`[4]: x1, x2`
5. Out[4]:`(0.010099999897990103,`0.9998990001020204)

在 x1中，我们计算了一些与ground truth完全不同的东西的损失，而 x2则是非常接近ground truth的东西的结果。我们预计 x1会很大，因为预测是错误的， x2应该接近于零。怎么了?

上面的函数是对metric的一个很好的近似。metric不是一种损失：它通常(包括这种情况)越高越好。当我们使用SGD来最小化损失时，我们应该使用一些相反的东西：

1. def iou_continuous(y_pred, y_true):
2. eps =`1e-6`
3. def _sum(x):
4. return x.sum(-1).sum(-1)
5. numerator =`(_sum(y_true * y_pred)`+ eps)
6. denominator =`(_sum(y_true 2)+ _sum(y_pred `2)
7. - _sum(y_true * y_pred)`+ eps)`
8. return`(numerator / denominator).mean()`
9. def iou_continuous_loss(y_pred, y_true):
10. return`1`- iou_continuous(y_pred, y_true)

这些问题可以从两个方面来确定：

• 编写一个单元测试，检查损失的方向：形式化的期望，更接近ground truth应该输出更低的损失。
• 运行一个健全的检查，让你的模型在单个batch中过拟合。

4. 当我们使用Pytorch的时候

假设有一个预先训练好的模型，开始做infer。

1. from ceevee.base import`AbstractPredictor`
2. class`MySuperPredictor(AbstractPredictor):`
3. def __init__(self,
4. weights_path: str,
5. ):
6. super().__init__()
7. self.model = self._load_model(weights_path=weights_path)
8. def process(self, x,`*kw):`
9. with torch.no_grad():
10. res = self.model(x)
11. return res
12. @staticmethod
13. def _load_model(weights_path):
14. model =`ModelClass()`
15. weights = torch.load(weights_path, map_location=''cpu'')
16. model.load_state_dict(weights)
17. return model

这个代码正确吗？也许！这确实适用于某些模型。例如，当模型没有dropout或norm层，如 torch.nn.BatchNorm2d。或者当模型需要为每个图像使用实际的norm统计量时(例如，许多基于pix2pix的架构需要它)。

但是对于大多数计算机视觉应用程序来说，代码忽略了一些重要的东西:切换到评估模式。

如果试图将动态PyTorch图转换为静态PyTorch图，这个问题很容易识别。 torch.jit用于这种转换。

1. In`[3]: model = nn.Sequential(`
2. ...: nn.Linear(10,`10),`
3. ...: nn.Dropout(.5)
4. ...:`)`
5. ...:
6. ...: traced_model = torch.jit.trace(model, torch.rand(10))
7. /Users/Arseny/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/jit/__init__.py:914:`TracerWarning:Trace had nondeterministic nodes.Did you forget call .eval() on your model?`Nodes:
8. %12`:Float(10)= aten::dropout(%input,%10,%11), scope:Sequential/Dropout[1]# /Users/Arseny/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/nn/functional.py:806:0`
9. This may cause errors in trace checking.`To disable trace checking,`pass check_trace=False to torch.jit.trace()
10. check_tolerance, _force_outplace,`True, _module_class)`
11. /Users/Arseny/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/jit/__init__.py:914:`TracerWarning:Output nr 1\. of the traced function does not match the corresponding output of the Python function.Detailed error:`
12. Not within tolerance rtol=1e-05 atol=1e-05 at input[5]`(0.0 vs.0.5454154014587402)and`5 other locations (60.00%)
13. check_tolerance, _force_outplace,`True, _module_class)`

简单的修复一下：

1. In`[4]: model = nn.Sequential(`
2. ...: nn.Linear(10,`10),`
3. ...: nn.Dropout(.5)
4. ...:`)`
5. ...:
6. ...: traced_model = torch.jit.trace(model.eval(), torch.rand(10))
7. # No more warnings!

在这种情况下， torch.jit.trace将模型运行几次并比较结果。这里的差别是可疑的。

然而 torch.jit.trace在这里不是万能药。这是一种应该知道和记住的细微差别。

5. 复制粘贴的问题

很多东西都是成对存在的：训练和验证、宽度和高度、纬度和经度……

1. def make_dataloaders(train_cfg, val_cfg, batch_size):
2. train =`Dataset.from_config(train_cfg)`
3. val =`Dataset.from_config(val_cfg)`
4. shared_params =`{''batch_size'': batch_size,''shuffle'':True,`''num_workers'': cpu_count()}
5. train =`DataLoader(train,`**shared_params)
6. val =`DataLoader(train,`**shared_params)
7. return train, val

不仅仅是我犯了愚蠢的错误。例如，在非常流行的albumentations库也有一个类似的版本。

1. # https://github.com/albu/albumentations/blob/0.3.0/albumentations/augmentations/transforms.py
2. def apply_to_keypoint(self, keypoint, crop_height=0, crop_width=0, h_start=0, w_start=0, rows=0, cols=0,`**params):`
3. keypoint = F.keypoint_random_crop(keypoint, crop_height, crop_width, h_start, w_start, rows, cols)
4. scale_x = self.width / crop_height
5. scale_y = self.height / crop_height
6. keypoint = F.keypoint_scale(keypoint, scale_x, scale_y)
7. return keypoint

别担心，已经修改好了。

如何避免？不要复制和粘贴代码，尽量以不需要复制和粘贴的方式编写代码。

【NO】

1. datasets =`[]`
2. data_a = get_dataset(MyDataset(config[''dataset_a'']), config[''shared_param''], param_a)
3. datasets.append(data_a)
4. data_b = get_dataset(MyDataset(config[''dataset_b'']), config[''shared_param''], param_b)
5. datasets.append(data_b)

【YES】

1. datasets =`[]`
2. for name, param in zip((''dataset_a'',`''dataset_b''),`
3. (param_a, param_b),
4. ):
5. datasets.append(get_dataset(MyDataset(config[name]), config[''shared_param''], param))

6. 合适的数据类型

让我们编写一个新的增强

1. def add_noise(img: np.ndarray)`-> np.ndarray:`
2. mask = np.random.rand(*img.shape)`+`.5
3. img = img.astype(''float32'')`* mask`
4. return img.astype(''uint8'')

图像已被更改。这是我们所期望的吗?嗯，也许它改变得太多了。

这里有一个危险的操作：将 float32 转换为 uint8。它可能会导致溢出：

1. def add_noise(img: np.ndarray)`-> np.ndarray:`
2. mask = np.random.rand(*img.shape)`+`.5
3. img = img.astype(''float32'')`* mask`
4. return np.clip(img,`0,`255).astype(''uint8'')
5. img = add_noise(cv2.imread(''two_hands.jpg'')[:,`:,`::-1])
6. _ = plt.imshow(img)

看起来好多了，是吧？

顺便说一句，还有一种方法可以避免这个问题：不要重新发明轮子，不要从头开始编写增强代码并使用现有的扩展： albumentations.augmentations.transforms.GaussNoise。

我曾经做过另一个同样起源的bug。

1. raw_mask = cv2.imread(''mask_small.png'')
2. mask = raw_mask.astype(''float32'')`/`255
3. mask = cv2.resize(mask,`(64,`64), interpolation=cv2.INTER_LINEAR)
4. mask = cv2.resize(mask,`(128,`128), interpolation=cv2.INTER_CUBIC)
5. mask =`(mask *`255).astype(''uint8'')
6. _ = plt.imshow(np.hstack((raw_mask, mask)))

这里出了什么问题？首先，用三次插值调整掩模的大小是一个坏主意。同样的问题 float32到 uint8：三次插值可以输出值大于输入，这会导致溢出。

我在做可视化的时候发现了这个问题。在你的训练循环中到处放置断言也是一个好主意。

7. 拼写错误

假设需要对全卷积网络(如语义分割问题)和一个巨大的图像进行推理。该图像是如此巨大，没有机会把它放在你的GPU中，它可以是一个医疗或卫星图像。

在这种情况下，可以将图像分割成网格，独立地对每一块进行推理，最后合并。此外，一些预测交叉可能有助于平滑边界附近的artifacts。

1. from tqdm import tqdm
2. class`GridPredictor:`
3. """
4. This class can be used to predict a segmentation mask for the big image
5. when you have GPU memory limitation
6. """
7. def __init__(self, predictor:`AbstractPredictor, size: int, stride:Optional[int]=`None):
8. self.predictor = predictor
9. self.size = size
10. self.stride = stride if stride is`notNoneelse size //`2
11. def __call__(self, x: np.ndarray):
12. h, w, _ = x.shape
13. mask = np.zeros((h, w,`1), dtype=''float32'')`
14. weights = mask.copy()
15. for i in tqdm(range(0, h -`1, self.stride)):`
16. for j in range(0, w -`1, self.stride):`
17. a, b, c, d = i, min(h, i + self.size), j, min(w, j + self.size)
18. patch = x[a:b, c:d,`:]`
19. mask[a:b, c:d,`:]+= np.expand_dims(self.predictor(patch),-1)`
20. weights[a:b, c:d,`:]=1`
21. return mask / weights

有一个符号输入错误，代码段足够大，可以很容易地找到它。我怀疑仅仅通过代码就能快速识别它。但是很容易检查代码是否正确：

1. class`Model(nn.Module):`
2. def forward(self, x):
3. return x.mean(axis=-1)
4. model =`Model()`
5. grid_predictor =`GridPredictor(model, size=128, stride=64)`
6. simple_pred = np.expand_dims(model(img),`-1)`
7. grid_pred = grid_predictor(img)
8. np.testing.assert_allclose(simple_pred, grid_pred, atol=.001)
9. ---------------------------------------------------------------------------
10. AssertionError`Traceback`(most recent call last)
11. <ipython-input-24-a72034c717e9>`in`<module>
12. 9 grid_pred = grid_predictor(img)
13. 10
14. --->`11 np.testing.assert_allclose(simple_pred, grid_pred, atol=.001)`
15. ~/.pyenv/versions/3.6.6/lib/python3.6/site-packages/numpy/testing/_private/utils.py in assert_allclose(actual, desired, rtol, atol, equal_nan, err_msg, verbose)
16. 1513 header =`''Not equal to tolerance rtol=%g, atol=%g''%(rtol, atol)`
17. 1514 assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
18. ->`1515 verbose=verbose, header=header, equal_nan=equal_nan)`
19. 1516
20. 1517
21. ~/.pyenv/versions/3.6.6/lib/python3.6/site-packages/numpy/testing/_private/utils.py in assert_array_compare(comparison, x, y, err_msg, verbose, header, precision, equal_nan, equal_inf)
22. 839 verbose=verbose, header=header,
23. 840 names=(''x'',`''y''), precision=precision)`
24. -->`841raiseAssertionError(msg)`
25. 842`except`ValueError:
26. 843`import traceback`
27. AssertionError:
28. Not equal to tolerance rtol=1e-07, atol=0.001
29. Mismatch:`99.6%`
30. Max absolute difference:`765.`
31. Max relative difference:`0.75000001`
32. x: array([[[215.333333],
33. [192.666667],
34. [250.`],...`
35. y: array([[[`215.33333],`
36. [`192.66667],`
37. [`250.`],...

下面是 __call__方法的正确版本:

1. def __call__(self, x: np.ndarray):
2. h, w, _ = x.shape
3. mask = np.zeros((h, w,`1), dtype=''float32'')`
4. weights = mask.copy()
5. for i in tqdm(range(0, h -`1, self.stride)):`
6. for j in range(0, w -`1, self.stride):`
7. a, b, c, d = i, min(h, i + self.size), j, min(w, j + self.size)
8. patch = x[a:b, c:d,`:]`
9. mask[a:b, c:d,`:]+= np.expand_dims(self.predictor(patch),-1)`
10. weights[a:b, c:d,`:]+=1`
11. return mask / weights

如果你仍然不知道问题出在哪里，请注意 weights[a:b,c:d,:]+=1这一行。

8. Imagenet归一化

当一个人需要进行转移学习时，用训练Imagenet时的方法将图像归一化通常是一个好主意。

让我们使用我们已经熟悉的albumentations库。

1. from albumentations import`Normalize`
2. norm =`Normalize()`
3. img = cv2.imread(''img_small.jpg'')
4. mask = cv2.imread(''mask_small.png'', cv2.IMREAD_GRAYSCALE)
5. mask = np.expand_dims(mask,`-1)`# shape (64, 64) -> shape (64, 64, 1)
6. normed = norm(image=img, mask=mask)
7. img, mask =`[normed[x]for x in[''image'',`''mask'']]
8. def img_to_batch(x):
9. x = np.transpose(x,`(2,0,1)).astype(''float32'')`
10. return torch.from_numpy(np.expand_dims(x,`0))`
11. img, mask = map(img_to_batch,`(img, mask))`
12. criterion = F.binary_cross_entropy

现在是时候训练一个网络并对单个图像进行过度拟合了——正如我所提到的，这是一种很好的调试技术：

1. model_a =`UNet(3,`1)
2. optimizer = torch.optim.Adam(model_a.parameters(), lr=1e-3)
3. losses =`[]`
4. for t in tqdm(range(20)):
5. loss = criterion(model_a(img), mask)
6. losses.append(loss.item())
7. optimizer.zero_grad()
8. loss.backward()
9. optimizer.step()
10. _ = plt.plot(losses)

曲率看起来很好，但是交叉熵的损失值-300是不可预料的。是什么问题？

归一化处理图像效果很好，但是mask没有：需要手动缩放到 [0,1]。

1. model_b =`UNet(3,`1)
2. optimizer = torch.optim.Adam(model_b.parameters(), lr=1e-3)
3. losses =`[]`
4. for t in tqdm(range(20)):
5. loss = criterion(model_b(img), mask /`255.)`
6. losses.append(loss.item())
7. optimizer.zero_grad()
8. loss.backward()
9. optimizer.step()
10. _ = plt.plot(losses)

训练循环的简单运行时断言(例如 assertmask.max()<=1会很快检测到问题。同样，也可以是单元测试。

总结

• 测试很有必要
• 运行时断言可以用于训练的pipeline;
• 可视化是一种幸福
• 复制粘贴是一种诅咒
• 没有什么是灵丹妙药，一个机器学习工程师必须总是小心(或只是受苦)。

CVPR 2022 | 数据堂亮相计算机视觉领域盛会

一年一度全球顶级的计算机视觉领域盛会 IEEE / CVF Computer Vision and Pattern Recognition Conference（以下简称“CVPR”）于6月19日在美国路易斯安那州新奥尔良拉开帷幕。

作为计算机视觉领域的顶级会议，CVPR每年都会吸引大量来自全球人工智能、计算机视觉以及机器学习领域的专业人士。

<<  滑动查看更多现场盛况  >>

自新冠疫情爆发以来，CVPR 2022首次重启线下参会，大会接收的投稿量达到近万份，相比去年增长了15%，其中44.59%的作者来自于中国大陆。

来自阿里巴巴和同济大学的研究者的论文《EPro-PnP: Generalized End-to-End Probabilistic Perspective-n-Points for Monocular Object Pose Estimation》获得了最佳学生论文奖。

CVPR 2022在现场公布最佳论文之前，还通过一段视频缅怀了旷视首席科学家、旷视研究院院长孙剑博士。孙剑博士此前曾两度获得CVPR最佳论文奖。

​

数据堂现场活动

数据堂作为CVPR 2022赞助商及参展单位，在Hall B-2场馆的1207展位等待您的莅临。

参展期间，数据堂将和国内外与会嘉宾分享我们在人脸识别、人体属性与行为识别、Re-ID、活体检测等领域的高质量成品数据集。

此外我们还准备了400份价值15万元的计算机视觉免费数据集等您来领取。点击图片即可了解数据详情。

​​​​

​​​​

​​​​

​​​​

​​​​

点击链接，快速注册领取免费数据集

CV新手避坑指南：计算机视觉常见的8个错误

重磅干货，第一时间送达