前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >【Code】OGB：图机器学习的基准测试数据集

【Code】OGB：图机器学习的基准测试数据集

作者头像
阿泽 Crz
发布于 2020-07-21 03:34:41
发布于 2020-07-21 03:34:41
1.5K00
代码可运行
举报
文章被收录于专栏：阿泽的学习笔记阿泽的学习笔记
运行总次数：0
代码可运行
关联问题
换一批

1.OGB

1.1 Overview

Open Graph Benchmark（以下简称 OGB）是斯坦福大学的同学开源的 Python 库，其包含了图机器学习（以下简称图 ML）的基准数据集、数据加载器和评估器，目的在于促进可扩展的、健壮的、可复现的图 ML 的研究。

OGB 包含了多种图机器学习的多种任务，并且涵盖从社会和信息网络到生物网络，分子图和知识图的各种领域。没有数据集都有特定的数据拆分和评估指标，从而提供统一的评估协议。

OGB 提供了一个自动的端到端图 ML 的 pipeline，该 pipeline 简化并标准化了图数据加载，实验设置和模型评估的过程。如下图所示：

下图展示了 OGB 的三个维度，包括任务类型（Tasks）、可扩展性（Scale）、领域（Rich domains）。

1.2 Dataset

来看一下 OGB 现在包含的数据集：

和数据集的统计明细：

1.3 Leaderboard

OGB 也提供了标准化的评估人员和排行榜，以跟踪最新的结果，我们来看下不同任务下的部分 Leaderboard。

节点分类：

链接预测：

图分类：

2.OGB+DGL

官方给出的例子都是基于 PyG 实现的，我们这里实现一个基于 DGL 例子。

2.1 环境准备

导入数据包

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
import dgl
import ogb
import math
import time
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from ogb.nodeproppred import DglNodePropPredDataset, Evaluator

查看版本

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
print(dgl.__version__)
print(torch.__version__)
print(ogb.__version__)
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
0.4.3post2
1.5.0+cu101
1.1.1

cuda 相关信息

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
print(torch.version.cuda)
print(torch.cuda.is_available())
print(torch.cuda.device_count())
print(torch.cuda.get_device_name(0))
print(torch.cuda.current_device())
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
10.1
True
1
Tesla P100-PCIE-16GB
0

2.2 数据准备

设置参数

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
device_id=0  # GPU 的使用 id
n_layers=3  # 输入层 + 隐藏层 + 输出层的数量
n_hiddens=256  # 隐藏层节点的数量
dropout=0.5
lr=0.01
epochs=300
runs=10  # 跑 10 次，取平均
log_steps=50

定义训练函数、测试函数和日志记录

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
def train(model, g, feats, y_true, train_idx, optimizer):
    """ 训练函数
    """
    model.train()
    optimizer.zero_grad()
    out = model(g, feats)[train_idx]
    loss = F.nll_loss(out, y_true.squeeze(1)[train_idx])
    loss.backward()
    optimizer.step()

    return loss.item()


@torch.no_grad()
def test(model, g, feats, y_true, split_idx, evaluator):
    """ 测试函数
    """
    model.eval()

    out = model(g, feats)
    y_pred = out.argmax(dim=-1, keepdim=True)

    train_acc = evaluator.eval({
        'y_true': y_true[split_idx['train']],
        'y_pred': y_pred[split_idx['train']],
    })['acc']
    valid_acc = evaluator.eval({
        'y_true': y_true[split_idx['valid']],
        'y_pred': y_pred[split_idx['valid']],
    })['acc']
    test_acc = evaluator.eval({
        'y_true': y_true[split_idx['test']],
        'y_pred': y_pred[split_idx['test']],
    })['acc']

    return train_acc, valid_acc, test_acc

