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 |
|---|---|---|---|---|---|---|
ugle | ugle-main/ugle/models/cagc.py | # https://github.com/wangtong627/CAGC/
import torch
import torch.nn as nn
from torch_geometric.nn import GATConv
from ugle.trainer import ugleTrainer
import numpy as np
from sklearn import cluster
import scipy.sparse as sp
from scipy.sparse.linalg import svds
from sklearn.preprocessing import normalize
import torch.nn.... | 8,800 | 33.649606 | 117 | py |
ugle | ugle-main/ugle/models/grace.py | # https://github.com/CRIPAC-DIG/GRACE
import torch
import torch.nn as nn
import torch.nn.functional as F
import ugle
import scipy.sparse as sp
import numpy as np
from sklearn.cluster import KMeans
from torch_geometric.utils import dropout_adj
from torch_geometric.nn import GCNConv
from ugle.trainer import ugleTrainer
... | 5,947 | 32.22905 | 100 | py |
ugle | ugle-main/ugle/models/vgaer.py | # https://github.com/qcydm/VGAER/tree/main/VGAER_codes
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from sklearn.cluster import KMeans
import math
from ugle.trainer import ugleTrainer
import numpy as np
class GraphConvolution(nn.Module):
"""
Simple... | 5,868 | 33.727811 | 116 | py |
ugle | ugle-main/ugle/models/dgi.py | # inspired by https://github.com/PetarV-/DGI
import numpy as np
import scipy.sparse as sp
import torch
import torch.nn as nn
from sklearn.cluster import KMeans
import ugle
from ugle.trainer import ugleTrainer
from ugle.gnn_architecture import GCN, AvgReadout, Discriminator
class DGI(nn.Module):
def __init__(self, ... | 2,970 | 33.149425 | 116 | py |
ugle | ugle-main/ugle/models/selfgnn.py | # https://github.com/zekarias-tilahun/SelfGNN
import torch
import torch.nn as nn
import torch.nn.functional as F
from sklearn.cluster import KMeans
import scipy.sparse as sp
from torch_geometric.nn import GCNConv, GATConv, SAGEConv
from functools import wraps
import copy
import ugle
from ugle.trainer import ugleTrainer... | 9,889 | 37.333333 | 117 | py |
doppler | doppler-master/docs/conf.py | # -*- coding: utf-8 -*-
# Licensed under a 3-clause BSD style license - see LICENSE.rst
#
# Astropy documentation build configuration file.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this file.
#
# All configurati... | 7,980 | 35.442922 | 109 | py |
shapely | shapely-main/docs/conf.py | # Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# set an environment variable for shapely.decorators.requires_geos to see if we
# are i... | 4,366 | 29.326389 | 87 | py |
vbpi-nf | vbpi-nf-main/code/deep_branchModel.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from invariant_branchModel import BatchIndexedMLP
from base_branchModel import BaseModel
import math
import pdb
class Encoder(nn.Module):
def __init__(self, ntips, rootsplit_embedding_map, subsplit_embedding_map, psp=True, feature_dim=2):
... | 6,588 | 50.88189 | 201 | py |
vbpi-nf | vbpi-nf-main/code/vector_sbnModel.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from bitarray import bitarray
from ete3 import Tree
from utils import BitArray, logsumexp
import pdb
class ParamParser(object):
def __init__(self):
self.start_and_end = {}
self.num_params = 0
self.num_pa... | 14,729 | 47.137255 | 241 | py |
vbpi-nf | vbpi-nf-main/code/invariant_branchModel.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import numpy as np
import pdb
class IndexedLinear(nn.Linear):
"""
Implementation of permutation equivariant linear layers.
"""
def __init__(self, in_features, out_features, bias=True):
super().__init__(in_feat... | 4,542 | 35.344 | 98 | py |
vbpi-nf | vbpi-nf-main/code/base_branchModel.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import pdb
class BaseModel(nn.Module):
"""
The base VBPI branch length model.
Use psp to turn on/off the primary subsplit pair (PSP) parameterization. The Default is true.
Reference
---------
.. [1] Cheng Zhang ... | 4,478 | 45.65625 | 139 | py |
vbpi-nf | vbpi-nf-main/code/phyloModel.py | import torch
import numpy as np
from rateMatrix import *
import pdb
class PHY(object):
nuc2vec = {'A':[1.,0.,0.,0.], 'G':[0.,1.,0.,0.], 'C':[0.,0.,1.,0.], 'T':[0.,0.,0.,1.],
'-':[1.,1.,1.,1.], '?':[1.,1.,1.,1.], 'N':[1.,1.,1.,1.], 'R':[1.,1.,0.,0.],
'Y':[0.,0.,1.,1.], 'S':[0.,1.,1.,0.], 'W':[... | 3,533 | 46.756757 | 137 | py |
vbpi-nf | vbpi-nf-main/code/vbpi.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import time
import math
import random
import numpy as np
from utils import namenum
from deep_branchModel import DeepModel
from vector_sbnModel import SBN
from phyloModel import PHY
import pdb
class VBPI(nn.Module):
EPS = 1e-40
def __ini... | 7,703 | 47.45283 | 168 | py |
advml-traffic-sign | advml-traffic-sign-master/train_adv.py | """
A run script to start adversarial training.
"""
import os
from os.path import basename
import keras
from keras import backend as K
from keras.models import save_model
from lib.attacks import symb_iter_fgs, symbolic_fgs
from lib.keras_utils import *
from lib.tf_utils import tf_test_error_rate, tf_train
from lib.ut... | 2,716 | 30.593023 | 103 | py |
advml-traffic-sign | advml-traffic-sign-master/parameters.py | """
Define project-wide parameters in this 'configuration' file
"""
# Import packages for all files
import os
import pickle
import random
import threading
import time
from os import listdir
import cv2
import keras
import keras.backend as K
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
fro... | 2,044 | 35.517857 | 79 | py |
advml-traffic-sign | advml-traffic-sign-master/train.py | """
A run script for training NN model on GTSRB
"""
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
from lib.keras_utils import *
from lib.OptCarlini import *
from lib.OptTransform import *
from lib.RandomTransform import *
from lib.utils import *
from parameters impo... | 1,626 | 31.54 | 79 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/OptYolo.py | from lib.keras_utils import *
from lib.utils import *
from parameters_yolo import *
from attack_detector.yad2k.models.keras_yolo import yolo_head
EPS = 1e-10 # Epsilon
MIN_CP = -2. # Minimum power index of c
MAX_CP = 2. # Maximum power index of c
SCORE_THRES = 0.5 # Softmax score threshold to consider success of... | 13,712 | 40.680851 | 82 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/tf_utils.py | """
An additional utility file used for adversarial training.
Author: Arjun Bhagoji (abhagoji@princeton.edu)
"""
import sys
import time
import keras.backend as K
import numpy as np
import tensorflow as tf
from keras.models import save_model
from keras.preprocessing.image import ImageDataGenerator
from lib.keras_utils... | 5,499 | 29.054645 | 86 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/OptTransform.py | from lib.keras_utils import *
from lib.RandomEnhance import *
from lib.RandomTransform import *
from lib.utils import *
from parameters import *
EPS = 1e-10 # Epsilon
MIN_CP = -2. # Minimum power index of c
MAX_CP = 2. # Maximum power index of c
SCORE_THRES = 0.99 # Softmax score threshold to consider success of... | 16,442 | 41.161538 | 82 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/utils.py | from lib.keras_utils import *
from parameters import *
from scipy import ndimage as ndi
from skimage.feature import canny
from lib.RandomEnhance import *
from lib.RandomTransform import *
# Threshold for checking mask area
MASK_THRES_MIN = 0.1
MASK_THRES_MAX = 0.9
def rgb2gray(image):
"""Convert 3-channel RGB i... | 15,607 | 31.516667 | 81 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/keras_utils.py | import keras
from keras.layers.convolutional import Convolution2D, MaxPooling2D
from keras.layers.core import Activation, Dense, Dropout, Flatten
from keras.layers.normalization import BatchNormalization
from keras.models import Sequential
from parameters import *
#----------------------------------- Model -----------... | 5,941 | 33.546512 | 80 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/yolo_utils.py | """
This is a separate utility class for attacking YOLO detector specifically
"""
from parameters_yolo import *
from attack_detector.yad2k.models.keras_yolo import yolo_head
def gradient_yolo(yolo_model, anchors, op=0):
_, _, output_conf, output_class = yolo_head(yolo_model.output, anchors, 80)
target_conf... | 6,533 | 33.209424 | 80 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/OptCarlini.py | from lib.keras_utils import *
from lib.utils import *
from parameters import *
EPS = 1e-10 # Epsilon
MIN_CP = -2. # Minimum power index of c
MAX_CP = 2. # Maximum power index of c
SCORE_THRES = 0.9 # Softmax score threshold to consider success of attacks
PROG_PRINT_STEPS = 50 # Print progress every certain step... | 13,558 | 40.464832 | 82 | py |
advml-traffic-sign | advml-traffic-sign-master/lib/OptProjTran.py | import random
from lib.keras_utils import *
from lib.utils import *
from parameters import *
from skimage.transform import ProjectiveTransform
EPS = 1e-10 # Epsilon
MIN_CP = -2. # Minimum power index of c
MAX_CP = 2. # Maximum power index of c
SCORE_THRES = 0.99 # Softmax score threshold to consider success of ... | 20,096 | 42.406048 | 80 | py |
MultitaskTrafficClassification | MultitaskTrafficClassification-master/multitaskMasked.py | import numpy as np
from keras.models import Model
from keras.layers import Dense
from keras.layers import multiply
from keras.layers import Flatten
from keras.layers import Input
from keras.layers.convolutional import Conv1D, MaxPooling1D
from keras.layers import Activation
from keras.optimizers import Adam
timestep =... | 6,121 | 28.574879 | 178 | py |
MultitaskTrafficClassification | MultitaskTrafficClassification-master/singletask.py | import numpy as np
from keras.models import Model
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers import Input
from keras.layers.convolutional import Conv1D, MaxPooling1D
from keras.layers import Activation
from keras.optimizers import Adam
timestep = 60
np.random.seed(10)
num_class ... | 5,206 | 25.979275 | 87 | py |
MultitaskTrafficClassification | MultitaskTrafficClassification-master/transferlearning.py | import numpy as np
from keras.models import Model
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers import Input
from keras.layers.convolutional import Conv1D, MaxPooling1D
from keras.layers import Activation
from keras.optimizers import Adam
timestep = 60
np.random.seed(10)
num_class ... | 6,419 | 31.424242 | 117 | py |
WeSTClass | WeSTClass-master/main.py | import numpy as np
np.random.seed(1234)
from time import time
import os
# os.environ["CUDA_VISIBLE_DEVICES"]="0"
from model import WSTC, f1
from keras.optimizers import SGD
from gen import augment, pseudodocs
from load_data import load_dataset
from gensim.models import word2vec
def train_word2vec(sentence_matrix, voc... | 10,587 | 41.352 | 151 | py |
WeSTClass | WeSTClass-master/model.py | import numpy as np
np.random.seed(1234)
import os
from time import time
import csv
import keras.backend as K
# K.set_session(K.tf.Session(config=K.tf.ConfigProto(intra_op_parallelism_threads=30, inter_op_parallelism_threads=30)))
from keras.engine.topology import Layer
from keras.layers import Dense, Input, Convolution... | 10,954 | 39.424354 | 124 | py |
Nalin | Nalin-main/src/nn/read_dataset.py | """
Created on 02-June-2020
@author Jibesh Patra
"""
from multiprocessing.spawn import freeze_support
from torchvision.transforms import Compose
from DynamicAnalysisDataset import DynamicAnalysisDataset
from torch.utils.data import random_split
import random
from pathlib import Path
from typing import Tuple, List
f... | 4,852 | 39.107438 | 173 | py |
Nalin | Nalin-main/src/nn/run_classification.py | """
Created on 21-April-2020
@author Jibesh Patra
"""
import argparse
import os
import sys
from multiprocessing import cpu_count
from pathlib import Path
import torch
from torch.utils.data import DataLoader
import fileutils as fs
from dataset_utils.data_transformers.AblationTransformer import AblationTransformer
fr... | 8,980 | 45.533679 | 144 | py |
Nalin | Nalin-main/src/nn/DynamicAnalysisDataset.py | """
Created on 04-May-2020
@author Jibesh Patra
"""
from torch.utils.data import Dataset
from torchvision.transforms import Compose
import pandas as pd
class DynamicAnalysisDataset(Dataset):
def __init__(self, dataset: pd.DataFrame, transform: Compose) -> None:
self.data = dataset
self.transfor... | 876 | 22.078947 | 74 | py |
Nalin | Nalin-main/src/nn/model.py | """
Created on 21-April-2020
@author Jibesh Patra
"""
from multiprocessing.spawn import freeze_support
import torch.nn as nn
from typing import List, Tuple
import torch
from abc import ABC, abstractmethod
import time
import os
import datetime
from torch.optim.lr_scheduler import ExponentialLR
try:
cfg = get_ipyt... | 9,486 | 39.029536 | 158 | py |
Nalin | Nalin-main/src/nn/models/VarValueClassifierRNN.py | """
Created on 25-June-2020
@author Jibesh Patra
"""
from abc import ABC
from model import Model
import torch.nn as nn
import torch
from typing import Tuple, List, Dict
class VarValueClassifierRNN(Model, ABC):
def __init__(self, embedding_dim: int,
num_of_characters_in_alphabet: int,
... | 3,150 | 36.511905 | 112 | py |
Nalin | Nalin-main/src/nn/dataset_utils/data_transformers/RepresentShape.py | """
Created on 24-September-2020
@author Jibesh Patra
"""
from typing import Dict
import torch
class RepresentShape:
def __init__(self):
self.max_shape = 100000
self.num_bins = 100
self.bin_spacing = self.max_shape // self.num_bins
def __call__(self, sample: Dict) -> Dict:
... | 885 | 22.945946 | 89 | py |
Nalin | Nalin-main/src/nn/dataset_utils/data_transformers/RepresentLen.py | """
Created on 29-June-2020
@author Jibesh Patra
"""
from typing import Dict
import torch
class RepresentLen:
def __init__(self):
self.max_len = 1000
self.num_bins = 100
self.bin_spacing = self.max_len // self.num_bins
def __call__(self, sample: Dict) -> Dict:
one_hot = [0]... | 572 | 20.222222 | 56 | py |
Nalin | Nalin-main/src/nn/dataset_utils/data_transformers/ValueToCharSequence.py | """
Created on 11-May-2020
@author Jibesh Patra
"""
from typing import Dict
import unicodedata
import string
import torch
all_letters = string.ascii_letters + \
" .,;'0123456789,;.!?:'\"/\\|_@#$%^→&*~`+-=<>()[]{} "
nbs_chars = len(all_letters)
class ValueToCharSequence:
def __init__(self, len_of... | 1,650 | 30.150943 | 96 | py |
Nalin | Nalin-main/src/nn/dataset_utils/data_transformers/AblationTransformer.py | """
Created on 13-June-2020
@author Jibesh Patra
"""
from typing import Dict, List
import torch
class AblationTransformer:
def __init__(self, features_to_ablate=None) -> None:
if features_to_ablate is None:
# Example: ['type'] OR ['type', 'value']
features_to_ablate = []
... | 940 | 29.354839 | 97 | py |
Nalin | Nalin-main/src/nn/dataset_utils/data_transformers/OneHotEncodingOfTypes.py | """
Created on 11-May-2020
@author Jibesh Patra
"""
from typing import Dict, List
import torch
import json
class OneHotEncodingOfType:
def __init__(self, max_types_to_select: int, types_in_dataset_file_path: str) -> None:
"""
Create the one-hot encoding for the types in the dataset.
:... | 1,984 | 35.090909 | 116 | py |
vqwordseg | vqwordseg-main/vqwordseg/algorithms.py | """
VQ phone and word segmentation algorithms.
Author: Herman Kamper
Contact: kamperh@gmail.com
Date: 2021
"""
from pathlib import Path
from scipy.spatial import distance
from scipy.special import factorial
from scipy.stats import gamma
from tqdm import tqdm
import numpy as np
import sys
sys.path.append(str(Path(__f... | 27,188 | 31.445107 | 93 | py |
MT4SR | MT4SR-main/main.py | # -*- coding: utf-8 -*-
# @Time : 2020/4/25 22:59
import os
import numpy as np
import random
import torch
import argparse
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from datasets import SASRecDataset, RelationAwareSASRecDataset
from trainers import FinetuneTrainer, DistSAModelTraine... | 9,274 | 49.407609 | 290 | py |
MT4SR | MT4SR-main/modules.py | import numpy as np
import copy
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
def gelu(x):
"""Implementation of the gelu activation function.
For information: OpenAI GPT's gelu is slightly different
(and gives slightly different results):
0.5 * x * (1 + tor... | 30,569 | 47.755981 | 194 | py |
MT4SR | MT4SR-main/trainers.py | # -*- coding: utf-8 -*-
import numpy as np
import tqdm
import random
import math
from collections import defaultdict
import torch
import torch.nn as nn
from torch.optim import Adam
from utils import recall_at_k, ndcg_k, get_metric, cal_mrr, get_user_performance_perpopularity, get_item_performance_perpopularity
from ... | 48,882 | 46.459223 | 201 | py |
MT4SR | MT4SR-main/utils.py | # -*- coding: utf-8 -*-
import numpy as np
import math
import random
import os
import json
import pickle
from scipy.sparse import csr_matrix
from tqdm import tqdm
import multiprocessing
import torch
import torch.nn.functional as F
def set_seed(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)... | 22,271 | 33.159509 | 140 | py |
MT4SR | MT4SR-main/datasets.py | import random
import numpy as np
import torch
from torch.utils.data import Dataset
from utils import neg_sample
class PretrainDataset(Dataset):
def __init__(self, args, user_seq, long_sequence):
self.args = args
self.user_seq = user_seq
self.long_sequence = long_sequence
self.max... | 12,377 | 37.086154 | 140 | py |
MT4SR | MT4SR-main/seqmodels.py | import torch
import torch.nn as nn
from modules import Encoder, LayerNorm, DistSAEncoder, DistMeanSAEncoder, RelationAwareSAEncoder
class SASRecModel(nn.Module):
def __init__(self, args):
super(SASRecModel, self).__init__()
self.item_embeddings = nn.Embedding(args.item_size, args.hidden_size, paddi... | 9,840 | 46.541063 | 127 | py |
ARPL | ARPL-master/osr.py | import os
import argparse
import datetime
import time
import csv
import pandas as pd
import importlib
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import lr_scheduler
import torch.multiprocessing as mp
import torch.backends.cudnn as cudnn
from models import gan
from models.model... | 9,985 | 41.858369 | 151 | py |
ARPL | ARPL-master/utils.py | import os
import sys
import errno
import os.path as osp
import numpy as np
import torch
def mkdir_if_missing(directory):
if not osp.exists(directory):
try:
os.makedirs(directory)
except OSError as e:
if e.errno != errno.EEXIST:
raise
class AverageMeter(objec... | 3,015 | 28.281553 | 100 | py |
ARPL | ARPL-master/ood.py | import os
import sys
import argparse
import datetime
import time
import csv
import os.path as osp
import numpy as np
import warnings
import importlib
warnings.filterwarnings('ignore')
import torch
import torch.nn as nn
from torch.optim import lr_scheduler
import torch.backends.cudnn as cudnn
import torchvision
import ... | 7,137 | 37.583784 | 141 | py |
ARPL | ARPL-master/core/test.py | import os
import os.path as osp
import numpy as np
import torch
from torch.autograd import Variable
import torch.nn.functional as F
from core import evaluation
def test(net, criterion, testloader, outloader, epoch=None, **options):
net.eval()
correct, total = 0, 0
torch.cuda.empty_cache()
_pred_k, ... | 1,911 | 29.83871 | 71 | py |
ARPL | ARPL-master/core/train.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
from utils import AverageMeter
def train(net, criterion, optimizer, trainloader, epoch=None, **options):
net.train()
losses = AverageMeter()
torch.cuda.empty_cache()
loss_all = 0
for batch_idx, (data, labels) in ... | 4,503 | 33.646154 | 127 | py |
ARPL | ARPL-master/models/resnetABN.py | import torch.nn as nn
import math
import torch
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
from models.ABN import MultiBatchNorm
from torch.nn.modules.conv import _ConvNd
from torch.nn.modules.utils import _ntuple
from collections import OrderedDict
import operator
from itertools import i... | 10,312 | 34.197952 | 119 | py |
ARPL | ARPL-master/models/resnet.py | '''ResNet in PyTorch.
BasicBlock and Bottleneck module is from the original ResNet paper:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385
PreActBlock and PreActBottleneck module is from the later paper:
[2] Kaiming He, Xiangyu Zhang, Shaoqing Ren,... | 8,250 | 33.814346 | 102 | py |
ARPL | ARPL-master/models/gan.py | ## reference code is https://github.com/pytorch/examples/blob/master/dcgan/main.py
import torch
import torch.nn as nn
import torch.nn.functional as F
import os
import numpy as np
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
m.weight.data.normal_(0.0, 0.02)
... | 6,130 | 33.638418 | 82 | py |
ARPL | ARPL-master/models/ABN.py | from torch import nn
class _MultiBatchNorm(nn.Module):
_version = 2
def __init__(self, num_features, num_classes, eps=1e-5, momentum=0.1, affine=True,
track_running_stats=True):
super(_MultiBatchNorm, self).__init__()
# self.bns = nn.ModuleList([nn.modules.batchnorm._... | 1,210 | 33.6 | 163 | py |
ARPL | ARPL-master/models/models.py | import torch
import torch.nn as nn
from torch.nn import functional as F
from models.ABN import MultiBatchNorm
class ConvNet(nn.Module):
"""LeNet++ as described in the Center Loss paper."""
def __init__(self, num_classes):
super(ConvNet, self).__init__()
self.conv1_1 = nn.Conv2d(3, 32, 5, stride... | 7,737 | 32.068376 | 74 | py |
ARPL | ARPL-master/datasets/datasets.py | import os
import torch
import torchvision
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
from torch.nn import functional as F
import torchvision.transforms as transforms
from torchvision.datasets import MNIST, KMNIST
import numpy as np
from PIL import Image
from utils import mkdir... | 7,319 | 31.972973 | 118 | py |
ARPL | ARPL-master/datasets/osr_dataloader.py | import os
import torch
import numpy as np
from PIL import Image
from torchvision import transforms
from torchvision.datasets import ImageFolder
from torchvision.datasets import MNIST, CIFAR10, CIFAR100, SVHN
class MNISTRGB(MNIST):
"""MNIST Dataset.
"""
def __getitem__(self, index):
img, target = se... | 11,899 | 36.777778 | 121 | py |
ARPL | ARPL-master/loss/Dist.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class Dist(nn.Module):
def __init__(self, num_classes=10, num_centers=1, feat_dim=2, init='random'):
super(Dist, self).__init__()
self.feat_dim = feat_dim
self.num_classes = num_classes
self.num_ce... | 1,590 | 39.794872 | 119 | py |
ARPL | ARPL-master/loss/ARPLoss.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from loss.Dist import Dist
class ARPLoss(nn.CrossEntropyLoss):
def __init__(self, **options):
super(ARPLoss, self).__init__()
self.use_gpu = options['use_gpu']
self.weight_pl = float(options['weight_pl'])
self.temp =... | 1,422 | 32.880952 | 90 | py |
ARPL | ARPL-master/loss/GCPLoss.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from loss.Dist import Dist
class GCPLoss(nn.CrossEntropyLoss):
def __init__(self, **options):
super(GCPLoss, self).__init__()
self.weight_pl = options['weight_pl']
self.temp = options['temp']
self.Dist = Dist(num_cla... | 771 | 34.090909 | 93 | py |
ARPL | ARPL-master/loss/Softmax.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class Softmax(nn.Module):
def __init__(self, **options):
super(Softmax, self).__init__()
self.temp = options['temp']
def forward(self, x, y, labels=None):
logits = F.softmax(y, dim=1)
if labels is None: return l... | 411 | 26.466667 | 53 | py |
ARPL | ARPL-master/loss/RPLoss.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from loss.Dist import Dist
class RPLoss(nn.CrossEntropyLoss):
def __init__(self, **options):
super(RPLoss, self).__init__()
self.weight_pl = float(options['weight_pl'])
self.temp = options['temp']
self.Dist = Dist(nu... | 982 | 31.766667 | 126 | py |
AUQADMM | AUQADMM-main/main.py | #main
!wget www.di.ens.fr/~lelarge/MNIST.tar.gz
!tar -zxvf MNIST.tar.gz
# import utils
# import AUQADMM
import math
import numpy as np
import pywt
import torch
import torchvision
import torch.optim as optim
from torchvision import transforms, datasets
from torchvision.datasets import MNIST
from six.moves import urlli... | 1,813 | 33.226415 | 114 | py |
AUQADMM | AUQADMM-main/Other_ADMM_Algs.py | #For ACADMM, RBADMM, CADMM
def tau_update(method, i, mu_RBADMM, epsilon, C_cg, T_f, tau_list, z_old, z_pprev, z_prev, y_pprev_list, y_prev_list, y_hat_list, y_old_list,
x_prev_list, x_old_list, primal_residual, dual_residual):
if method == 'ACADMM':
if i % T_f == 1:
with torch.n... | 10,278 | 39.468504 | 150 | py |
AUQADMM | AUQADMM-main/utils.py | #utils
#MNIST DataLoader
def mnist_loaders(train_batch_size, test_batch_size=None):
if test_batch_size is None:
test_batch_size = train_batch_size
trainLoader = torch.utils.data.DataLoader(
datasets.MNIST(root = './',
train=True,
download=True,
... | 11,364 | 32.230994 | 126 | py |
AUQADMM | AUQADMM-main/AUQADMM.py | #AUQADMM CLASS
class AUQADMM:
def __init__(self, params, regularizer, rho1, rho2, trainsets, LOSS_NAME):
self.LOSS_NAME = LOSS_NAME
self.U = params
dim1 = params[0].shape[0]; dim2 = params[0].shape[1];
self.dim = 1.0*dim1*dim2
self.Workers = len(self.U)
self.regulari... | 8,672 | 33.831325 | 157 | py |
CognitiveDistillation | CognitiveDistillation-main/evaluate.py | import argparse
import mlconfig
import torch
import time
import models
import datasets
import losses
import torch.nn.functional as F
import util
import os
import sys
import numpy as np
from exp_mgmt import ExperimentManager
if torch.cuda.is_available():
torch.backends.cudnn.enabled = True
torch.backends.cudnn.b... | 9,797 | 33.5 | 81 | py |
CognitiveDistillation | CognitiveDistillation-main/misc.py | # Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
# --------------------------------------------------------
# References:
# DeiT: https://github.com/facebookresearch/deit
#... | 12,878 | 32.27907 | 116 | py |
CognitiveDistillation | CognitiveDistillation-main/extract.py | import argparse
import mlconfig
import torch
import random
import numpy as np
import datasets
import time
import util
import models
import detection
import os
from tqdm import tqdm
from exp_mgmt import ExperimentManager
if torch.cuda.is_available():
torch.backends.cudnn.enabled = True
torch.backends.cudnn.bench... | 6,777 | 37.954023 | 119 | py |
CognitiveDistillation | CognitiveDistillation-main/train_ddp.py | import argparse
import mlconfig
import torch
import time
import models
import datasets
import losses
import torch.nn.functional as F
import util
import os
import sys
import numpy as np
import misc
from exp_mgmt import ExperimentManager
from collections import OrderedDict
from timm.models.layers import trunc_normal_
if ... | 15,269 | 38.35567 | 119 | py |
CognitiveDistillation | CognitiveDistillation-main/detect_analysis.py | import argparse
import mlconfig
import torch
import random
import numpy as np
import datasets
import time
import util
import models
import json
import os
import analysis
from exp_mgmt import ExperimentManager
from sklearn.metrics import roc_auc_score, average_precision_score
from sklearn.metrics import roc_curve, auc, ... | 13,775 | 41.518519 | 119 | py |
CognitiveDistillation | CognitiveDistillation-main/exp_mgmt.py | import os
import util
import datetime
import shutil
import mlconfig
import torch
import json
import misc
from collections import OrderedDict
if torch.cuda.is_available():
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
device = torch.device('cuda')
else:
device = torch.device('... | 4,688 | 36.214286 | 91 | py |
CognitiveDistillation | CognitiveDistillation-main/unlearn_fintune.py | import argparse
import mlconfig
import torch
import torch.nn.functional as F
import time
import models
import datasets
import losses
import util
import os
import sys
import json
import numpy as np
import copy
import analysis
from exp_mgmt import ExperimentManager
from torchvision import transforms
from torch.utils.data... | 16,872 | 39.078385 | 119 | py |
CognitiveDistillation | CognitiveDistillation-main/util.py | import logging
import os
import numpy as np
import torch
import json
import math
import losses
import torch.nn.functional as F
from scipy.spatial.distance import cdist
from torch.utils.data import DataLoader
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
def pa... | 4,516 | 31.035461 | 113 | py |
CognitiveDistillation | CognitiveDistillation-main/train.py | import argparse
import mlconfig
import torch
import time
import models
import datasets
import losses
import torch.nn.functional as F
import util
import os
import sys
import numpy as np
from exp_mgmt import ExperimentManager
if torch.cuda.is_available():
torch.backends.cudnn.enabled = True
torch.backends.cudnn.b... | 10,308 | 33.710438 | 78 | py |
CognitiveDistillation | CognitiveDistillation-main/models/efficientnet.py | import copy
import math
import torch
import torch.nn as nn
from functools import partial
from torchvision.ops.misc import SqueezeExcitation, ConvNormActivation
from torchvision.ops import StochasticDepth
from typing import Sequence
def _make_divisible(v: float, divisor: int, min_value=None):
"""
This function... | 8,464 | 35.021277 | 118 | py |
CognitiveDistillation | CognitiveDistillation-main/models/resnet.py | import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3,
stride=stride, padding=1... | 4,427 | 34.424 | 78 | py |
CognitiveDistillation | CognitiveDistillation-main/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.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
'''expand + depthwise + pointwise'''
def __init__(self, in_p... | 3,144 | 36.891566 | 114 | py |
CognitiveDistillation | CognitiveDistillation-main/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],
'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512],
'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512... | 1,618 | 31.38 | 112 | py |
CognitiveDistillation | CognitiveDistillation-main/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,472 | 33.674419 | 102 | py |
CognitiveDistillation | CognitiveDistillation-main/models/dynamic_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 |
CognitiveDistillation | CognitiveDistillation-main/models/toy_model.py | import torch.nn as nn
class ConvBrunch(nn.Module):
def __init__(self, in_planes, out_planes, kernel_size=3):
super(ConvBrunch, self).__init__()
padding = (kernel_size - 1) // 2
self.out_conv = nn.Sequential(
nn.Conv2d(in_planes, out_planes,
kernel_size=ker... | 1,615 | 30.076923 | 65 | py |
CognitiveDistillation | CognitiveDistillation-main/models/vit.py | # Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
# --------------------------------------------------------
# References:
# timm: https://github.com/rwightman/pytorch-image... | 2,777 | 30.931034 | 110 | py |
CognitiveDistillation | CognitiveDistillation-main/models/celeba_resnet.py | import torch.nn as nn
import torch.utils.model_zoo as model_zoo
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
'res... | 7,742 | 32.519481 | 116 | py |
CognitiveDistillation | CognitiveDistillation-main/models/__init__.py | import mlconfig
import torch
from . import resnet, issba_resnet, dynamic_models, vgg, google_inception, vit, mobilenetv2
from . import efficientnet
from . import preact_resnet
from . import celeba_resnet
from . import toy_model
mlconfig.register(torch.optim.SGD)
mlconfig.register(torch.optim.Adam)
mlconfig.register(t... | 1,047 | 33.933333 | 91 | py |
CognitiveDistillation | CognitiveDistillation-main/models/issba_resnet.py | import torchvision.models as models
import torch
class ResNet18_200(torch.nn.Module):
def __init__(self, num_classes=200):
super(ResNet18_200, self).__init__()
self.model = models.resnet18()
self.model.fc = torch.nn.Linear(self.model.fc.in_features, num_classes)
self.get_features =... | 864 | 26.03125 | 79 | py |
CognitiveDistillation | CognitiveDistillation-main/models/google_inception.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,314 | 30.571429 | 83 | py |
CognitiveDistillation | CognitiveDistillation-main/models/blocks.py | 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:
self.batch_no... | 1,439 | 31.727273 | 102 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_trojan.py | import torch
import numpy as np
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class TrojanCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,
download=Fals... | 1,507 | 37.666667 | 93 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/imagenet_badnet.py | import numpy as np
import PIL
from torchvision import datasets
from torchvision import transforms
class ImageNetSubset(datasets.ImageNet):
def __init__(self, root, split='train', transform=None, target_transform=None,
download=False, poison_rate=0.1, target_label=0, **kwargs):
super().__i... | 3,033 | 38.921053 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_blend.py | import torch
import numpy as np
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class BlendCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,
download=False... | 1,523 | 39.105263 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_wanet.py | import torch
import numpy as np
import torch.nn.functional as F
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class WaNetCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,... | 2,168 | 39.166667 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_cl.py | import torch
import numpy as np
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class CLCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,
download=False, p... | 2,292 | 37.216667 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_nashville.py | import torch
import numpy as np
import pilgram
from torchvision import datasets
from PIL import Image
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class NashvilleCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transf... | 1,562 | 36.214286 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/mixed_mnist.py | import torch
import numpy as np
import os
from torchvision import datasets
from PIL import Image
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class MIXED_MNIST(datasets.MNIST):
def __init__(self, root, train=True, transform=None, target_transform=None,
... | 1,736 | 34.44898 | 80 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_custom.py | import torch
import numpy as np
from torchvision import datasets
from PIL import Image
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class CustomCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,
... | 1,302 | 36.228571 | 79 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_badnet_adaptive.py | import torch
import numpy as np
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class BadNetAdaptiveCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None, trigger_size=3,
... | 1,591 | 40.894737 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_dynamic.py | import torch
import numpy as np
import models
from torchvision import datasets
from torchvision import transforms
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
def create_bd(netG, netM, inputs, targets, opt):
patterns = netG(inputs)
masks_output = netM... | 2,525 | 37.272727 | 101 | py |
CognitiveDistillation | CognitiveDistillation-main/datasets/cifar_badnet.py | import torch
import numpy as np
from torchvision import datasets
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
class BadNetCIFAR10(datasets.CIFAR10):
def __init__(self, root, train=True, transform=None, target_transform=None,
download=Fals... | 1,772 | 40.232558 | 101 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.