Benchmark datasets, data loaders, and evaluators for graph machine learning

Overview


PyPI License

Overview

The Open Graph Benchmark (OGB) is a collection of benchmark datasets, data loaders, and evaluators for graph machine learning. Datasets cover a variety of graph machine learning tasks and real-world applications. The OGB data loaders are fully compatible with popular graph deep learning frameworks, including PyTorch Geometric and Deep Graph Library (DGL). They provide automatic dataset downloading, standardized dataset splits, and unified performance evaluation.

OGB aims to provide graph datasets that cover important graph machine learning tasks, diverse dataset scale, and rich domains.

Graph ML Tasks: We cover three fundamental graph machine learning tasks: prediction at the level of nodes, links, and graphs.

Diverse scale: Small-scale graph datasets can be processed within a single GPU, while medium- and large-scale graphs might require multiple GPUs or clever sampling/partition techniques.

Rich domains: Graph datasets come from diverse domains ranging from scientific ones to social/information networks, and also include heterogeneous knowledge graphs.

OGB is an on-going effort, and we are planning to increase our coverage in the future.

Installation

You can install OGB using Python's package manager pip. If you have previously installed ogb, please make sure you update the version to 1.3.2. The release note is available here.

Requirements

  • Python>=3.6
  • PyTorch>=1.6
  • DGL>=0.5.0 or torch-geometric>=1.6.0
  • Numpy>=1.16.0
  • pandas>=0.24.0
  • urllib3>=1.24.0
  • scikit-learn>=0.20.0
  • outdated>=0.2.0

Pip install

The recommended way to install OGB is using Python's package manager pip:

pip install ogb
python -c "import ogb; print(ogb.__version__)"
# This should print "1.3.2". Otherwise, please update the version by
pip install -U ogb

From source

You can also install OGB from source. This is recommended if you want to contribute to OGB.

git clone https://github.com/snap-stanford/ogb
cd ogb
pip install -e .

Package Usage

We highlight two key features of OGB, namely, (1) easy-to-use data loaders, and (2) standardized evaluators.

(1) Data loaders

We prepare easy-to-use PyTorch Geometric and DGL data loaders. We handle dataset downloading as well as standardized dataset splitting. Below, on PyTorch Geometric, we see that a few lines of code is sufficient to prepare and split the dataset! Needless to say, you can enjoy the same convenience for DGL!

from ogb.graphproppred import PygGraphPropPredDataset
from torch_geometric.data import DataLoader

# Download and process data at './dataset/ogbg_molhiv/'
dataset = PygGraphPropPredDataset(name = 'ogbg-molhiv')

split_idx = dataset.get_idx_split() 
train_loader = DataLoader(dataset[split_idx['train']], batch_size=32, shuffle=True)
valid_loader = DataLoader(dataset[split_idx['valid']], batch_size=32, shuffle=False)
test_loader = DataLoader(dataset[split_idx['test']], batch_size=32, shuffle=False)

(2) Evaluators

We also prepare standardized evaluators for easy evaluation and comparison of different methods. The evaluator takes input_dict (a dictionary whose format is specified in evaluator.expected_input_format) as input, and returns a dictionary storing the performance metric appropriate for the given dataset. The standardized evaluation protocol allows researchers to reliably compare their methods.

from ogb.graphproppred import Evaluator

evaluator = Evaluator(name = 'ogbg-molhiv')
# You can learn the input and output format specification of the evaluator as follows.
# print(evaluator.expected_input_format) 
# print(evaluator.expected_output_format) 
input_dict = {'y_true': y_true, 'y_pred': y_pred}
result_dict = evaluator.eval(input_dict) # E.g., {'rocauc': 0.7321}

Citing OGB / OGB-LSC

If you use OGB or OGB-LSC datasets in your work, please cite our papers (Bibtex below).