class Logger(object):
    """ 用于日志记录
    """
    def __init__(self, runs, info=None):
        self.info = info
        self.results = [[] for _ in range(runs)]

    def add_result(self, run, result):
        assert len(result) == 3
        assert run >= 0 and run < len(self.results)
        self.results[run].append(result)

    def print_statistics(self, run=None):
        if run is not None:
            result = 100 * torch.tensor(self.results[run])
            argmax = result[:, 1].argmax().item()
            print(f'Run {run + 1:02d}:')
            print(f'Highest Train: {result[:, 0].max():.2f}')
            print(f'Highest Valid: {result[:, 1].max():.2f}')
            print(f'  Final Train: {result[argmax, 0]:.2f}')
            print(f'   Final Test: {result[argmax, 2]:.2f}')
        else:
            result = 100 * torch.tensor(self.results)

            best_results = []
            for r in result:
                train1 = r[:, 0].max().item()
                valid = r[:, 1].max().item()
                train2 = r[r[:, 1].argmax(), 0].item()
                test = r[r[:, 1].argmax(), 2].item()
                best_results.append((train1, valid, train2, test))

            best_result = torch.tensor(best_results)

            print(f'All runs:')
            r = best_result[:, 0]
            print(f'Highest Train: {r.mean():.2f} ± {r.std():.2f}')
            r = best_result[:, 1]
            print(f'Highest Valid: {r.mean():.2f} ± {r.std():.2f}')
            r = best_result[:, 2]
            print(f'  Final Train: {r.mean():.2f} ± {r.std():.2f}')
            r = best_result[:, 3]
            print(f'   Final Test: {r.mean():.2f} ± {r.std():.2f}')

加载数据

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
device = f'cuda:{device_id}' if torch.cuda.is_available() else 'cpu'
device = torch.device(device)

# 加载数据，name 为 'ogbn-' + 数据集名
# 自己可以打印出 dataset 看一下
dataset = DglNodePropPredDataset(name='ogbn-arxiv')
split_idx = dataset.get_idx_split()
g, labels = dataset[0]
feats = g.ndata['feat']
g = dgl.to_bidirected(g)
feats, labels = feats.to(device), labels.to(device)
train_idx = split_idx['train'].to(device)

2.3 GCN

实现一个基本的 GCN，这里对每一层都进行了一个 Batch Normalization，去掉的话，精度会下降 2% 左右。

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
from dgl.nn import GraphConv

class GCN(nn.Module):
    def __init__(self,
                 in_feats,
                 n_hiddens,
                 n_classes,
                 n_layers,
                 dropout):
        super(GCN, self).__init__()

        self.layers = nn.ModuleList()
        self.bns = nn.ModuleList()
        self.layers.append(GraphConv(in_feats, n_hiddens, 'both'))
        self.bns.append(nn.BatchNorm1d(n_hiddens))
        for _ in range(n_layers - 2):
            self.layers.append(GraphConv(n_hiddens, n_hiddens, 'both'))
            self.bns.append(nn.BatchNorm1d(n_hiddens))
        self.layers.append(GraphConv(n_hiddens, n_classes, 'both'))
        self.dropout = dropout

    def reset_parameters(self):
        for layer in self.layers:
            layer.reset_parameters()
        for bn in self.bns:
            bn.reset_parameters()

    def forward(self, g, x):
        for i, layer in enumerate(self.layers[:-1]):
            x = layer(g, x)
            x = self.bns[i](x)
            x = F.relu(x)
            x = F.dropout(x, p=self.dropout, training=self.training)
        x = self.layers[-1](g, x)
        return x.log_softmax(dim=-1)
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
model = GCN(in_feats=feats.size(-1),
            n_hiddens=n_hiddens,
            n_classes=dataset.num_classes,
            n_layers=n_layers,
            dropout=dropout).to(device)

evaluator = Evaluator(name='ogbn-arxiv')
logger = Logger(runs)

