repo stringlengths 2 99 | file stringlengths 13 225 | code stringlengths 0 18.3M | file_length int64 0 18.3M | avg_line_length float64 0 1.36M | max_line_length int64 0 4.26M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/load_net.py | """
Utility file to select GraphNN model as
selected by the user
"""
from nets.Planetoid_node_classification.gated_gcn_net import GatedGCNNet, GatedGCNNet_pyg, ResGatedGCNNet_pyg
from nets.Planetoid_node_classification.gcn_net import GCNNet, GCNNet_pyg
from nets.Planetoid_node_classification.gat_net import GAT... | 2,570 | 27.566667 | 109 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/graphsage_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
"""
GraphSAGE:
William L. Hamilton, Rex Ying, Jure Leskovec, Inductive Representation Learning on Large Graphs (NeurIPS 2017)
https://cs.stanford.edu/people/jure/pubs/graphsage-nips17.pdf
"""
from layers.graphsage_layer import... | 5,141 | 35.211268 | 122 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/gin_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
from dgl.nn.pytorch.glob import SumPooling, AvgPooling, MaxPooling
"""
GIN: Graph Isomorphism Networks
HOW POWERFUL ARE GRAPH NEURAL NETWORKS? (Keyulu Xu, Weihua Hu, Jure Leskovec and Stefanie Jegelka, ICLR 2019)
https://arxiv.o... | 5,612 | 35.448052 | 113 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/gcn_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
import dgl
import numpy as np
"""
GCN: Graph Convolutional Networks
Thomas N. Kipf, Max Welling, Semi-Supervised Classification with Graph Convolutional Networks (ICLR 2017)
http://arxiv.org/abs/1609.0... | 5,125 | 33.635135 | 110 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/gated_gcn_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
import numpy as np
"""
ResGatedGCN: Residual Gated Graph ConvNets
An Experimental Study of Neural Networks for Variable Graphs (Xavier Bresson and Thomas Laurent, ICLR 2018)
https://arxiv.org/pdf/1711.07553v2.pdf
"""
from layers... | 8,352 | 37.493088 | 122 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/mlp_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl
from layers.mlp_readout_layer import MLPReadout
class MLPNet(nn.Module):
def __init__(self, net_params):
super().__init__()
in_dim_node = net_params['in_dim'] # node_dim (feat is an integer)
hidden_dim = net_... | 3,772 | 27.583333 | 93 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/nets/Planetoid_node_classification/mo_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_scatter import scatter_add
import dgl
import numpy as np
"""
GMM: Gaussian Mixture Model Convolution layer
Geometric Deep Learning on Graphs and Manifolds using Mixture Model CNNs (Federico Monti et al., CVPR 2017)
https://arxiv... | 6,420 | 39.639241 | 121 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/graphsage_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
from dgl.nn.pytorch import SAGEConv
"""
GraphSAGE:
William L. Hamilton, Rex Ying, Jure Leskovec, Inductive Representation Learning on Large Graphs (NeurIPS 2017)
https://cs.stanford.edu/people/jure/pubs/graphsage... | 10,938 | 29.386111 | 114 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/mlp_readout_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
"""
MLP Layer used after graph vector representation
"""
class MLPReadout(nn.Module):
def __init__(self, input_dim, output_dim, L=2): #L=nb_hidden_layers
super().__init__()
list_FC_layers = [ nn.Linear( input_dim//2**l , input... | 1,026 | 26.756757 | 109 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/gated_gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from torch_geometric.typing import OptTensor
from torch_scatter import scatter
from torch_geometric.nn.conv import MessagePassing
"""
ResGatedGCN: Residual Gated Graph ConvNets
An Experimental Study of Neural Networks f... | 10,484 | 35.40625 | 170 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/gat_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from dgl.nn.pytorch import GATConv
"""
GAT: Graph Attention Network
Graph Attention Networks (Veličković et al., ICLR 2018)
https://arxiv.org/abs/1710.10903
"""
class GATLayer(nn.Module):
"""
Parameters
----------
in_dim :... | 10,303 | 29.850299 | 107 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/gin_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
"""
GIN: Graph Isomorphism Networks
HOW POWERFUL ARE GRAPH NEURAL NETWORKS? (Keyulu Xu, Weihua Hu, Jure Leskovec and Stefanie Jegelka, ICLR 2019)
https://arxiv.org/pdf/1810.00826.pdf
"""
class GINLayer(nn.Module):... | 4,598 | 30.9375 | 113 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/gmm_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
import dgl.function as fn
"""
GMM: Gaussian Mixture Model Convolution layer
Geometric Deep Learning on Graphs and Manifolds using Mixture Model CNNs (Federico Monti et al., CVPR 2017)
https://arxiv.org/pdf/1611.084... | 3,680 | 31.289474 | 111 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/gcn_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import dgl.function as fn
from dgl.nn.pytorch import GraphConv
"""
GCN: Graph Convolutional Networks
Thomas N. Kipf, Max Welling, Semi-Supervised Classification with Graph Convolutional Networks (ICLR 2017)
http://arxiv.org/abs/1609.02907
... | 2,561 | 29.86747 | 109 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/ring_gnn_equiv_layer.py | import torch
import torch.nn as nn
import torch.nn.functional as F
"""
Ring-GNN equi 2 to 2 layer file
On the equivalence between graph isomorphism testing and function approximation with GNNs (Chen et al, 2019)
https://arxiv.org/pdf/1905.12560v1.pdf
CODE ADPATED FROM https://github.com/leichen2018/Ri... | 8,076 | 39.385 | 139 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/layers/three_wl_gnn_layers.py | import torch
import torch.nn as nn
import torch.nn.functional as F
"""
Layers used for
3WLGNN
Provably Powerful Graph Networks (Maron et al., 2019)
https://papers.nips.cc/paper/8488-provably-powerful-graph-networks.pdf
CODE adapted from https://github.com/hadarser/ProvablyPowerfulGraphNetwork... | 4,983 | 31.154839 | 108 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/train/train_Planetoid_node_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
from train.metrics import accuracy_TU as accuracy
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, dataset, train_idx):
model.train()
epoch_loss = 0
epoch_... | 3,774 | 30.991525 | 89 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/train/metrics.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.metrics import confusion_matrix
from sklearn.metrics import f1_score
import numpy as np
def MAE(scores, targets):
MAE = F.l1_loss(scores, targets)
MAE = MAE.detach().item()
return MAE
# it is the original one to calculate th... | 2,754 | 31.797619 | 135 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/train/train_ogb_node_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
import dgl
from tqdm import tqdm
from train.metrics import accuracy_SBM as accuracy
from train.metrics import accuracy_ogb
from ogb.nodeproppred import Evaluator
"""
For GCNs
"""
def tr... | 11,004 | 35.440397 | 110 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/train/train_SBMs_node_classification.py | """
Utility functions for training one epoch
and evaluating one epoch
"""
import torch
import torch.nn as nn
import math
import dgl
from train.metrics import accuracy_SBM as accuracy
from train.metrics import accuracy_ogb
"""
For GCNs
"""
def train_epoch_sparse(model, optimizer, device, data_loader, epoc... | 7,186 | 38.489011 | 113 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/utils/cleaner_main.py |
# Clean the main.py file after conversion from notebook.
# Any notebook code is removed from the main.py file.
import subprocess
def cleaner_main(filename):
# file names
file_notebook = filename + '.ipynb'
file_python = filename + '.py'
# convert notebook to python file
print('Convert ' + file_notebook + '... | 3,939 | 37.252427 | 136 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/ogbn.py |
import time
import os
import pickle
import numpy as np
import os.path as osp
import dgl
import torch
from torch_scatter import scatter
from scipy import sparse as sp
import numpy as np
from tqdm import tqdm
from torch_geometric.data import InMemoryDataset
from torch_geometric.data import Data
from scipy.sparse import ... | 22,737 | 38.407279 | 140 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/molecules.py | import torch
import pickle
import torch.utils.data
import time
import os
import numpy as np
import csv
import dgl
from scipy import sparse as sp
import numpy as np
from torch_geometric.data import Data
from torch_geometric.data import InMemoryDataset
from tqdm import tqdm
# *NOTE
# The dataset pickle and index file... | 14,989 | 39.404313 | 130 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/data.py | """
File to load dataset based on user control from main file
"""
from data.molecules import *
from data.SBMs import SBMsDataset, SBMsDatasetpyg
from data.planetoids import PlanetoidDataset
from data.ogbn import ogbnDatasetpyg
def LoadData(DATASET_NAME, use_node_embedding = False, framework = 'dgl'):
"""
... | 1,193 | 33.114286 | 104 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/node2vec_citeseer.py | import argparse
import torch
from torch_geometric.nn import Node2Vec
from torch_geometric.utils import to_undirected
import torch_geometric as pyg
from ogb.nodeproppred import PygNodePropPredDataset
import os.path as osp
def save_embedding(model):
torch.save(model.embedding.weight.data.cpu(), 'data/planetoid/embe... | 2,380 | 36.793651 | 89 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/SBMs.py |
import time
import os
import pickle
import numpy as np
import os.path as osp
import dgl
import torch
from ogb.utils.url import decide_download, download_url, extract_zip
from scipy import sparse as sp
import numpy as np
from tqdm import tqdm
from torch_geometric.data import InMemoryDataset
from torch_geometric.data im... | 14,591 | 37.70557 | 127 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/node2vec_proteins.py | import argparse
import torch
from torch_geometric.nn import Node2Vec
from ogb.nodeproppred import PygNodePropPredDataset
def save_embedding(model):
torch.save(model.embedding.weight.data.cpu(), 'ogbn/embedding_proteins.pt')
def main():
parser = argparse.ArgumentParser(description='OGBN-Proteins (Node2Vec)... | 2,096 | 34.542373 | 79 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/CSL.py | import numpy as np, time, pickle, random, csv
import torch
from torch.utils.data import DataLoader, Dataset
import os
import pickle
import numpy as np
import dgl
from sklearn.model_selection import StratifiedKFold, train_test_split
random.seed(42)
from scipy import sparse as sp
class DGLFormDataset(torch.utils.d... | 13,727 | 40.101796 | 128 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/node2vec-products.py | import argparse
import torch
from torch_geometric.nn import Node2Vec
from ogb.nodeproppred import PygNodePropPredDataset
def save_embedding(model):
torch.save(model.embedding.weight.data.cpu(), 'ogbn/embedding_products.pt')
def main():
parser = argparse.ArgumentParser(description='OGBN-Products (Node2Vec)... | 2,133 | 35.169492 | 79 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/planetoids.py | import torch
import pickle
import torch.utils.data
import time
import os
import numpy as np
from torch_geometric.utils import get_laplacian
import csv
from scipy import sparse as sp
import dgl
from dgl.data import TUDataset
from dgl.data import LegacyTUDataset
import torch_geometric as pyg
from scipy.sparse import csr_... | 13,158 | 43.60678 | 131 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/node2vec_arxiv.py | import argparse
import torch
from torch_geometric.nn import Node2Vec
from torch_geometric.utils import to_undirected
from ogb.nodeproppred import PygNodePropPredDataset
import os.path as osp
def save_embedding(model):
torch.save(model.embedding.weight.data.cpu(), 'ogbn/embedding_arxiv.pt')
def main():
pars... | 2,306 | 36.819672 | 81 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/data/molecules/prepare_molecules.py | #!/usr/bin/env python
# coding: utf-8
# # Notebook for preparing and saving MOLECULAR graphs
# In[1]:
import numpy as np
import torch
import pickle
import time
import os
from IPython import get_ipython
#get_ipython().run_line_magic('matplotlib', 'inline')
import matplotlib.pyplot as plt
# In[2]:
print(torch.__v... | 2,951 | 17.110429 | 116 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/out/log2csv-planetoid.py | import os
import re
import numpy as np
import csv
def write2csv(path):
# path='Planetoid_node_classification/results/result_GAT_pyg_Citeseer_GPU0_23h12m32s_on_Oct_28_2020.txt'
csv_file=open('results.csv','w',encoding='gbk',newline='')
csv_writer=csv.writer(csv_file)
csv_writer.writerow(['data','model',... | 4,018 | 45.732558 | 189 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/out/log2csv-sbm.py | import os
import re
import numpy as np
import csv
def write2csv(path):
# path='Planetoid_node_classification/results/result_GAT_pyg_Citeseer_GPU0_23h12m32s_on_Oct_28_2020.txt'
csv_file=open('results.csv','w',encoding='gbk',newline='')
csv_writer=csv.writer(csv_file)
csv_writer.writerow(['data','model',... | 3,972 | 45.197674 | 189 | py |
benchmarking-gnns-pyg | benchmarking-gnns-pyg-master/out/log2csv-ogb.py | import os
import re
import numpy as np
import csv
def write2csv(path):
# path='Planetoid_node_classification/results/result_GAT_pyg_Citeseer_GPU0_23h12m32s_on_Oct_28_2020.txt'
csv_file=open('results.csv','w',encoding='gbk',newline='')
csv_writer=csv.writer(csv_file)
csv_writer.writerow(['data','model',... | 4,751 | 49.021053 | 203 | py |
SleePyCo | SleePyCo-main/train_mtcl.py | import os
import json
import argparse
import warnings
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from utils import *
from loader import EEGDataLoader
from models.main_model import MainModel
class OneFoldTrainer:
def __init__(self, args, fold, config):
... | 8,872 | 40.853774 | 170 | py |
SleePyCo | SleePyCo-main/test.py | import os
import json
import argparse
import warnings
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from utils import *
from loader import EEGDataLoader
from train_mtcl import OneFoldTrainer
from models.main_model import MainModel
class OneFoldEvaluator(OneFoldTrainer):
def __init__... | 3,233 | 34.933333 | 169 | py |
SleePyCo | SleePyCo-main/train_crl.py | import os
import json
import argparse
import warnings
import torch
import torch.optim as optim
from torch.utils.data import DataLoader
from utils import *
from loss import SupConLoss
from loader import EEGDataLoader
from models.main_model import MainModel
class OneFoldTrainer:
def __init__(self, args, fold, con... | 5,454 | 36.62069 | 169 | py |
SleePyCo | SleePyCo-main/transform.py | import torch
import random
import numpy as np
from scipy import signal
from scipy.ndimage.interpolation import shift
class TwoTransform:
def __init__(self, transform):
self.transform = transform
def __call__(self, x):
return [self.transform(x), self.transform(x)]
class Compose:
de... | 4,204 | 26.48366 | 144 | py |
SleePyCo | SleePyCo-main/loss.py | import torch
import torch.nn as nn
class SupConLoss(nn.Module):
"""Supervised Contrastive Learning: https://arxiv.org/pdf/2004.11362.pdf.
It also supports the unsupervised contrastive loss in SimCLR"""
def __init__(self, temperature=0.07, contrast_mode='all',
base_temperature=0.07):
... | 3,650 | 38.684783 | 80 | py |
SleePyCo | SleePyCo-main/utils.py | import os
import sys
import math
import time
import torch
import random
import numpy as np
import sklearn.metrics as skmet
from terminaltables import SingleTable
from termcolor import colored
_, term_width = os.popen('stty size', 'r').read().split()
term_width = int(term_width)
TOTAL_BAR_LENGTH = 25.
last_time = tim... | 8,844 | 34.239044 | 129 | py |
SleePyCo | SleePyCo-main/loader.py | import os
import glob
import torch
import numpy as np
from transform import *
from torch.utils.data import Dataset
class EEGDataLoader(Dataset):
def __init__(self, config, fold, set='train'):
self.set = set
self.fold = fold
self.sr = 100
self.dset_cfg = config['dataset']... | 4,913 | 39.278689 | 117 | py |
SleePyCo | SleePyCo-main/models/iitnet.py | import torch.nn as nn
def conv3(in_planes, out_planes, stride=1):
return nn.Conv1d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__in... | 4,111 | 31.896 | 96 | py |
SleePyCo | SleePyCo-main/models/xsleepnet.py | import torch.nn as nn
class XSleepNetFeature(nn.Module):
def __init__(self, config):
super(XSleepNetFeature, self).__init__()
self.training_mode = config['training_params']['mode']
# architecture
self.conv1 = self.make_layers(1, 16)
self.conv2 = self.make_layers(1... | 2,631 | 32.74359 | 86 | py |
SleePyCo | SleePyCo-main/models/utils.py | import torch.utils.data
from torch.nn import functional as F
import math
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _single, _pair, _triple
class _ConvNd(Module):
def __ini... | 7,340 | 37.434555 | 128 | py |
SleePyCo | SleePyCo-main/models/main_model.py | import torch.nn as nn
import torch.nn.functional as F
from .sleepyco import SleePyCoBackbone
from .xsleepnet import XSleepNetFeature
from .iitnet import IITNetBackbone
from .utime import UTimeEncoder
from .deepsleepnet import DeepSleepNetFeature
from .classifiers import get_classifier
last_chn_dict = {
'SleePyC... | 3,898 | 36.490385 | 133 | py |
SleePyCo | SleePyCo-main/models/classifiers.py | import math
import torch
import torch.nn as nn
feature_len_dict = {
'SleePyCo': [
[5, 24, 120],
[10, 48, 240],
[15, 72, 360],
[20, 96, 480],
[24, 120, 600],
[29, 144, 720],
[34, 168, 840],
[39, 192, 960],
[44, 216, 1080],
[48, 240, 12... | 8,588 | 30.811111 | 146 | py |
SleePyCo | SleePyCo-main/models/sleepyco.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class SleePyCoBackbone(nn.Module):
def __init__(self, config):
super(SleePyCoBackbone, self).__init__()
self.training_mode = config['training_params']['mode']
# architecture
self.init_layer = self.make_layers... | 6,271 | 37.012121 | 154 | py |
SleePyCo | SleePyCo-main/models/deepsleepnet.py | import torch
import torch.nn as nn
from .utils import Conv1d, MaxPool1d
class DeepSleepNetFeature(nn.Module):
def __init__(self, config):
super(DeepSleepNetFeature, self).__init__()
self.chn = 64
# architecture
self.dropout = nn.Dropout(p=0.5)
self.path1 = nn.Sequential(C... | 3,855 | 44.904762 | 100 | py |
SleePyCo | SleePyCo-main/models/utime.py | import torch
import torch.nn as nn
from .utils import Conv1d
class ConvUnit(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation):
super(ConvUnit, self).__init__()
self.conv = Conv1d(
in_channels=in_channels,
out_channels... | 4,199 | 37.181818 | 119 | py |
SleePyCo | SleePyCo-main/dset/Sleep-EDF-2013/download_sleep-edf-2013.py | import os
os.makedirs('./edf', exist_ok=True)
os.system('wget https://www.physionet.org/physiobank/database/sleep-edfx/sleep-cassette/SC4001E0-PSG.edf -P ./edf')
os.system('wget https://www.physionet.org/physiobank/database/sleep-edfx/sleep-cassette/SC4001EC-Hypnogram.edf -P ./edf')
os.system('wget https://www.physio... | 9,329 | 112.780488 | 121 | py |
SleePyCo | SleePyCo-main/dset/Sleep-EDF-2013/prepare_sleep-edf-2013.py | import os
import glob
import ntpath
import logging
import argparse
import pyedflib
import numpy as np
# Label values
W = 0
N1 = 1
N2 = 2
N3 = 3
REM = 4
MOVE = 5
UNK = 6
stage_dict = {
"W": W,
"N1": N1,
"N2": N2,
"N3": N3,
"REM": REM,
"MOVE": MOVE,
"UNK": UNK
}
# Have to manually define ... | 7,734 | 35.314554 | 102 | py |
SleePyCo | SleePyCo-main/dset/Sleep-EDF-2018/prepare_sleep-edf-2018.py | import os
import glob
import ntpath
import logging
import argparse
import pyedflib
import numpy as np
# Label values
W = 0
N1 = 1
N2 = 2
N3 = 3
REM = 4
MOVE = 5
UNK = 6
stage_dict = {
"W": W,
"N1": N1,
"N2": N2,
"N3": N3,
"REM": REM,
"MOVE": MOVE,
"UNK": UNK
}
# Have to manually define ... | 7,734 | 35.314554 | 102 | py |
SleePyCo | SleePyCo-main/dset/Sleep-EDF-2018/download_sleep-edf-2018.py | import os
os.makedirs('./edf', exist_ok=True)
os.system('wget https://www.physionet.org/physiobank/database/sleep-edfx/sleep-cassette/SC4001E0-PSG.edf -P ./edf')
os.system('wget https://www.physionet.org/physiobank/database/sleep-edfx/sleep-cassette/SC4001EC-Hypnogram.edf -P ./edf')
os.system('wget https://www.physion... | 36,460 | 116.996764 | 121 | py |
SASA | SASA-main/setup.py | import os
import subprocess
from setuptools import find_packages, setup
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
def get_git_commit_number():
if not os.path.exists('.git'):
return '0000000'
cmd_out = subprocess.run(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE)
... | 3,616 | 31.294643 | 95 | py |
SASA | SASA-main/tools/test.py | import argparse
import datetime
import glob
import os
import re
import time
from pathlib import Path
import numpy as np
import torch
from tensorboardX import SummaryWriter
from eval_utils import eval_utils
from pcdet.config import cfg, cfg_from_list, cfg_from_yaml_file, log_config_to_file
from pcdet.datasets import b... | 9,291 | 40.855856 | 120 | py |
SASA | SASA-main/tools/demo.py | import argparse
import glob
from pathlib import Path
import mayavi.mlab as mlab
import numpy as np
import torch
from pcdet.config import cfg, cfg_from_yaml_file
from pcdet.datasets import DatasetTemplate
from pcdet.models import build_network, load_data_to_gpu
from pcdet.utils import common_utils
from visual_utils im... | 3,575 | 33.384615 | 118 | py |
SASA | SASA-main/tools/train.py | import argparse
import datetime
import glob
import os
from pathlib import Path
from test import repeat_eval_ckpt
import torch
import torch.distributed as dist
import torch.nn as nn
from tensorboardX import SummaryWriter
from pcdet.config import cfg, cfg_from_list, cfg_from_yaml_file, log_config_to_file
from pcdet.dat... | 8,839 | 42.762376 | 118 | py |
SASA | SASA-main/tools/eval_utils/eval_utils.py | import pickle
import time
import numpy as np
import torch
import tqdm
from pcdet.models import load_data_to_gpu
from pcdet.utils import common_utils
def statistics_info(cfg, ret_dict, metric, disp_dict):
for key in metric.keys():
if key in ret_dict:
metric[key] += ret_dict[key]
min_thres... | 4,772 | 34.887218 | 131 | py |
SASA | SASA-main/tools/train_utils/train_utils.py | import glob
import os
import torch
import tqdm
from torch.nn.utils import clip_grad_norm_
def train_one_epoch(model, optimizer, train_loader, model_func, lr_scheduler, accumulated_iter, optim_cfg,
rank, tbar, total_it_each_epoch, dataloader_iter, tb_log=None, leave_pbar=False):
if total_it_ea... | 5,667 | 37.297297 | 117 | py |
SASA | SASA-main/tools/train_utils/optimization/fastai_optim.py | # This file is modified from https://github.com/traveller59/second.pytorch
from collections import Iterable
import torch
from torch import nn
from torch._utils import _unflatten_dense_tensors
from torch.nn.utils import parameters_to_vector
bn_types = (nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d, nn.SyncBatchNorm)... | 10,477 | 38.992366 | 117 | py |
SASA | SASA-main/tools/train_utils/optimization/learning_schedules_fastai.py | # This file is modified from https://github.com/traveller59/second.pytorch
import math
from functools import partial
import numpy as np
import torch.optim.lr_scheduler as lr_sched
from .fastai_optim import OptimWrapper
class LRSchedulerStep(object):
def __init__(self, fai_optimizer: OptimWrapper, total_step, l... | 4,169 | 35.26087 | 118 | py |
SASA | SASA-main/tools/train_utils/optimization/__init__.py | from functools import partial
import torch.nn as nn
import torch.optim as optim
import torch.optim.lr_scheduler as lr_sched
from .fastai_optim import OptimWrapper
from .learning_schedules_fastai import CosineWarmupLR, OneCycle
def build_optimizer(model, optim_cfg):
if optim_cfg.OPTIMIZER == 'sgd':
optim... | 2,289 | 35.935484 | 113 | py |
SASA | SASA-main/tools/visual_utils/visualize_utils.py | import mayavi.mlab as mlab
import numpy as np
import torch
box_colormap = [
[1, 1, 1],
[0, 1, 0],
[0, 1, 1],
[1, 1, 0],
]
def check_numpy_to_torch(x):
if isinstance(x, np.ndarray):
return torch.from_numpy(x).float(), True
return x, False
def rotate_points_along_z(points, angle):
... | 8,540 | 38.541667 | 121 | py |
SASA | SASA-main/pcdet/config.py | from pathlib import Path
import yaml
from easydict import EasyDict
def log_config_to_file(cfg, pre='cfg', logger=None):
for key, val in cfg.items():
if isinstance(cfg[key], EasyDict):
logger.info('\n%s.%s = edict()' % (pre, key))
log_config_to_file(cfg[key], pre=pre + '.' + key, l... | 2,750 | 30.988372 | 94 | py |
SASA | SASA-main/pcdet/__init__.py | import subprocess
from pathlib import Path
from .version import __version__
__all__ = [
'__version__'
]
def get_git_commit_number():
if not (Path(__file__).parent / '../.git').exists():
return '0000000'
cmd_out = subprocess.run(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE)
git_commi... | 535 | 20.44 | 82 | py |
SASA | SASA-main/pcdet/models/__init__.py | from collections import namedtuple
import numpy as np
import torch
from .detectors import build_detector
def build_network(model_cfg, num_class, dataset):
model = build_detector(
model_cfg=model_cfg, num_class=num_class, dataset=dataset
)
return model
def load_data_to_gpu(batch_dict):
for ... | 1,074 | 25.219512 | 77 | py |
SASA | SASA-main/pcdet/models/detectors/point_rcnn.py | from .detector3d_template import Detector3DTemplate
class PointRCNN(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=num_class, dataset=dataset)
self.module_list = self.build_networks()
def forward(self, batch_dict):
... | 999 | 31.258065 | 83 | py |
SASA | SASA-main/pcdet/models/detectors/pointpillar.py | from .detector3d_template import Detector3DTemplate
class PointPillar(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=num_class, dataset=dataset)
self.module_list = self.build_networks()
def forward(self, batch_dict):
... | 1,018 | 28.114286 | 83 | py |
SASA | SASA-main/pcdet/models/detectors/second_net.py | from .detector3d_template import Detector3DTemplate
class SECONDNet(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=num_class, dataset=dataset)
self.module_list = self.build_networks()
def forward(self, batch_dict):
... | 1,016 | 28.057143 | 83 | py |
SASA | SASA-main/pcdet/models/detectors/detector3d_template.py | import os
import torch
import torch.nn as nn
from ...ops.iou3d_nms import iou3d_nms_utils
from .. import backbones_2d, backbones_3d, dense_heads, roi_heads
from ..backbones_2d import map_to_bev
from ..backbones_3d import pfe, vfe
from ..model_utils import model_nms_utils
class Detector3DTemplate(nn.Module):
def... | 17,009 | 44.119363 | 111 | py |
SASA | SASA-main/pcdet/models/detectors/PartA2_net.py | from .detector3d_template import Detector3DTemplate
class PartA2Net(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=num_class, dataset=dataset)
self.module_list = self.build_networks()
def forward(self, batch_dict):
... | 1,072 | 32.53125 | 83 | py |
SASA | SASA-main/pcdet/models/detectors/pv_rcnn.py | from .detector3d_template import Detector3DTemplate
class PVRCNN(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=num_class, dataset=dataset)
self.module_list = self.build_networks()
def forward(self, batch_dict):
... | 1,069 | 32.4375 | 83 | py |
SASA | SASA-main/pcdet/models/detectors/__init__.py | from .detector3d_template import Detector3DTemplate
from .PartA2_net import PartA2Net
from .point_rcnn import PointRCNN
from .pointpillar import PointPillar
from .pv_rcnn import PVRCNN
from .second_net import SECONDNet
from .point_3dssd import Point3DSSD
__all__ = {
'Detector3DTemplate': Detector3DTemplate,
'S... | 658 | 24.346154 | 65 | py |
SASA | SASA-main/pcdet/models/detectors/point_3dssd.py | import torch
from .detector3d_template import Detector3DTemplate
from ...ops.iou3d_nms import iou3d_nms_utils
from ...ops.roiaware_pool3d import roiaware_pool3d_utils
class Point3DSSD(Detector3DTemplate):
def __init__(self, model_cfg, num_class, dataset):
super().__init__(model_cfg=model_cfg, num_class=n... | 10,022 | 47.892683 | 134 | py |
SASA | SASA-main/pcdet/models/backbones_3d/spconv_unet.py | from functools import partial
import spconv
import torch
import torch.nn as nn
from ...utils import common_utils
from .spconv_backbone import post_act_block
class SparseBasicBlock(spconv.SparseModule):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None, indice_key=None, norm_fn=No... | 8,445 | 38.839623 | 117 | py |
SASA | SASA-main/pcdet/models/backbones_3d/spconv_backbone.py | from functools import partial
import spconv
import torch.nn as nn
def post_act_block(in_channels, out_channels, kernel_size, indice_key=None, stride=1, padding=0,
conv_type='subm', norm_fn=None):
if conv_type == 'subm':
conv = spconv.SubMConv3d(in_channels, out_channels, kernel_size, ... | 9,376 | 34.790076 | 118 | py |
SASA | SASA-main/pcdet/models/backbones_3d/__init__.py | from .pointnet2_backbone import PointNet2Backbone, PointNet2MSG, PointNet2FSMSG
from .spconv_backbone import VoxelBackBone8x, VoxelResBackBone8x
from .spconv_unet import UNetV2
__all__ = {
'VoxelBackBone8x': VoxelBackBone8x,
'UNetV2': UNetV2,
'PointNet2Backbone': PointNet2Backbone,
'PointNet2MSG': Poin... | 416 | 31.076923 | 79 | py |
SASA | SASA-main/pcdet/models/backbones_3d/pointnet2_backbone.py | import torch
import torch.nn as nn
from ...ops.pointnet2.pointnet2_batch import pointnet2_modules
from ...ops.pointnet2.pointnet2_stack import pointnet2_modules as pointnet2_modules_stack
from ...ops.pointnet2.pointnet2_stack import pointnet2_utils as pointnet2_utils_stack
class PointNet2MSG(nn.Module):
def __in... | 15,273 | 41.077135 | 119 | py |
SASA | SASA-main/pcdet/models/backbones_3d/pfe/__init__.py | from .voxel_set_abstraction import VoxelSetAbstraction
__all__ = {
'VoxelSetAbstraction': VoxelSetAbstraction
}
| 117 | 18.666667 | 54 | py |
SASA | SASA-main/pcdet/models/backbones_3d/pfe/voxel_set_abstraction.py | import torch
import torch.nn as nn
from ....ops.pointnet2.pointnet2_stack import pointnet2_modules as pointnet2_stack_modules
from ....ops.pointnet2.pointnet2_stack import pointnet2_utils as pointnet2_stack_utils
from ....utils import common_utils
def bilinear_interpolate_torch(im, x, y):
"""
Args:
i... | 9,638 | 39.1625 | 121 | py |
SASA | SASA-main/pcdet/models/backbones_3d/vfe/vfe_template.py | import torch.nn as nn
class VFETemplate(nn.Module):
def __init__(self, model_cfg, **kwargs):
super().__init__()
self.model_cfg = model_cfg
def get_output_feature_dim(self):
raise NotImplementedError
def forward(self, **kwargs):
"""
Args:
**kwargs:
... | 470 | 19.478261 | 45 | py |
SASA | SASA-main/pcdet/models/backbones_3d/vfe/mean_vfe.py | import torch
from .vfe_template import VFETemplate
class MeanVFE(VFETemplate):
def __init__(self, model_cfg, num_point_features, **kwargs):
super().__init__(model_cfg=model_cfg)
self.num_point_features = num_point_features
def get_output_feature_dim(self):
return self.num_point_featu... | 1,038 | 31.46875 | 99 | py |
SASA | SASA-main/pcdet/models/backbones_3d/vfe/pillar_vfe.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .vfe_template import VFETemplate
class PFNLayer(nn.Module):
def __init__(self,
in_channels,
out_channels,
use_norm=True,
last_layer=False):
super().__init__()
... | 5,089 | 40.048387 | 137 | py |
SASA | SASA-main/pcdet/models/backbones_3d/vfe/__init__.py | from .mean_vfe import MeanVFE
from .pillar_vfe import PillarVFE
from .vfe_template import VFETemplate
__all__ = {
'VFETemplate': VFETemplate,
'MeanVFE': MeanVFE,
'PillarVFE': PillarVFE
}
| 200 | 19.1 | 37 | py |
SASA | SASA-main/pcdet/models/dense_heads/anchor_head_single.py | import numpy as np
import torch.nn as nn
from .anchor_head_template import AnchorHeadTemplate
class AnchorHeadSingle(AnchorHeadTemplate):
def __init__(self, model_cfg, input_channels, num_class, class_names, grid_size, point_cloud_range,
predict_boxes_when_training=True, **kwargs):
super... | 2,928 | 37.539474 | 136 | py |
SASA | SASA-main/pcdet/models/dense_heads/point_head_template.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from ...ops.roiaware_pool3d import roiaware_pool3d_utils
from ...utils import common_utils, loss_utils
class PointHeadTemplate(nn.Module):
def __init__(self, model_cfg, num_class):
super().__init__()
self.model_cfg = model_cfg
... | 9,475 | 45 | 119 | py |
SASA | SASA-main/pcdet/models/dense_heads/anchor_head_template.py | import numpy as np
import torch
import torch.nn as nn
from ...utils import box_coder_utils, common_utils, loss_utils
from .target_assigner.anchor_generator import AnchorGenerator
from .target_assigner.atss_target_assigner import ATSSTargetAssigner
from .target_assigner.axis_aligned_target_assigner import AxisAlignedTa... | 12,364 | 43.800725 | 118 | py |
SASA | SASA-main/pcdet/models/dense_heads/anchor_head_multi.py | import numpy as np
import torch
import torch.nn as nn
from ..backbones_2d import BaseBEVBackbone
from .anchor_head_template import AnchorHeadTemplate
class SingleHead(BaseBEVBackbone):
def __init__(self, model_cfg, input_channels, num_class, num_anchors_per_location, code_size, rpn_head_cfg=None,
... | 17,041 | 44.566845 | 117 | py |
SASA | SASA-main/pcdet/models/dense_heads/point_head_box.py | import torch
from ...utils import box_coder_utils, box_utils
from ...utils.loss_utils import PointSASALoss
from .point_head_template import PointHeadTemplate
class PointHeadBox(PointHeadTemplate):
"""
A simple point-based segmentation head, which are used for PointRCNN.
Reference Paper: https://arxiv.org... | 6,616 | 41.146497 | 106 | py |
SASA | SASA-main/pcdet/models/dense_heads/point_head_simple.py | import torch
from ...utils import box_utils
from .point_head_template import PointHeadTemplate
class PointHeadSimple(PointHeadTemplate):
"""
A simple point-based segmentation head, which are used for PV-RCNN keypoint segmentaion.
Reference Paper: https://arxiv.org/abs/1912.13192
PV-RCNN: Point-Voxel ... | 3,568 | 37.793478 | 106 | py |
SASA | SASA-main/pcdet/models/dense_heads/__init__.py | from .anchor_head_multi import AnchorHeadMulti
from .anchor_head_single import AnchorHeadSingle
from .anchor_head_template import AnchorHeadTemplate
from .point_head_box import PointHeadBox
from .point_head_vote import PointHeadVote
from .point_head_simple import PointHeadSimple
from .point_intra_part_head import Point... | 651 | 35.222222 | 59 | py |
SASA | SASA-main/pcdet/models/dense_heads/point_head_vote.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from ...ops.iou3d_nms import iou3d_nms_utils
from ...ops.roiaware_pool3d import roiaware_pool3d_utils
from ...ops.pointnet2.pointnet2_batch import pointnet2_modules
from ...utils import box_coder_utils, box_utils, common_utils, loss_... | 37,917 | 45.754624 | 127 | py |
SASA | SASA-main/pcdet/models/dense_heads/point_intra_part_head.py | import torch
from ...utils import box_coder_utils, box_utils
from .point_head_template import PointHeadTemplate
class PointIntraPartOffsetHead(PointHeadTemplate):
"""
Point-based head for predicting the intra-object part locations.
Reference Paper: https://arxiv.org/abs/1907.03670
From Points to Part... | 5,568 | 42.507813 | 107 | py |
SASA | SASA-main/pcdet/models/dense_heads/target_assigner/anchor_generator.py | import torch
class AnchorGenerator(object):
def __init__(self, anchor_range, anchor_generator_config):
super().__init__()
self.anchor_generator_cfg = anchor_generator_config
self.anchor_range = anchor_range
self.anchor_sizes = [config['anchor_sizes'] for config in anchor_generator_... | 3,990 | 48.8875 | 122 | py |
SASA | SASA-main/pcdet/models/dense_heads/target_assigner/axis_aligned_target_assigner.py | import numpy as np
import torch
from ....ops.iou3d_nms import iou3d_nms_utils
from ....utils import box_utils
class AxisAlignedTargetAssigner(object):
def __init__(self, model_cfg, class_names, box_coder, match_height=False):
super().__init__()
anchor_generator_cfg = model_cfg.ANCHOR_GENERATOR_C... | 9,874 | 45.14486 | 118 | py |
SASA | SASA-main/pcdet/models/dense_heads/target_assigner/atss_target_assigner.py | import torch
from ....ops.iou3d_nms import iou3d_nms_utils
from ....utils import common_utils
class ATSSTargetAssigner(object):
"""
Reference: https://arxiv.org/abs/1912.02424
"""
def __init__(self, topk, box_coder, match_height=False):
self.topk = topk
self.box_coder = box_coder
... | 6,050 | 41.612676 | 117 | py |
SASA | SASA-main/pcdet/models/roi_heads/roi_head_template.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from ...utils import box_coder_utils, common_utils, loss_utils
from ..model_utils.model_nms_utils import class_agnostic_nms
from .target_assigner.proposal_target_layer import ProposalTargetLayer
class RoIHeadTemplate(nn.Module):
... | 11,451 | 43.216216 | 128 | py |
SASA | SASA-main/pcdet/models/roi_heads/partA2_head.py | import numpy as np
import spconv
import torch
import torch.nn as nn
from ...ops.roiaware_pool3d import roiaware_pool3d_utils
from .roi_head_template import RoIHeadTemplate
class PartA2FCHead(RoIHeadTemplate):
def __init__(self, input_channels, model_cfg, num_class=1):
super().__init__(num_class=num_class... | 10,039 | 43.622222 | 120 | py |
SASA | SASA-main/pcdet/models/roi_heads/__init__.py | from .partA2_head import PartA2FCHead
from .pointrcnn_head import PointRCNNHead
from .pvrcnn_head import PVRCNNHead
from .roi_head_template import RoIHeadTemplate
__all__ = {
'RoIHeadTemplate': RoIHeadTemplate,
'PartA2FCHead': PartA2FCHead,
'PVRCNNHead': PVRCNNHead,
'PointRCNNHead': PointRCNNHead
}
| 317 | 25.5 | 46 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.