@article{hu2020ogb,
  title={Open Graph Benchmark: Datasets for Machine Learning on Graphs},
  author={Hu, Weihua and Fey, Matthias and Zitnik, Marinka and Dong, Yuxiao and Ren, Hongyu and Liu, Bowen and Catasta, Michele and Leskovec, Jure},
  journal={arXiv preprint arXiv:2005.00687},
  year={2020}
}
@article{hu2021ogblsc,
  title={OGB-LSC: A Large-Scale Challenge for Machine Learning on Graphs},
  author={Hu, Weihua and Fey, Matthias and Ren, Hongyu and Nakata, Maho and Dong, Yuxiao and Leskovec, Jure},
  journal={arXiv preprint arXiv:2103.09430},
  year={2021}
}
Comments
  • Are you allowed to use validation labels for label propagation?

    Are you allowed to use validation labels for label propagation?

    I plan on submitting several label propagation baselines. However, when using label propagation (which has 0 parameters), it seems quite weird (and unfair to it) to not use the validation labels for the purposes of propagation.

    There's only one hyperparameter to tune (alpha) and no parameters learned. In addition, regardless of what hyperparameters you choose (and how you choose them), it's hard for me to imagine an instance where using train + validation labels will worsen your performance at inference.

    For GNNs a validation set is often needed, as you need it for stuff like early stopping as well as tuning your (many) hyperparameters.

    Essentially, if say, ogbn-arxiv was a realistic setting, I can't imagine a case where you wouldn't want to use validation labels for your label propagation.

    However, I can understand if OGB would like to prohibit that, given that OGB is meant as a benchmark, which by their very nature, are somewhat synthetic.

    opened by Chillee 19
  • Confusion about ogbl-biokg

    Confusion about ogbl-biokg

    Hi, could you explain the test data for ogbl-biokg in more detail?

    Specifically, we corrupt each test triplet edges by replacing its head or tail with randomly-sampled 1,000 negative entities (500 for head and 500 for tail), while ensuring the resulting triplets do not appear in KG.

    I'm not sure I fully understand. Does this mean that you randomly sample, from all nodes, each head and tail (500 for each) for each test edge? If we are to predict the existence of edges, what will this information be used for?

    opened by vymao 14
  • use the whole graph adjacency matrix for link prediction task?

    use the whole graph adjacency matrix for link prediction task?

    https://github.com/snap-stanford/ogb/blob/master/examples/linkproppred/collab/gnn.py#L106

    it seems that gnn model takes the whole adjacency matrix (data.adj_t).

    but as far as I know, in the standard setting, gnn takes an incomplete set of edges (split_edge['train']['edge']) and predicts the rest (split_edge['valid'] and split_edge['test']).

    Should I fix it? or could you please give me some reference for this setting?

    I really appreciate the great commitment of you all.

    opened by LeeJunHyun 14
  • PCQM4Mv2 sdf problem

    PCQM4Mv2 sdf problem

    HI, I try to get the mol from pcqm4m-v2-train.sdf, and compare the structure with mol from rdkit.Chem.MolFromSmiles, for example: obabel -ixyz 1.xyz -osmi -O 1.smi, we get the smiles CC(=O)N(C)/C=C/c1ccc(cc1OC)OC, but origin is COc1cc(OC)ccc1/C=C/N(C(=O)C)C then I do gnn inference with these two graphs, the final result is a little different。 it seems that 2D graph is not the same? btw sdf does not provide xyz of H like pcqm4m-v2_xyz.zip ?

    opened by PierreHao 13
  • Import issue in ogb

    Import issue in ogb

    The ogb package can not be imported on console now and will generate errors for the below imports:

    import torch import ogb from ogb.graphproppred import GraphPropPredDataset from ogb.graphproppred import PygGraphPropPredDataset

    In addition log generation is not implemented in init files. I also noticed that the lines in init that blocks proper import have not yet been used anywhere else in the program so I have a PR to address these issues.

    https://github.com/Zahra-Bakhtiari/GraphPropPred_bug_fix/pull/1/files

    I also did some google search and noticed that this is a big struggle for the new ogb users, several open issues exist on it :)

    opened by Zahra-Bakhtiari 12
  • Cannot pickle local object

    Cannot pickle local object

    Hi there!

    I was trying to work with the obgl-biokg and execute the script at https://github.com/snap-stanford/ogb/blob/master/examples/linkproppred/biokg/run.py .

    I was getting the following error:

    Exception has occurred: AttributeError
    Can't pickle local object 'main.<locals>.<lambda>'
      File "/.../src/ogb_original/dataloader.py", line 121, in one_shot_iterator
        for data in dataloader:
      File "/.../src/ogb_original/dataloader.py", line 112, in __next__
        data = next(self.iterator_tail)
      File "/.../src/ogb_original/model.py", line 238, in train_step
        positive_sample, negative_sample, subsampling_weight, mode = next(train_iterator)
      File "/...3/src/ogblbiokg/linkproppred_biokg.py", line 306, in main
        log = kge_model.train_step(kge_model, optimizer, train_iterator, args)
      File "/.../src/ogblbiokg/linkproppred_biokg.py", line 371, in <module>
        main(parse_args(params))
    

    Could you help me how to handle this issue?

    opened by sophiakrix 11
  • which version of ogbn-proteins dataset did you use in cluster_gin.py file?

    which version of ogbn-proteins dataset did you use in cluster_gin.py file?

    Hello, OGB team, hope you are doing great! I just downloaded the example code of ogbn-proteins and ran the cluster_gin.py. I found out you didn't use node features and the node species information has been changed from previous one-hot encoding (version 3) to taxonomy ID. However, in cluster_gin.py file, cluster_data.data.x = cluster_data.data.x.to(torch.float) this statement is incorrect cause there is no attribute called x now. You can check when you set the argumentuse_node_features to be True. Another question is that it is possible for us to use one-hot encoding features provided previously? Because we have no idea about the meaning represented by taxonomy ID of each protein or does the similarity between two proteins could be expressed by the difference of their taxonomy IDs? Thank you for replying in advance and have a good one! Screen Shot 1441-08-07 at 12 57 22 AM

    opened by Elizabeth1997 11
  • Predictor setting in inference for ogbl-vessel

    Predictor setting in inference for ogbl-vessel

    https://github.com/snap-stanford/ogb/blob/f5534d99703ab549ae4f7279f2002c6cc79041dc/examples/linkproppred/vessel/gnn.py#L139

    I found that the predictor is not set to predictor.eval() in the test function in gnn.py, which may result in the poor performance for GNN on this dataset. If predictor.eval() is added, even with hidden size 3, the test ROC-AUC of GCN may reach 70+%, although sometimes it is stuck at 50%.

    opened by skepsun 10
  • Loading imports gets stuck

    Loading imports gets stuck

    I think there is a problem with imports in ogb. I tried to run the example:

    import networkx as nx
    print("a")
    # from sklearn.metrics import roc_auc_score, average_precision_score
    from ogb.graphproppred import PygGraphPropPredDataset
    print("c")
    from torch_geometric.loader import DataLoader
    
    # Download and process data at './dataset/ogbg_molhiv/'
    dataset = PygGraphPropPredDataset(name="ogbg-molhiv", root='dataset/')
    
    split_idx = dataset.get_idx_split()
    train_loader = DataLoader(dataset[split_idx["train"]], batch_size=32, shuffle=False)
    valid_loader = DataLoader(dataset[split_idx["valid"]], batch_size=32, shuffle=False)
    test_loader = DataLoader(dataset[split_idx["test"]], batch_size=32, shuffle=False)
    

    a gets printed, but then Python gets stuck and does not print c. However I tried to add print("b") to various points in ogb, following the from ogb.graphproppred import PygGraphPropPredDataset line.

    To import PygGraphPropPredDataset, we need to run the code in __init__.py:

    from .evaluate import Evaluator
    from .dataset import GraphPropPredDataset
    
    try:
        from .dataset_pyg import PygGraphPropPredDataset
    except ImportError:
        pass
    
    try:
        from .dataset_dgl import DglGraphPropPredDataset
        from .dataset_dgl import collate_dgl
    except (ImportError, OSError):
        pass
    
    

    Even the first line does not get printed. So I went to the evaluate.py and there we have:

    from sklearn.metrics import roc_auc_score, average_precision_score
    print("b")
    
    import pandas as pd
    import os
    import numpy as np
    
    try:
        import torch
    except ImportError:
        torch = None
    

    And b does not get printed. So I added from sklearn.metrics import roc_auc_score, average_precision_score directly after print("a") in the original file. After this modification it works.

    I had an opportunity to try this multiple times, on fresh installs of the entire OS (Windows 2 times, Linux 1 time), with three versions of Python (3.8, 3.9, 3.10) and 3 versions of PyTorch (3.9, 3.10, 3.11). The problem was identical every time, and every time adding the manual import worked.

    Fixing this would be pretty nice, since this is a quickstart on the main page.

    opened by j-adamczyk 10
  • Importing ogb, program stuck for infinite time

    Importing ogb, program stuck for infinite time

    Hi I am able to run from torch_geometric.data import InMemoryDataset successfully. But whenever I try to import anything from ogb, the program stuck for infinite time. Import code is: from ogb.graphproppred import Evaluator

    I followed the following command to install torch in conda environment:

    CUDA=cu113
    TORCH=1.11.0
    pip install torch-scatter -f https://pytorch-geometric.com/whl/torch-${TORCH}+${CUDA}.html
    pip install torch-sparse -f https://pytorch-geometric.com/whl/torch-${TORCH}+${CUDA}.html
    pip install torch-cluster -f https://pytorch-geometric.com/whl/torch-${TORCH}+${CUDA}.html
    pip install torch-spline-conv -f https://pytorch-geometric.com/whl/torch-${TORCH}+${CUDA}.html
    pip install torch-geometric
    

    Note that, I am using Ubuntu. My Nvidia-smi output:

    $ nvidia-smi
    Wed Apr 20 05:09:04 2022       
    +-----------------------------------------------------------------------------+
    | NVIDIA-SMI 450.119.03   Driver Version: 450.119.03   CUDA Version: 11.0     |
    |-------------------------------+----------------------+----------------------+
    | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
    | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
    |                               |                      |               MIG M. |
    |===============================+======================+======================|
    |   0  GeForce GTX 1070    Off  | 00000000:01:00.0  On |                  N/A |
    | 27%   36C    P8     9W / 151W |   1227MiB /  8116MiB |      1%      Default |
    |                               |                      |                  N/A
    
    opened by faysalhossain2007 10
  • Isn't there any way to use ogb datasets by tensorflow, instead of torch?

    Isn't there any way to use ogb datasets by tensorflow, instead of torch?

    I am working on a big machine learning project in which various features of tensorflow are used. So, while using an ogb dataset for a new graph-based module, I cannot switch to torch. I thought your library-agnostic loader provides a way to incorporate tensorflow, as here one reads

    We also prepare library-agnostic dataset loaders that can be used with any other deep learning libraries such as Tensorflow and MxNet.

    However, I still get the following error

    Traceback (most recent call last):
      File "C:/Users/Matinking/PycharmProjects/RL/GNN_spektral_OGB.py", line 11, in <module>
        from ogb.nodeproppred import NodePropPredDataset
      File "C:\Users\Matinking\AppData\Local\Programs\Python\Python37\lib\site-packages\ogb\nodeproppred\__init__.py", line 2, in <module>
        from .dataset import NodePropPredDataset
      File "~\AppData\Local\Programs\Python\Python37\lib\site-packages\ogb\nodeproppred\dataset.py", line 5, in <module>
        from ogb.io.read_graph_raw import read_csv_graph_raw, read_csv_heterograph_raw,\
      File "~\AppData\Local\Programs\Python\Python37\lib\site-packages\ogb\io\__init__.py", line 1, in <module>
        from .save_dataset import DatasetSaver
      File "~\AppData\Local\Programs\Python\Python37\lib\site-packages\ogb\io\save_dataset.py", line 1, in <module>
        import torch
    ModuleNotFoundError: No module named 'torch'
    

    when I run, for example,

    mport numpy as np
    import matplotlib.pyplot as plt
    
    from tensorflow.keras.losses import CategoricalCrossentropy
    from tensorflow.keras.metrics import categorical_accuracy
    from tensorflow.keras.optimizers import Adam
    
    from spektral.data import DisjointLoader
    from spektral.models import GeneralGNN
    
    from ogb.nodeproppred import NodePropPredDataset
    
    dataset = NodePropPredDataset("ogbn-proteins")
    split_idx = dataset.get_idx_split()
    train_idx, valid_idx, test_idx = split_idx["train"], split_idx["valid"], split_idx["test"]
    
    np.random.seed(0)
    
    batch_size = 16
    learning_rate = 0.0001
    epochs = 100
    
    loader_tr = DisjointLoader(train_idx, batch_size=batch_size, epochs=epochs)
    loader_te = DisjointLoader(test_idx, batch_size=batch_size)
    
    model = GeneralGNN(dataset.labels, activation="softmax")
    
    optimizer = Adam(learning_rate)
    loss_fn = CategoricalCrossentropy()
    model.compile(loss=loss_fn,
                  optimizer=optimizer,
                  metrics=categorical_accuracy)
    
    history = model.fit(loader_tr.load(), steps_per_epoch=loader_te.steps_per_epoch, epochs=epochs)
    
    plt.plot(history.history['loss'])
    plt.plot(history.history['categorical_accuracy'])
    plt.xlabel('epoch')
    plt.legend(["Loss", "Categorical Accuracy"])
    plt.show()
    

    Thus, can you please guide me on how to use ogb datasets by tensorflow, instead of torch?

    Thanks, Matin

    opened by Matin-Macktoobian 10
  • Python3.9:  OSError: libcublas.so.11: cannot open shared object file: No such file or directory

    Python3.9: OSError: libcublas.so.11: cannot open shared object file: No such file or directory

    Aware, of course, that you don't yet officially support Python3.9, but thought this might be useful for someone who needs to use it:

    Had this error when trying to install the module on Python3.9:

    /python3.9/site-packages/torch/__init__.py", line 153, in _load_global_deps
         ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL)
       File "/usr/lib64/python3.9/ctypes/__init__.py", line 374, in __init__
         self._handle = _dlopen(self._name, mode)
     OSError: libcublas.so.11: cannot open shared object file: No such file or directory
    

    Worked around the error by updating the torch version in our model's requirements.txt to include a different cuda version (when running on Python3.9 or greater) thus:

    # Workaround for OGB issue on Python3.9
    --find-links https://download.pytorch.org/whl/torch_stable.html
    torch==1.13.0+cu116; python_version >= '3.9'
    
    opened by colossusb 0
  • [Feature Request] Using parquet files instead/alongside torch splits

    [Feature Request] Using parquet files instead/alongside torch splits

    Hello devs. I am trying to develop support for OGB Datasets in MLDatasets.jl. One of the bottlenecks we are facing is loading the .pt files. This implementation here using Pickle.jl hack results in substantial memory usage compared to python. With new support for TorchArrow can you support parquet files for loading the splits?

    opened by Dsantra92 0
  • [Suggestion - PyG] option to load heterogeneous graphs as HeteroData

    [Suggestion - PyG] option to load heterogeneous graphs as HeteroData

    Hi OGB-Team, right now, heterogenous graphs are loaded as a Data objects by filling x_dict, edge_index_dict etc.. HeteroData in PyG on the other hand, stores features and edges by its node-type or edge-type identifier, e.g. node-related buffers like x are exposed as data[NODE_TYPE].buffer and edge-related buffers like edge_index are exposed as data[EDGE_TYPE].buffer.Those representations are quite similar besides basically the order of keys accessing the data, e.g. data.x_dict[NODE_TYPE] vs data[NODE_TYPE].x.

    Is there any particular reason for this? If not, HeteroData would seem more flexible to me in the PyG framework, as it would allow for direct use with samplers or for transformations like to_undirected or to_homogeneous.

    opened by stadlmax 1