for run in range(runs):
    model.reset_parameters()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    for epoch in range(1, 1 + epochs):
        loss = train(model, g, feats, labels, train_idx, optimizer)
        result = test(model, g, feats, labels, split_idx, evaluator)
        logger.add_result(run, result)

        if epoch % log_steps == 0:
            train_acc, valid_acc, test_acc = result
            print(f'Run: {run + 1:02d}, '
                  f'Epoch: {epoch:02d}, '
                  f'Loss: {loss:.4f}, '
                  f'Train: {100 * train_acc:.2f}%, '
                  f'Valid: {100 * valid_acc:.2f}% '
                  f'Test: {100 * test_acc:.2f}%')

    logger.print_statistics(run)
logger.print_statistics()
代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
Run: 01, Epoch: 50, Loss: 1.1489, Train: 68.71%, Valid: 68.93% Test: 68.32%
Run: 01, Epoch: 100, Loss: 1.0565, Train: 71.29%, Valid: 69.61% Test: 68.03%
Run: 01, Epoch: 150, Loss: 1.0010, Train: 72.28%, Valid: 70.57% Test: 70.00%
Run: 01, Epoch: 200, Loss: 0.9647, Train: 73.18%, Valid: 69.79% Test: 67.97%
Training time/epoch 0.2617543590068817
Run 01:
Highest Train: 73.54
Highest Valid: 71.16
  Final Train: 73.08
   Final Test: 70.43
Run: 02, Epoch: 50, Loss: 1.1462, Train: 68.83%, Valid: 68.69% Test: 68.50%
Run: 02, Epoch: 100, Loss: 1.0583, Train: 71.17%, Valid: 69.54% Test: 68.06%
Run: 02, Epoch: 150, Loss: 1.0013, Train: 71.98%, Valid: 69.71% Test: 68.06%
Run: 02, Epoch: 200, Loss: 0.9626, Train: 73.23%, Valid: 69.76% Test: 67.79%
Training time/epoch 0.26154680013656617
Run 02:
Highest Train: 73.34
Highest Valid: 70.87
  Final Train: 72.56
   Final Test: 70.42
Run: 03, Epoch: 50, Loss: 1.1508, Train: 68.93%, Valid: 68.49% Test: 67.14%
Run: 03, Epoch: 100, Loss: 1.0527, Train: 70.90%, Valid: 69.75% Test: 68.77%
Run: 03, Epoch: 150, Loss: 1.0042, Train: 72.54%, Valid: 70.71% Test: 69.36%
Run: 03, Epoch: 200, Loss: 0.9679, Train: 73.13%, Valid: 69.92% Test: 68.05%
Training time/epoch 0.26173179904619853
Run 03:
Highest Train: 73.44
Highest Valid: 71.04
  Final Train: 73.06
   Final Test: 70.53
Run: 04, Epoch: 50, Loss: 1.1507, Train: 69.02%, Valid: 68.81% Test: 68.09%
Run: 04, Epoch: 100, Loss: 1.0518, Train: 71.30%, Valid: 70.19% Test: 68.78%
Run: 04, Epoch: 150, Loss: 0.9951, Train: 72.05%, Valid: 68.20% Test: 65.38%
Run: 04, Epoch: 200, Loss: 0.9594, Train: 72.98%, Valid: 70.47% Test: 69.26%
Training time/epoch 0.2618525844812393
Run 04:
Highest Train: 73.34
Highest Valid: 70.88
  Final Train: 72.86
   Final Test: 70.60
Run: 05, Epoch: 50, Loss: 1.1500, Train: 68.82%, Valid: 69.00% Test: 68.47%
Run: 05, Epoch: 100, Loss: 1.0566, Train: 71.13%, Valid: 70.15% Test: 69.47%
Run: 05, Epoch: 150, Loss: 0.9999, Train: 72.48%, Valid: 70.88% Test: 70.27%
Run: 05, Epoch: 200, Loss: 0.9648, Train: 73.37%, Valid: 70.51% Test: 68.96%
Training time/epoch 0.261941517829895
Run 05:
Highest Train: 73.37
Highest Valid: 70.93
  Final Train: 72.77
   Final Test: 70.24
