repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
neurophox | neurophox-master/neurophox/tensorflow/layers.py | from typing import Optional, List, Dict, Union, Callable
import tensorflow as tf
from tensorflow.keras.layers import Activation
import numpy as np
from .generic import TransformerLayer, MeshLayer, CompoundTransformerLayer, PermutationLayer
from ..meshmodel import RectangularMeshModel, TriangularMeshModel, PermutingRe... | 13,812 | 48.332143 | 146 | py |
CorrMNN | CorrMNN-master/deep_CCA_model.py | import math
from keras.layers import Dense
from keras.layers import merge as Merge
from keras.models import Sequential
from keras.optimizers import RMSprop, SGD
from keras.regularizers import l2
from keras import backend as K
import tensorflow as tf
def my_init_sigmoid(shape, dtype=None):
rnd = K.random_uniform(
... | 8,202 | 43.102151 | 129 | py |
simple_shot | simple_shot-master/src/test_inatural.py | import logging
import os
import random
import shutil
import time
import warnings
import collections
import pickle
import numpy as np
import torch
import torch.backends.cudnn as cudnn
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.u... | 21,383 | 38.821229 | 141 | py |
simple_shot | simple_shot-master/src/train.py | import logging
import os
import random
import shutil
import time
import warnings
import collections
import pickle
import numpy as np
import torch
import torch.backends.cudnn as cudnn
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.u... | 22,149 | 38.90991 | 161 | py |
simple_shot | simple_shot-master/src/models/ResNet.py | import torch.nn as nn
__all__ = ['resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152']
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=Fal... | 6,003 | 28.431373 | 106 | py |
simple_shot | simple_shot-master/src/models/MobileNet.py | '''MobileNet in PyTorch.
See the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications"
for more details.
'''
import torch.nn as nn
import torch.nn.functional as F
__all__ = ['MobileNet']
class Block(nn.Module):
'''Depthwise conv + Pointwise conv'''
def __init__(self, in... | 2,340 | 33.426471 | 111 | py |
simple_shot | simple_shot-master/src/models/ProtoNet.py | import torch.nn as nn
import torch
import torch.nn.functional as F
def get_metric(metric_type):
METRICS = {
'cosine': lambda gallery, query: 1. - F.cosine_similarity(query[:, None, :], gallery[None, :, :], dim=2),
'euclidean': lambda gallery, query: ((query[:, None, :] - gallery[None, :, :]) ** 2)... | 1,501 | 38.526316 | 120 | py |
simple_shot | simple_shot-master/src/models/DenseNet.py | from collections import OrderedDict
import torch
import torch.nn as nn
import torch.nn.functional as F
__all__ = ['densenet121', 'densenet169', 'densenet201', 'densenet161']
class _DenseLayer(nn.Sequential):
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
super(_DenseLayer, self... | 6,239 | 39.519481 | 107 | py |
simple_shot | simple_shot-master/src/models/Conv4.py | from torch import nn
__all__ = ['Conv4']
def conv_block(in_channels: int, out_channels: int) -> nn.Module:
return nn.Sequential(
nn.Conv2d(in_channels, out_channels, 3, padding=1),
nn.BatchNorm2d(out_channels),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
class Conv4(n... | 1,131 | 24.727273 | 65 | py |
simple_shot | simple_shot-master/src/models/WideResNet.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
from torch.autograd import Variable
def conv3x3(in_planes, out_planes, stride=1):
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=True)
def conv_init(m):
c... | 3,905 | 33.263158 | 98 | py |
simple_shot | simple_shot-master/src/datasets/sampler.py | import numpy as np
import torch
from torch.utils.data import Sampler
__all__ = ['CategoriesSampler']
class CategoriesSampler(Sampler):
def __init__(self, label, n_iter, n_way, n_shot, n_query):
self.n_iter = n_iter
self.n_way = n_way
self.n_shot = n_shot
self.n_query = n_query
... | 1,183 | 27.878049 | 82 | py |
simple_shot | simple_shot-master/src/datasets/transform.py | import torchvision.transforms as transforms
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
def without_augment(size=84, enlarge=False):
if enlarge:
resize = int(size*256./224.)
else:
resize = size
return transforms.Co... | 1,023 | 31 | 60 | py |
NoRClassifier | NoRClassifier-main/GMVAE/GMVAE.py | '''
Gaussian Mixture Variational Autoencoder
'''
import os
import sys
import numpy as np
from tensorboardX import SummaryWriter
from torch.autograd import Variable
from LossFunctions import *
from InferenceNet import *
from GenerativeNet import *
class GMVAE:
def __init__(self, args, seq2seq=False):
... | 18,874 | 35.650485 | 119 | py |
NoRClassifier | NoRClassifier-main/GMVAE/InferenceNet.py | import torch
from torch import nn
# Inference Network
class InferenceNet(nn.Module):
def __init__(self, x_dim, z_dim, w_dim, K, hidden_dim, dropout, layers=3):
super(InferenceNet, self).__init__()
# For sampling in forward
self.z_dim = z_dim
self.w_dim = w_dim
# self.activation = nn.ReLU()
self.activati... | 5,993 | 25.878924 | 80 | py |
NoRClassifier | NoRClassifier-main/GMVAE/LossFunctions.py | '''
Loss functions of the ELBO
'''
import torch
def reconstruction_loss(sigma, x_batch, x_recons_mean):
loss = 0.5 / sigma * torch.sum(torch.pow((x_recons_mean - x_batch), 2), dim=1)
return -torch.mean(loss)
def cond_prior_loss(z_x, z_x_mean, z_x_var, z_x_logvar, K, z_wy_mean_stack, z_wy_var_stack, z_wy_logv... | 1,421 | 27.44 | 120 | py |
NoRClassifier | NoRClassifier-main/GMVAE/GenerativeNet.py | import torch
from torch import nn
# Generative Network
class GenerativeNet(nn.Module):
def __init__(self, x_dim, z_dim, w_dim, K, hidden_dim, dropout, use_cuda, sigma, layers=3):
super(GenerativeNet, self).__init__()
self.K = K
# For sampling in forward
self.w_dim = w_dim
self.z_dim = z_dim
# self.acti... | 4,464 | 26.22561 | 92 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/dataloader.py | import csv
import os
import config
import cv2
import numpy as np
import torch
import torch.utils.data as data
import torchvision
import torchvision.transforms as transforms
from PIL import Image
from torch.utils.tensorboard import SummaryWriter
class ColorDepthShrinking(object):
def __init__(self, c=3):
... | 4,310 | 31.908397 | 115 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/utils.py | """Some helper functions for PyTorch, including:
- get_mean_and_std: calculate the mean and std value of dataset.
- msr_init: net parameter initialization.
- progress_bar: progress bar mimic xlua.progress.
"""
import math
import os
import sys
import time
import torch
import torch.nn as nn
import torch.nn.i... | 3,399 | 25.5625 | 96 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/eval.py | import copy
import os
import torch
import torch.nn as nn
import torchvision
from classifier_models import PreActResNet18
from config import get_arguments
from dataloader import get_dataloader
from networks.models import Generator, NetC_MNIST
from utils import progress_bar
def create_targets_bd(targets, opt):
if ... | 5,249 | 32.227848 | 112 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/train.py | import os
import shutil
import config
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from classifier_models import PreActResNet18, ResNet18
from dataloader import get_dataloader
from networks.models import Generator, NetC_MNIST
f... | 18,093 | 35.926531 | 141 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/networks/models.py | import torch
import torch.nn.functional as F
import torchvision
from torch import nn
from torchvision import transforms
from .blocks import *
class Normalize:
def __init__(self, opt, expected_values, variance):
self.n_channels = opt.input_channel
self.expected_values = expected_values
sel... | 5,336 | 33.655844 | 115 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/networks/blocks.py | import torch
from torch import nn
class Conv2dBlock(nn.Module):
def __init__(self, in_c, out_c, ker_size=(3, 3), stride=1, padding=1, batch_norm=True, relu=True):
super(Conv2dBlock, self).__init__()
self.conv2d = nn.Conv2d(in_c, out_c, ker_size, stride, padding)
if batch_norm:
... | 1,413 | 31.136364 | 115 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/behaviors/image_regularization/test_regularization.py | import copy
import os
import sys
import torch
import torch.nn as nn
from config import get_arguments
sys.path.insert(0, "../..")
from classifier_models import PreActResNet18
from dataloader import get_dataloader
from networks.models import Generator, NetC_MNIST
from utils import progress_bar
def create_targets_bd(... | 4,280 | 28.937063 | 112 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/fine_pruning/fine-pruning-mnist.py | import copy
import os
import sys
import torch
import torch.nn as nn
from config import get_arguments
sys.path.insert(0, "../..")
from dataloader import get_dataloader
from networks.models import Generator, NetC_MNIST
from utils import progress_bar
def create_targets_bd(targets, opt):
if opt.attack_mode == "all... | 5,271 | 31.54321 | 119 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/fine_pruning/fine-pruning-cifar10-gtsrb.py | import copy
import os
import sys
import torch
import torch.nn as nn
from config import get_arguments
sys.path.insert(0, "../..")
from classifier_models import PreActResNet18
from dataloader import get_dataloader
from networks.models import Generator
from utils import progress_bar
def create_targets_bd(targets, opt... | 5,745 | 31.647727 | 114 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/neural_cleanse/detecting.py | import sys
import config
import torch
import torchvision
import torchvision.transforms as transforms
from torch import Tensor, nn
sys.path.insert(0, "../..")
import os
import matplotlib.pyplot as plt
import numpy as np
from classifier_models import *
from dataloader import get_dataloader
from networks.models impor... | 10,515 | 34.407407 | 119 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/neural_cleanse/neural_cleanse.py | import sys
import numpy as np
from config import get_argument
from detecting import *
sys.path.insert(0, "../..")
def outlier_detection(l1_norm_list, idx_mapping, opt):
print("-" * 30)
print("Determining whether model is backdoor")
consistency_constant = 1.4826
median = torch.median(l1_norm_list)
... | 4,183 | 34.159664 | 118 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/STRIP/dataloader.py | import csv
import os
import config
import numpy as np
import torch
import torch.utils.data as data
import torchvision
import torchvision.transforms as transforms
from PIL import Image
class ToNumpy:
def __call__(self, x):
x = np.array(x)
if len(x.shape) == 2:
x = np.expand_dims(x, axi... | 4,283 | 31.953846 | 115 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/defenses/STRIP/STRIP.py | import os
import sys
import cv2
import numpy as np
import torch
import torch.nn.functional as F
import torchvision
from config import get_argument
from dataloader import get_dataloader, get_dataset
from torchvision import transforms
sys.path.insert(0, "../..")
from classifier_models import PreActResNet18
from networ... | 8,840 | 33.135135 | 112 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/shufflenetv2.py | """ShuffleNetV2 in PyTorch.
See the paper "ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design" for more details.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class ShuffleBlock(nn.Module):
def __init__(self, groups=2):
super(ShuffleBlock, self).__init__()
... | 5,200 | 34.623288 | 112 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/efficientnet.py | """EfficientNet in PyTorch.
Paper: "EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks".
Reference: https://github.com/keras-team/keras-applications/blob/master/keras_applications/efficientnet.py
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
def swish(x):
return x ... | 3,741 | 31.53913 | 112 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/pnasnet.py | """PNASNet in PyTorch.
Paper: Progressive Neural Architecture Search
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class SepConv(nn.Module):
"""Separable Convolution."""
def __init__(self, in_planes, out_planes, kernel_size, stride):
super(SepConv, self).__init__()
s... | 4,226 | 31.515385 | 116 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/resnet.py | """ResNet in PyTorch.
For Pre-activation ResNet, see 'preact_resnet.py'.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansi... | 4,052 | 30.913386 | 104 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/mobilenetv2.py | """MobileNetV2 in PyTorch.
See the paper "Inverted Residuals and Linear Bottlenecks:
Mobile Networks for Classification, Detection and Segmentation" for more details.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
"""expand + depthwise + pointwise"""
def __ini... | 2,977 | 35.765432 | 114 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/vgg.py | """VGG11/13/16/19 in Pytorch."""
import torch
import torch.nn as nn
cfg = {
"VGG11": [64, "M", 128, "M", 256, 256, "M", 512, 512, "M", 512, 512, "M"],
"VGG13": [64, 64, "M", 128, 128, "M", 256, 256, "M", 512, 512, "M", 512, 512, "M"],
"VGG16": [64, 64, "M", 128, 128, "M", 256, 256, 256, "M", 512, 512, 512... | 1,471 | 27.862745 | 117 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/densenet.py | """DenseNet in PyTorch."""
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Bottleneck(nn.Module):
def __init__(self, in_planes, growth_rate):
super(Bottleneck, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)
self.conv1 = nn.Conv2d(in_planes, 4 * ... | 3,590 | 30.226087 | 98 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/preact_resnet.py | """Pre-activation ResNet in PyTorch.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Identity Mappings in Deep Residual Networks. arXiv:1603.05027
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class PreActBlock(nn.Module):
"""Pre-activation version of the BasicBlock.... | 4,316 | 31.954198 | 103 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/googlenet.py | """GoogLeNet with PyTorch."""
import torch
import torch.nn as nn
import torch.nn.functional as F
class Inception(nn.Module):
def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
super(Inception, self).__init__()
# 1x1 conv branch
self.b1 = nn.Sequential(
... | 3,101 | 30.333333 | 83 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/resnext.py | """ResNeXt in PyTorch.
See the paper "Aggregated Residual Transformations for Deep Neural Networks" for more details.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
"""Grouped convolution block."""
expansion = 2
def __init__(self, in_planes, cardinality=3... | 3,536 | 33.009615 | 109 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/senet.py | """SENet in PyTorch.
SENet is the winner of ImageNet-2017. The paper is not released yet.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(... | 3,999 | 32.333333 | 113 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/shufflenet.py | """ShuffleNet in PyTorch.
See the paper "ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices" for more details.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class ShuffleBlock(nn.Module):
def __init__(self, groups):
super(ShuffleBlock, self).__init... | 3,544 | 32.443396 | 116 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/lenet.py | """LeNet in PyTorch."""
import torch.nn as nn
import torch.nn.functional as F
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linea... | 698 | 26.96 | 45 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/mobilenet.py | """MobileNet in PyTorch.
See the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications"
for more details.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
"""Depthwise conv + Pointwise conv"""
def __init__(self, in_planes, out... | 1,940 | 33.660714 | 103 | py |
input-aware-backdoor-attack-release | input-aware-backdoor-attack-release-master/classifier_models/dpn.py | """Dual Path Networks in PyTorch."""
import torch
import torch.nn as nn
import torch.nn.functional as F
class Bottleneck(nn.Module):
def __init__(self, last_planes, in_planes, out_planes, dense_depth, stride, first_layer):
super(Bottleneck, self).__init__()
self.out_planes = out_planes
sel... | 3,631 | 34.960396 | 116 | py |
keras-js | keras-js-master/python/model_pb2.py | # Generated by the protocol buffer compiler. DO NOT EDIT!
# source: model.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflect... | 6,998 | 36.427807 | 622 | py |
keras-js | keras-js-master/python/encoder.py | #!/usr/bin/env python
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import h5py
import numpy as np
import argparse
import uuid
import model_pb2
def quantize_arr(arr):
"""Quantization based on linear rescaling over min/max range.
"""
... | 4,226 | 33.647541 | 109 | py |
BiFeat | BiFeat-main/kmeans.py | import numpy as np
import torch
import tqdm
import math
def initialize(X, num_clusters):
"""
initialize cluster centers
:param X: (torch.tensor) matrix
:param num_clusters: (int) number of clusters
:return: (np.array) initial state
"""
nonzero_idxs = X.norm(dim=1, p=0).nonzero().squeeze()
... | 10,702 | 32.446875 | 158 | py |
BiFeat | BiFeat-main/packbits.py | import math
import torch
import time
def tensor_dim_slice(tensor, dim, s):
return tensor[(slice(None),) * (dim if dim >= 0 else dim + tensor.dim()) + (s, )]
def packshape(shape, dim, mask, dtype):
nbits_element = torch.iinfo(dtype).bits
nbits = 1 if mask == 0b00000001 else 2 if mask == 0b00000011 else 4 if... | 3,531 | 43.708861 | 263 | py |
BiFeat | BiFeat-main/compresser.py | import torch as th
import math
import numpy as np
import tqdm
from .kmeans import kmeans, get_centers, kmeans_predict
from .packbits import packbits, unpackbits
class Compresser(object):
def __init__(self, mode="sq", length=1, width=1, device="cpu"):
self.mode = mode
self.length = length
se... | 11,171 | 36.489933 | 182 | py |
BiFeat | BiFeat-main/examples/graphsage/train_compressed_cache.py | import dgl
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import dgl.multiprocessing as mp
import dgl.nn.pytorch as dglnn
import time
import math
import argparse
from torch.nn.parallel import DistributedDataParallel
import tqdm
from model import S... | 19,137 | 39.893162 | 177 | py |
BiFeat | BiFeat-main/examples/graphsage/train_compressed.py | import dgl
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import dgl.multiprocessing as mp
import dgl.nn.pytorch as dglnn
import time
import math
import argparse
from torch.nn.parallel import DistributedDataParallel
import tqdm
from model import S... | 15,749 | 39.592784 | 171 | py |
BiFeat | BiFeat-main/examples/graphsage/model.py | import torch as th
import torch.nn as nn
import torch.functional as F
import dgl
import dgl.nn as dglnn
import sklearn.linear_model as lm
import sklearn.metrics as skm
import tqdm
class SAGE(nn.Module):
def __init__(self, in_feats, n_hidden, n_classes, n_layers, activation, dropout, MLP=False, res=False, bn=F... | 6,514 | 37.779762 | 138 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/storage.py | import torch
import time
class GraphCacheServer:
"""
Manage graph features
Automatically fetch the feature tensor from CPU or GPU
"""
def __init__(self, nfeats, node_num, nid_map, gpuid):
"""
Paramters:
graph: should be created from `dgl.contrib.graph_store`
... | 6,770 | 38.829412 | 93 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/process_lsc.py | import ogb
from ogb.lsc import MAG240MDataset
import tqdm
import numpy as np
import torch
import dgl
import dgl.function as fn
import argparse
import os
parser = argparse.ArgumentParser()
parser.add_argument('--rootdir', type=str, default='.', help='Directory to download the OGB dataset.')
parser.add_argument('--autho... | 5,830 | 50.60177 | 140 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/kmeans.py | import numpy as np
import torch
import tqdm
import math
def initialize(X, num_clusters):
"""
initialize cluster centers
:param X: (torch.tensor) matrix
:param num_clusters: (int) number of clusters
:return: (np.array) initial state
"""
nonzero_idxs = X.norm(dim=1, p=0).nonzero().squeeze()
... | 10,702 | 32.446875 | 158 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/packbits.py | import math
import torch
import time
def tensor_dim_slice(tensor, dim, s):
return tensor[(slice(None),) * (dim if dim >= 0 else dim + tensor.dim()) + (s, )]
def packshape(shape, dim, mask, dtype):
nbits_element = torch.iinfo(dtype).bits
nbits = 1 if mask == 0b00000001 else 2 if mask == 0b00000011 else 4 if... | 3,531 | 43.708861 | 263 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/compresser.py | import torch as th
import math
import numpy as np
import tqdm
from .kmeans import kmeans, get_centers, kmeans_predict
from .packbits import packbits, unpackbits
class Compresser(object):
def __init__(self, mode="sq", length=1, width=1, device="cpu"):
self.mode = mode
self.length = length
se... | 11,171 | 36.489933 | 182 | py |
BiFeat | BiFeat-main/examples/graphsage/utils/load_graph.py | import dgl
import torch as th
import numpy as np
from memory_profiler import profile
def load_reddit():
# from ogb.nodeproppred import DglNodePropPredDataset
# print('load', name)
# data = DglNodePropPredDataset(name="ogbn-products", root="/data/graphData/original_dataset")
from dgl.data import Redd... | 7,849 | 33.888889 | 132 | py |
CharFormer | CharFormer-main/datasets.py | import glob
import os
import numpy as np
from torch.utils.data import Dataset
from PIL import Image
import torchvision.transforms as transforms
import cv2
from skimage import morphology
import time
class ImageDataset(Dataset):
def __init__(self, root1, root2 = None, transforms_=None, mode="train", file_set ="separ... | 3,490 | 39.126437 | 116 | py |
CharFormer | CharFormer-main/predict.py | import torch
import time
import argparse
from torch.autograd import Variable
from torchvision.utils import make_grid
from models.model_CharFormer import CharFormer
from datasets import *
from util.TestMetrics import get_PSNR, get_SSIM
# from datasets import skeletonPrepare
########################################
###... | 5,506 | 39.492647 | 112 | py |
CharFormer | CharFormer-main/train.py | ##### External Interface #####
import argparse
import time
import datetime
import sys
import torch
from torchvision.utils import save_image
from torch.utils.data import DataLoader
from torch.autograd import Variable
from torchvision.utils import make_grid
##### Internal Interface #####
from util.LossFunctions import V... | 10,859 | 38.78022 | 129 | py |
CharFormer | CharFormer-main/models/TransformerBlock.py | import torch
from torch import nn
from einops import rearrange
# def pair(t):
# return t if isinstance(t, tuple) else (t, t)
class PreNorm(nn.Module):
def __init__(self, dim, fn):
super().__init__()
self.norm = nn.LayerNorm(dim)
self.fn = fn
def forward(self, x, **kwargs):
... | 2,855 | 30.043478 | 105 | py |
CharFormer | CharFormer-main/models/model_CharFormer.py | from functools import partial
import torch
from torch import nn, einsum
from einops import rearrange
from FusedAttention import FusedAttentionBlock
List = nn.ModuleList
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def cast_tuple(val, depth=1):
return v... | 8,985 | 30.865248 | 144 | py |
CharFormer | CharFormer-main/models/FusedAttention.py | import numpy as np
import torch
from torch import nn
from torch.nn import init
class ChannelAttention(nn.Module):
def __init__(self,channel,reduction=16):
super().__init__()
self.maxpool=nn.AdaptiveMaxPool2d(1)
self.avgpool=nn.AdaptiveAvgPool2d(1)
self.se=nn.Sequential(
... | 2,452 | 29.283951 | 79 | py |
CharFormer | CharFormer-main/util/LossFunctions.py | import torch.nn as nn
import torch.nn.functional as F
import cv2
from PIL import Image
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
from torchvision.utils import make_grid
from skimage import morphology
cuda = True if torch.cuda.is_available() else False
Tensor = torch... | 4,110 | 30.868217 | 99 | py |
colight | colight-master/lit_agent.py |
import pickle
from network_agent import NetworkAgent, Selector
import numpy as np
from keras.layers import Input, Multiply, Add
from keras.models import Model
from keras.optimizers import RMSprop
from keras.layers.merge import concatenate
class LitAgent(NetworkAgent):
def build_network(self):
'''Ini... | 4,417 | 51.595238 | 121 | py |
colight | colight-master/simple_dqn_agent.py |
import numpy as np
from keras import backend as K
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping, TensorBoard
from keras.laye... | 2,950 | 47.377049 | 140 | py |
colight | colight-master/network_agent.py |
import numpy as np
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model
from keras.optimizers import RMSprop
from keras.layers.core import Dropout
from keras.layers.pooling import MaxPooling2D
from keras import... | 15,179 | 44.861027 | 148 | py |
colight | colight-master/simple_dqn_one_agent.py |
import numpy as np
from keras import backend as K
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping, TensorBoard
from keras.laye... | 6,016 | 43.242647 | 176 | py |
colight | colight-master/CoLight_agent.py | import numpy as np
import os
import pickle
from agent import Agent
import random
import time
"""
Model for CoLight in paper "CoLight: Learning Network-level Cooperation for Traffic Signal
Control", in submission.
"""
import keras
from keras import backend as K
from keras.optimizers import Adam, RMSprop
import ten... | 28,506 | 43.681818 | 464 | py |
colight | colight-master/baseline/deeplight_agent.py |
from keras.callbacks import EarlyStopping, TensorBoard
from keras.layers.merge import concatenate, add
import pickle
### network_agent
import numpy as np
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model... | 24,807 | 41.047458 | 142 | py |
colight | colight-master/baseline/network_agent_bk.py |
import numpy as np
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model
from keras.optimizers import RMSprop
from keras.layers.core import Dropout
from keras.layers.pooling import MaxPooling2D
from keras impo... | 8,441 | 38.448598 | 161 | py |
colight | colight-master/baseline/deeplight_agent_bk.py |
import numpy as np
from keras import backend as K
from keras.layers import Input, Dense, Conv2D, Flatten, BatchNormalization, Activation, Multiply, Add
from keras.models import Model, model_from_json, load_model
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping, TensorBoard
from keras.laye... | 15,520 | 42.598315 | 131 | py |
scDeepSort | scDeepSort-master/predict.py | import argparse
import time
import random
import numpy as np
import pandas as pd
from pathlib import Path
import torch
import torch.nn as nn
import torch.nn.functional as F
from dgl.contrib.sampling import NeighborSampler
# self-defined
from utils import load_data
from models import GNN
from pprint import pprint
clas... | 8,379 | 44.053763 | 149 | py |
scDeepSort | scDeepSort-master/train.py | import argparse
import random
import numpy as np
from pathlib import Path
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from dgl.contrib.sampling import NeighborSampler
# self-defined
from utils import load_data_internal
from models import GNN
from pprint imp... | 8,103 | 46.670588 | 245 | py |
scDeepSort | scDeepSort-master/models/gnn.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import dgl
import dgl.function as fn
from dgl import DGLGraph
class NodeUpdate(nn.Module):
def __init__(self, in_feats, out_feats, activation=None, norm=None):
super(NodeUpdate, self).__init__()
self.fc_neigh = n... | 4,300 | 45.75 | 115 | py |
scDeepSort | scDeepSort-master/utils/preprocess_internal.py | import argparse
import pandas as pd
import dgl
import torch
import torch.nn.functional as F
import collections
from scipy.sparse import csr_matrix, vstack, save_npz
from sklearn.decomposition import PCA
from pathlib import Path
import numpy as np
from pprint import pprint
import json
def normalize_weight(graph: dgl.D... | 9,105 | 40.770642 | 148 | py |
scDeepSort | scDeepSort-master/utils/preprocess.py | import argparse
import pandas as pd
import dgl
import torch
import torch.nn.functional as F
import collections
from scipy.sparse import csr_matrix, vstack, load_npz
from sklearn.decomposition import PCA
from pathlib import Path
import numpy as np
from time import time
def get_map_dict(map_path: Path, tissue):
map... | 10,462 | 42.235537 | 150 | py |
Automatic-Corpus-Generation | Automatic-Corpus-Generation-master/model/test.py | #- *- coding: utf-8 -*-
import numpy as np
import logging
from tqdm import tqdm
from model.utils.utils import *
from model.bilstm import *
import pickle
EMBEDDING_DIM = 300
HIDDEN_DIM = 300
batch_size = 32
saved_model_path = 'save/model.th'
saved_model_dict = "save/modeldict"
with open("modeldict.pkl", "rb") as file... | 4,376 | 35.781513 | 74 | py |
Automatic-Corpus-Generation | Automatic-Corpus-Generation-master/model/bilstm.py | # -*- coding:utf-8 -*-
import torch
import os
import torch.nn as nn
import torch.nn.functional as F
# These will usually be more like 32 or 64 dimensional.
# We will keep them small, so we can see how the weights change as we train.
if (os.cpu_count() > 8):
USE_CUDA = True
else:
USE_CUDA = False
class BiLST... | 2,327 | 34.815385 | 104 | py |
Automatic-Corpus-Generation | Automatic-Corpus-Generation-master/model/train.py | #- *- coding: utf-8 -*-
import numpy as np
import logging
from tqdm import tqdm
from utils.utils import *
from bilstm import *
import torch.optim as optim
import pickle
EMBEDDING_DIM = 300
HIDDEN_DIM = 300
batch_size = 32
isSplit = True
lang = Lang()
train, dev = prepare_data_seq("data/test/test13.sgml", lang, Fal... | 3,436 | 33.37 | 108 | py |
Automatic-Corpus-Generation | Automatic-Corpus-Generation-master/model/utils/utils.py | #-*- coding:utf-8 -*-
import torch
import torch.utils.data as data
from torch.autograd import Variable
import logging
import os
import codecs
import random
from bs4 import BeautifulSoup
UNK_token=0
PAD_token=1
EOS_token=2
SOS_token=3
if (os.cpu_count() > 8):
USE_CUDA = True
else:
USE_CUDA = False
class Lang... | 6,990 | 31.821596 | 104 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/trace_expm.py | import torch
import numpy as np
import scipy.linalg as slin
class TraceExpm(torch.autograd.Function):
@staticmethod
def forward(ctx, input):
# detach so we can cast to NumPy
E = slin.expm(input.cpu().detach().numpy())
f = np.trace(E)
E = torch.from_numpy(E)
ctx.save_for... | 943 | 23.205128 | 71 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/locally_connected.py | import torch
import torch.nn as nn
import math
class LocallyConnected(nn.Module):
"""Local linear layer, i.e. Conv1dLocal() with filter size 1.
Args:
num_linear: num of local linear layers, i.e.
in_features: m1
out_features: m2
bias: whether to include bias or not
Shape:
... | 2,911 | 30.311828 | 80 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/GraphNOTEARS.py | from locally_connected import LocallyConnected
# from lbfgsb_scipy_p1 import LBFGSBScipy # >50 可选
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
import utils as ut
import scipy.sparse
device = torch.device("cuda:1")
class model_p1_MLP(nn.Mod... | 6,274 | 30.375 | 191 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/lasso.py | from locally_connected import LocallyConnected
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
class lasso_MLP(nn.Module):
def __init__(self, dims, bias=True):
super(lasso_MLP, self).__init__()
assert len(dims) >= 2
... | 3,799 | 30.404959 | 90 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/utils.py | from scipy.special import expit as sigmoid
import igraph as ig
import random
import torch
import numpy as np
import scipy.sparse
import scipy.sparse as sp
device = torch.device("cuda:0")
def set_random_seed(seed):
random.seed(seed)
np.random.seed(seed)
def is_dag(W):
G = ig.Graph.Weighted_Adjacency(W.tol... | 14,993 | 35.13012 | 249 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/run.py | from locally_connected import LocallyConnected
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
from sklearn.metrics import f1_score
import torch
import torch.nn as nn
import numpy as np
import scipy.sparse
import GraphNOTEARS
import notears_torch_version
import lasso
import dynotears_p2
import ut... | 14,434 | 51.111913 | 225 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/dynotears_p2.py | from locally_connected import LocallyConnected
#from lbfgsb_scipy_p1 import LBFGSBScipy # >50 可选
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
import utils as ut
import scipy.sparse
device = torch.device("cuda:0")
class dynotears_MLP(nn.Mo... | 6,229 | 29.689655 | 191 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/linear.py | import numpy as np
import scipy.linalg as slin
import scipy.optimize as sopt
from scipy.special import expit as sigmoid
import scipy.sparse
import numpy as np
import torch
def notears_linear(X, x_temp, A, lambda1, loss_type, max_iter=100, h_tol=1e-8, rho_max=1e+16, w_threshold = 0.5):
"""Solve min_W L(W; X) + lamb... | 4,778 | 33.630435 | 113 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/lbfgsb_scipy.py | import torch
import scipy.optimize as sopt
class LBFGSBScipy(torch.optim.Optimizer):
"""Wrap L-BFGS-B algorithm, using scipy routines.
Courtesy: Arthur Mensch's gist
https://gist.github.com/arthurmensch/c55ac413868550f89225a0b9212aa4cd
"""
def __init__(self, params):
defaults = dict(... | 4,142 | 30.150376 | 80 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_2/notears_torch_version.py | from locally_connected import LocallyConnected
#from lbfgsb_scipy_p1 import LBFGSBScipy # 特征数大于50可用
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
class NotearsMLP(nn.Module):
def __init__(self, dims, bias=True):
super(NotearsMLP... | 4,140 | 31.606299 | 97 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/trace_expm.py | import torch
import numpy as np
import scipy.linalg as slin
class TraceExpm(torch.autograd.Function):
@staticmethod
def forward(ctx, input):
# detach so we can cast to NumPy
E = slin.expm(input.cpu().detach().numpy())
f = np.trace(E)
E = torch.from_numpy(E)
ctx.save_for... | 943 | 23.205128 | 71 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/locally_connected.py | import torch
import torch.nn as nn
import math
class LocallyConnected(nn.Module):
"""Local linear layer, i.e. Conv1dLocal() with filter size 1.
Args:
num_linear: num of local linear layers, i.e.
in_features: m1
out_features: m2
bias: whether to include bias or not
Shape:
... | 2,911 | 30.311828 | 80 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/GraphNOTEARS.py | from locally_connected import LocallyConnected
# from lbfgsb_scipy_p1 import LBFGSBScipy # >50 可选
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
import utils as ut
import scipy.sparse
device = torch.device("cuda:0")
class model_p1_MLP(nn.Mod... | 6,040 | 29.821429 | 192 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/dynotears.py | from locally_connected import LocallyConnected
#from lbfgsb_scipy_p1 import LBFGSBScipy # >50 可选
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
import utils as ut
import scipy.sparse
device = torch.device("cuda:0")
class dynotears_MLP(nn.Mo... | 6,150 | 29.450495 | 192 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/lasso.py | from locally_connected import LocallyConnected
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
import torch
import torch.nn as nn
import numpy as np
class lasso_MLP(nn.Module):
def __init__(self, dims, bias=True):
super(lasso_MLP, self).__init__()
assert len(dims) >= 2
... | 3,571 | 29.529915 | 84 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/utils.py | from scipy.special import expit as sigmoid
import igraph as ig
import random
import torch
import numpy as np
import scipy.sparse
import scipy.sparse as sp
device = torch.device("cuda:0")
def set_random_seed(seed):
random.seed(seed)
np.random.seed(seed)
def is_dag(W):
G = ig.Graph.Weighted_Adjacency(W.tol... | 14,829 | 34.995146 | 172 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/run.py | from locally_connected import LocallyConnected
from lbfgsb_scipy import LBFGSBScipy
from trace_expm import trace_expm
from sklearn.metrics import f1_score
import torch
import torch.nn as nn
import numpy as np
import scipy.sparse
import GraphNOTEARS
import notears_torch_version
import lasso
import dynotears
import utils... | 10,198 | 47.566667 | 225 | py |
GraphNOTEARS | GraphNOTEARS-main/GraphNOTEARS_syn_p_1/linear.py | import numpy as np
import scipy.linalg as slin
import scipy.optimize as sopt
from scipy.special import expit as sigmoid
import scipy.sparse
import numpy as np
import torch
def notears_linear(X, x_temp, A, lambda1, loss_type, max_iter=100, h_tol=1e-8, rho_max=1e+16, w_threshold = 0.5):
"""Solve min_W L(W; X) + lamb... | 4,778 | 33.630435 | 113 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.