Releases(1.3.5)
  • 1.3.5(Nov 2, 2022)

  • 1.3.4(Aug 20, 2022)

    This release introduces the following two:

    • ogbl-vessel dataset (described here) @jqmcginnis
    • Improved rank calculation for link prediction https://github.com/snap-stanford/ogb/pull/357 @mberr
    Source code(tar.gz)
    Source code(zip)
  • 1.3.2(Sep 29, 2021)

  • 1.3.1(Apr 7, 2021)

    Thanks to the DGL Team, all the LSC data is now hosted on AWS. This significantly improves the download speed around the globe! The underlying data stays exactly the same.

    Source code(tar.gz)
    Source code(zip)
  • 1.3.0(Mar 15, 2021)

  • 1.2.6(Mar 1, 2021)

  • 1.2.5(Feb 24, 2021)

    This version provides a major change in ogbg-code.

    • ogbg-code has been deprecated due to prediction target (i.e., method name) leakage in input AST.
    • ogbg-code2 has been introduced that fixes the issue., where the method name and its recursive definition in AST are replaced with a special token _mask_.

    We sincerely thank Charles Sutton (@casutton) for finding the data leakage in our dataset.

    Source code(tar.gz)
    Source code(zip)
  • 1.2.4(Dec 29, 2020)

    This release fixes the dataset bug in negative samples in ogbl-wikikg and ogbl-citation and releases new versions of them: ogbl-wikikg2 and ogbl-citation2. The old versions are deprecated.

    Source code(tar.gz)
    Source code(zip)
  • 1.2.3(Sep 12, 2020)

    This release enhances the OGB package in the following ways.

    • Made ogbn-papers100M data loading more tractable by using compressed binary files https://github.com/snap-stanford/ogb/issues/46
    • Introduced DatasetSaver module for external contributors https://github.com/snap-stanford/ogb/issues/1
    • Made dataset object compatible to DGL v0.5 (not backward compatible for heterogeneous graph datasets).
    Source code(tar.gz)
    Source code(zip)
  • 1.2.2(Aug 12, 2020)

    This release is mainly for changing the evaluation metric of ogbg-molpcba from PRC-AUC to Average Precision (AP). AP is shown to be more appropriate to summarize the non-convex nature of the Precision Recall Curve [1]. The leaderboard and our paper have been updated accordingly.

    We also fix an issue and add a feature:

    • Fixed an issue for saving a large library-agnostic data object. https://github.com/snap-stanford/ogb/issues/48
    • Added automatic version check feature so that users will get notified when the package version is outdated.

    [1] Jesse Davis and Mark Goadrich. The relationship between precision-recall and roc curves. InInternational Conference on Machine Learning (ICML), pp. 233–240, 2006.

    Source code(tar.gz)
    Source code(zip)
  • 1.2.1(Jun 27, 2020)

    This release fixes bugs in a dataset, evaluator, and data loader.

    • Duplicated edges in ogbn-mag are removed. The updated dataset will be downloaded and processed automatically as you run your script for ogbn-mag. #40
    • Evaluators for ogbl-collab and ogbl-ddi are updated. Specifically, ogbl-collab now uses Hits@50, and ogbl-ddi now uses Hits@20.
    • DGL data loader bug for ogbn-mag and ogbl-biokg is fixed. #36
    Source code(tar.gz)
    Source code(zip)
  • 1.2.0(Jun 11, 2020)

    This is the second major release of OGB, in which we have curated many more exciting graph datasets, including heterogeneous graphs and a web-scale gigantic graph (100+ million nodes, 1+ billion edges).

    First, we note that there is no change in the datasets released in version 1.1.1. Therefore, any experimental results obtained using 1.1.1 on the existing datasets are compatible to version 1.2.0.

    In this new release, we have additionally released 5 new datasets listed below.

    • ogbn-papers100M: Web-scale gigantic paper citation network.
    • ogbn-mag: Heterogeneous academic graph.
    • ogbl-biokg: Heterogeneous biomedical knowledge graph.
    • ogbl-ddi: Drug-drug interaction network.
    • ogbg-code: Source code Abstract Syntax Trees.
    Source code(tar.gz)
    Source code(zip)
  • 1.1.1(May 5, 2020)

  • 1.1.0(May 1, 2020)

    First Major Release

    This is the first major release of OGB. A number of changes have been made to the datasets, which are summarized below.

    1. Re-indexed all the nodes in the node/link datasets (The graphs remain essentially the same).
    2. In dataset folders for all the datasets, added mapping/ directory that contains information to map node/edge/graph/label indices to real-world entities (e.g., mapping from nodes in PPA to unique protein identifiers, mapping from molecular graphs into the SMILES strings.)
    3. Deleted the ogbn-proteins node features, and put them in the species variable.
    4. Deleted ogbl-reviews datasets.
    5. Added 4 datasets: ogbn-arxiv, ogbl-citation, ogbl-collab, ogbl-wikikg.
    6. Renamed ogbg-ppi to ogbg-ppa.
    7. Renamed ogbg-mol-hiv and ogbg-mol-pcba to ogbg-molhiv and ogbg-molpcba, respectively.
    8. Changed the evaluation metric of imbalanced molecule dataset (e.g., pcba) from ROC-AUC to PRC-AUC.
    9. Changed the get_split_edge() interface in LinkPropPredDataset. The downloaded dataset files are also changed accordingly.
    10. Added num_classes attribute for multi-class classification datasets.
    Source code(tar.gz)
    Source code(zip)
  • 1.0.1(Mar 23, 2020)

    Minor Changes

    OGB datasets can now be imported more conveniently, e.g.:

    from ogb.graphproppred import GraphPropPredDataset
    from ogb.graphproppred import PygGraphPropPredDataset
    from ogb.graphproppred import DglGraphPropPredDataset
    

    Note that this will throw an ImportError if OGB can not find installations of Pyg or DGL, respectively.

    Source code(tar.gz)
    Source code(zip)