Run: 06, Epoch: 50, Loss: 1.1495, Train: 69.00%, Valid: 68.76% Test: 67.89%
Run: 06, Epoch: 100, Loss: 1.0541, Train: 71.24%, Valid: 69.74% Test: 68.21%
Run: 06, Epoch: 150, Loss: 0.9947, Train: 71.89%, Valid: 69.81% Test: 69.77%
Run: 06, Epoch: 200, Loss: 0.9579, Train: 73.45%, Valid: 70.50% Test: 69.60%
Training time/epoch 0.2620268513758977
Run 06:
Highest Train: 73.70
Highest Valid: 70.97
  Final Train: 73.70
   Final Test: 70.12
Run: 07, Epoch: 50, Loss: 1.1544, Train: 68.93%, Valid: 68.81% Test: 67.97%
Run: 07, Epoch: 100, Loss: 1.0562, Train: 71.17%, Valid: 69.79% Test: 68.45%
Run: 07, Epoch: 150, Loss: 1.0016, Train: 72.41%, Valid: 70.65% Test: 69.87%
Run: 07, Epoch: 200, Loss: 0.9627, Train: 73.12%, Valid: 69.97% Test: 68.20%
Training time/epoch 0.2620680228301457
Run 07:
Highest Train: 73.40
Highest Valid: 71.02
  Final Train: 73.08
   Final Test: 70.49
Run: 08, Epoch: 50, Loss: 1.1508, Train: 68.89%, Valid: 68.42% Test: 67.68%
Run: 08, Epoch: 100, Loss: 1.0536, Train: 71.24%, Valid: 69.24% Test: 67.01%
Run: 08, Epoch: 150, Loss: 1.0015, Train: 72.36%, Valid: 69.57% Test: 67.76%
Run: 08, Epoch: 200, Loss: 0.9593, Train: 73.42%, Valid: 70.86% Test: 70.02%
Training time/epoch 0.2621182435750961
Run 08:
Highest Train: 73.43
Highest Valid: 70.93
  Final Train: 73.43
   Final Test: 69.92
Run: 09, Epoch: 50, Loss: 1.1457, Train: 69.17%, Valid: 68.83% Test: 67.67%
Run: 09, Epoch: 100, Loss: 1.0496, Train: 71.45%, Valid: 69.86% Test: 68.53%
Run: 09, Epoch: 150, Loss: 0.9941, Train: 72.51%, Valid: 69.38% Test: 67.02%
Run: 09, Epoch: 200, Loss: 0.9587, Train: 73.49%, Valid: 70.35% Test: 68.59%
Training time/epoch 0.2621259101231893
Run 09:
Highest Train: 73.64
Highest Valid: 70.97
  Final Train: 73.22
   Final Test: 70.46
Run: 10, Epoch: 50, Loss: 1.1437, Train: 69.16%, Valid: 68.43% Test: 67.17%
Run: 10, Epoch: 100, Loss: 1.0473, Train: 71.43%, Valid: 70.33% Test: 69.29%
Run: 10, Epoch: 150, Loss: 0.9936, Train: 71.98%, Valid: 67.93% Test: 65.06%
Run: 10, Epoch: 200, Loss: 0.9583, Train: 72.93%, Valid: 68.05% Test: 65.43%
Training time/epoch 0.26213142466545103
Run 10:
Highest Train: 73.44
Highest Valid: 70.93
  Final Train: 73.44
   Final Test: 70.26
All runs:
Highest Train: 73.46 ± 0.12
Highest Valid: 70.97 ± 0.09
  Final Train: 73.12 ± 0.34
   Final Test: 70.35 ± 0.21

3.Conclusion

目前，OGB 才刚刚起步，5 月 4 号刚发布第一个主要版本，未来还会扩展到千万级别节点的数据集。OGB 这样的多样且统一的基准的出现对 GNN 来说是非常重要的一步，希望也能形成与 NLP、CV 等领域类似的 Leaderboard，不至于每次论文都是在 Cora, CiteSeer 等玩具型数据集上做实验了。

4.References

  1. Hu, Weihua et al. “Open Graph Benchmark: Datasets for Machine Learning on Graphs.” ArXiv abs/2005.00687 (2020): n. pag.
  2. 《Open Graph Benchmark》
  3. 《Github: snap-stanford/ogb》
  4. 《Github: dmlc/dgl》
  5. Presentation and Discussion: Open Graph Benchmark
本文参与 腾讯云自媒体同步曝光计划，分享自微信公众号。
原始发表：2020-05-26，如有侵权请联系 cloudcommunity@tencent.com 删除
数据结构
github
机器学习
git
开源

本文分享自 阿泽的学习笔记 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

数据结构
github
机器学习
git
开源
评论
登录后参与评论
暂无评论
登录 后参与评论
推荐阅读
自己在总结前人经验下弄的几个opencv封装函数
图像处理
该文介绍了使用深度学习实现图像去噪和图像修复的方法，包括自编码器、卷积神经网络、生成对抗网络等技术，并提供了相关代码和示例。
林冠宏-指尖下的幽灵
2018/01/02
5930
OpenCv函数学习（一）[建议收藏]
javahttps网络安全
在记录数字图像的颜色时，计算机实际上是用每个像素需要的位深度来表示的。黑白二色的图像是数字图像中最简单的一种，它只有黑、白两种颜色，也就是说它的每个像素只有1位颜色，位深度是1，用2的一次幂来表示；考虑到位深度平均分给R, G, B和Alpha，而只有RGB可以相互组合成颜色。所以4位颜色的图，它的位深度是4，只有2的4次幂种颜色，即16种颜色或16种灰度等级 ) 。8位颜色的图，位深度就是8，用2的8次幂表示，它含有256种颜色 ( 或256种灰度等级 )。24位颜色可称之为真彩色，位深度是24，它能组合成2的24次幂种颜色，即：16777216种颜色 ( 或称千万种颜色 )，超过了人眼能够分辨的颜色数量。当我们用24位来记录颜色时，实际上是以2^（8×3），即红、绿、蓝 ( RGB ) 三基色各以2的8次幂，256种颜色而存在的，三色组合就形成一千六百万种颜色。
全栈程序员站长
2022/07/14
3180
OpenCV导向滤波（引导滤波）实现（Guided Filter）代码，以及使用颜色先验算法去雾
opencv
 论文下载地址：http://research.microsoft.com/en-us/um/people/jiansun/papers/GuidedFilter_ECCV10.pdf