Deep Learning Datasets Maker is a QGIS plugin to make datasets creation easier for raster and vector data.

Deep Learning Dataset Maker Deep Learning Datasets Maker is a QGIS plugin to make datasets creation easier for raster and vector data. How to use Down

deepbands 25 Dec 15, 2022
GraphGT: Machine Learning Datasets for Graph Generation and Transformation

GraphGT: Machine Learning Datasets for Graph Generation and Transformation Dataset Website | Paper Installation Using pip To install the core environm

y6q9 50 Aug 18, 2022
Cl datasets - PyTorch image dataloaders and utility functions to load datasets for supervised continual learning

Continual learning datasets Introduction This repository contains PyTorch image

berjaoui 5 Aug 28, 2022
A Research-oriented Federated Learning Library and Benchmark Platform for Graph Neural Networks. Accepted to ICLR'2021 - DPML and MLSys'21 - GNNSys workshops.

FedGraphNN: A Federated Learning System and Benchmark for Graph Neural Networks A Research-oriented Federated Learning Library and Benchmark Platform

FedML-AI 175 Dec 1, 2022
An easy way to build PyTorch datasets. Modularly build datasets and automatically cache processed results

EasyDatas An easy way to build PyTorch datasets. Modularly build datasets and automatically cache processed results Installation pip install git+https