流川疯
2019/01/18
2.6K0
OpenCV 实现哈哈镜效果
算法
代码，有参考别人的代码 // haha_mirror.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> #include "cv.h" #include "highgui.h" #include "math.h" #include "opencv2/core/core.hpp" #pragma comment(lib,"opencv_core2410d.lib") #pragma comment
流川疯
2022/06/16
3500
OpenCV 实现哈哈镜效果
OpenCV的Mat类型以及基本函数使用
opencvc++数据结构
在OpenCV中IplImage是表示一个图像的结构体，也是从OpenCV1.0到目前最为重要的一个结构；在之前的图像表示用IplImage，而且之前的OpenCV是用C语言编写的，提供的接口也是C语言接口。
职场亮哥
2020/10/10
1.5K0
Adaptive thresholding using the integral image
windows编程算法
大家好，又见面了，我是你们的朋友全栈君。#include <opencv2/opencv.hpp> #include <opencv2/legacy/compat.hpp> #include <opencv2/imgproc/types_c.h> #include <fstream> using namespace std; void vvAdaptiveThreshold( IplImage* inImg, IplImage* outImg) { int S = inImg->width >> 5; int T = 10;
全栈程序员站长
2022/08/29
2130
OpenCV计算物体的重心坐标（2值图像）
opencv
http://download.csdn.net/detail/wangyaninglm/9389338 
流川疯
2019/01/18
2K0
OpenCV 矩形轮廓检测
opencvpython
转载请注明出处：http://blog.csdn.net/wangyaninglm/article/details/44151213，
流川疯
2022/11/29
9790
OpenCV 矩形轮廓检测
Bitmap与IplImage之间的转换
api编程算法
如果要从CBitmap转为IplImage，可以先将CBitmap转为BITMAP，再由BITMAP转为IplImage；
战神伽罗
2019/07/24
1.3K0
Bitmap与IplImage之间的转换
单目摄像机标定程序「建议收藏」
https网络安全
我自己写了一个摄像机标定程序，核心算法参照learning opencv，但是那个程序要从命令行预先输入参数，且标定图片要预先准备好，我觉得不太好，我就自己写了一个，跟大家分享下。 若有纰漏，希望大家指正！
全栈程序员站长
2022/11/15
4550
opencv——访问图像元素(imagedata widthstep)
tcp/ip
怎么访问图像元素 (坐标起点相对于图像原点 image origin 从 0 开始，或者是左上角 (img->origin=IPL_ORIGIN_TL) 或者是左下角 (img->origin=IPL_ORIGIN_BL)
全栈程序员站长
2022/08/15
6520
基于粒子滤波的物体跟踪
samplingsumvi
一直都觉得粒子滤波是个挺牛的东西，每次试图看文献都被复杂的数学符号搞得看不下去。一个偶然的机会发现了Rob Hess(http://web.engr.oregonstate.edu/~hess/)实现的这个粒子滤波。从代码入手，一下子就明白了粒子滤波的原理。根据维基百科上对粒子滤波的介绍(http://en.wikipedia.org/wiki/Particle_filter)，粒子滤波其实有很多变种，Rob Hess实现的这种应该是最基本的一种，Sampling Importance Resampling (SIR)，根据重要性重采样。下面是我对粒子滤波实现物体跟踪的算法原理的粗浅理解：
MachineLP
2022/05/09
6680
基于粒子滤波的物体跟踪
RTSP/GB28181/HIKSDK/Ehome协议视频上云服务平台EasyCVR人脸识别开发ArcSoftFace环境搭建
人脸识别sdkidevr 视频解决方案
前段时间很多用户咨询我们TSINGSEE青犀视频全线产品能否实现人脸识别，那时候对人脸识别的研究我们也才处于起步状态，目前我们在EasyCVR视频上云网关上已经开始搭建的人脸识别的环境，本文就和大家分享一下。
EasyNVR
2020/10/10
1.2K0
RTSP/GB28181/HIKSDK/Ehome协议视频上云服务平台EasyCVR人脸识别开发ArcSoftFace环境搭建
图像处理-灰度变换-直方图
编程算法
假如图像的灰度分布不均匀，其灰度分布集中在较窄的范围内，使图像的细节不够清晰，对比度较低。通常采用直方图均衡化及直方图规定化两种变换，使图像的灰度范围拉开或使灰度均匀分布，从而增大反差，使图像细节清晰，以达到增强的目的。 直方图均衡化，对图像进行非线性拉伸，重新分配图像的灰度值，使一定范围内图像的灰度值大致相等。这样，原来直方图中间的峰值部分对比度得到增强，而两侧的谷底部分对比度降低，输出图像的直方图是一个较为平坦的直方图。
AomanHao
2022/01/14
1.5K0
图像处理-灰度变换-直方图
车牌识别 之 字符分割
直接贴代码： #include "stdafx.h" #include "cv.h" #include "highgui.h" using namespace std; using namespace cv; IplImage *g_pGrayImage = NULL; IplImage *g_pBinaryImage = NULL; const char *pstrWindowsBinaryTitle = "二值图"; void on_trackbar(int pos) {
MachineLP
2022/05/09
1.6K0
车牌识别 之 字符分割
OpenCV 1 图像分割--分水岭算法代码
// watershed_test20140801.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" // // ch9_watershed image // This is an exact copy of the watershed.cpp demo in the OpenCV ../samples/c directory // // Think about using a morphologically eroded forground and backg
流川疯
2022/11/29
2970
opencv角点检测学习总结[通俗易懂]
opencvscala编程算法图像处理
如果一个点在两个正交方向上都有明显的导数，则我们认为此点更倾向于是独一无二的，所以许多可跟踪的特征点都是角点。
全栈程序员站长
2022/09/27
9950
图像处理-图像分割-大津法
编程算法
最大类间方差法是1979年由日本学者大津提出的，是一种自适应阈值确定的方法，又叫大津法，简称OTSU
AomanHao
2022/01/14
5750
OpenCV图像处理笔记（二）：图片操作进阶
c++api图像处理
一、图像模糊 1、模糊原理 Smooth/Blur 是图像处理中最简单和常用的操作之一 使用该操作的原因之一就为了给图像预处理时候减低噪声 使用Smooth/Blur操作其背后是数学的卷积计算 通常这
MiChong
2020/09/24
1.2K0
OpenCV图像处理笔记（二）：图片操作进阶
ViVADO HLS 图像的获取
图像处理
OPENCV（Open Source Computer Vision）被广泛的使用在计算机视觉开发上。使用VIVADO HLS视频库在zynq-7000全可编程soc上加速OPENCV 应用的开发，将大大提升我们的计算机视觉开发。
FPGA开源工作室
2019/10/29
1.8K0
ViVADO HLS 图像的获取
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪多租户的 4 种常用方案亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？60页PPT全解：DeepSeek系列论文技术要点整理
相关讨论
如何收藏文章？请我我收藏的东西在哪里能找到？软件使用建议？
相关课程
轻量应用构建训练营前端云原生降本增效实战营
自己在总结前人经验下弄的几个opencv封装函数
5930
OpenCv函数学习（一）[建议收藏]
3180
OpenCV导向滤波（引导滤波）实现（Guided Filter）代码，以及使用颜色先验算法去雾
2.6K0
OpenCV 实现哈哈镜效果
3500
OpenCV的Mat类型以及基本函数使用
1.5K0
Adaptive thresholding using the integral image
2130
OpenCV计算物体的重心坐标（2值图像）
2K0
OpenCV 矩形轮廓检测
9790
Bitmap与IplImage之间的转换
1.3K0
单目摄像机标定程序「建议收藏」
4550
opencv——访问图像元素(imagedata widthstep)
6520
基于粒子滤波的物体跟踪
6680
RTSP/GB28181/HIKSDK/Ehome协议视频上云服务平台EasyCVR人脸识别开发ArcSoftFace环境搭建
1.2K0
图像处理-灰度变换-直方图
1.5K0
车牌识别 之 字符分割
1.6K0
OpenCV 1 图像分割--分水岭算法代码
2970
opencv角点检测学习总结[通俗易懂]
9950
图像处理-图像分割-大津法
5750
OpenCV图像处理笔记（二）：图片操作进阶
1.2K0
ViVADO HLS 图像的获取
1.8K0
相关推荐
自己在总结前人经验下弄的几个opencv封装函数
更多 >
全栈程序员站长0
LV.1
CTO
文章
55K
获赞
121.5K
专栏
2
目录
  • 1.OGB
    • 1.1 Overview
    • 1.2 Dataset
    • 1.3 Leaderboard
  • 2.OGB+DGL
    • 2.1 环境准备
    • 2.2 数据准备
    • 2.3 GCN
  • 3.Conclusion
  • 4.References
加入讨论
的问答专区 >
码事漫谈0
1高级后端开发工程师擅长3个领域
相关课程
一站式学习中心 >
轻量应用构建训练营
2894人在学
云服务器
轻量应用服务器
云计算
前端
1252人在学
前端
云原生降本增效实战营
267人在学
容器
容器服务
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论
2