Ximing Yang 4 Dec 14, 2021
A data annotation pipeline to generate high-quality, large-scale speech datasets with machine pre-labeling and fully manual auditing.

About This repository provides data and code for the paper: Scalable Data Annotation Pipeline for High-Quality Large Speech Datasets Development (subm

Appen Repos 86 Dec 7, 2022
[Preprint] "Bag of Tricks for Training Deeper Graph Neural Networks A Comprehensive Benchmark Study" by Tianlong Chen*, Kaixiong Zhou*, Keyu Duan, Wenqing Zheng, Peihao Wang, Xia Hu, Zhangyang Wang

Bag of Tricks for Training Deeper Graph Neural Networks: A Comprehensive Benchmark Study Codes for [Preprint] Bag of Tricks for Training Deeper Graph

VITA 101 Dec 29, 2022
image scene graph generation benchmark

Scene Graph Benchmark in PyTorch 1.7 This project is based on maskrcnn-benchmark Highlights Upgrad to pytorch 1.7 Multi-GPU training and inference Bat

Microsoft 303 Dec 27, 2022
Machine Learning From Scratch. Bare bones NumPy implementations of machine learning models and algorithms with a focus on accessibility. Aims to cover everything from linear regression to deep learning.

Machine Learning From Scratch About Python implementations of some of the fundamental Machine Learning models and algorithms from scratch. The purpose

Erik Linder-Norén 21.8k Jan 9, 2023
Vowpal Wabbit is a machine learning system which pushes the frontier of machine learning with techniques such as online, hashing, allreduce, reductions, learning2search, active, and interactive learning.

This is the Vowpal Wabbit fast online learning code. Why Vowpal Wabbit? Vowpal Wabbit is a machine learning system which pushes the frontier of machin

Vowpal Wabbit 8.1k Jan 6, 2023
A non-linear, non-parametric Machine Learning method capable of modeling complex datasets

Fast Symbolic Regression Symbolic Regression is a non-linear, non-parametric Machine Learning method capable of modeling complex data sets. fastsr aim

VAMSHI CHOWDARY 3 Jun 22, 2022
[IJCAI-2021] A benchmark of data-free knowledge distillation from paper "Contrastive Model Inversion for Data-Free Knowledge Distillation"

DataFree A benchmark of data-free knowledge distillation from paper "Contrastive Model Inversion for Data-Free Knowledge Distillation" Authors: Gongfa

ZJU-VIPA 47 Jan 9, 2023
DeepGNN is a framework for training machine learning models on large scale graph data.

DeepGNN Overview DeepGNN is a framework for training machine learning models on large scale graph data. DeepGNN contains all the necessary features in

Microsoft 45 Jan 1, 2023
modelvshuman is a Python library to benchmark the gap between human and machine vision

modelvshuman is a Python library to benchmark the gap between human and machine vision. Using this library, both PyTorch and TensorFlow models can be evaluated on 17 out-of-distribution datasets with high-quality human comparison data.

Bethge Lab 244 Jan 3, 2023
This is the repository for the AAAI 21 paper [Contrastive and Generative Graph Convolutional Networks for Graph-based Semi-Supervised Learning].

CG3 This is the repository for the AAAI 21 paper [Contrastive and Generative Graph Convolutional Networks for Graph-based Semi-Supervised Learning]. R

null 12 Oct 28, 2022
Scripts of Machine Learning Algorithms from Scratch. Implementations of machine learning models and algorithms using nothing but NumPy with a focus on accessibility. Aims to cover everything from basic to advance.

Algo-ScriptML Python implementations of some of the fundamental Machine Learning models and algorithms from scratch. The goal of this project is not t

Algo Phantoms 81 Nov 26, 2022