repo stringlengths 2 99 | file stringlengths 14 239 | code stringlengths 20 3.99M | file_length int64 20 3.99M | avg_line_length float64 9.73 128 | max_line_length int64 11 86.4k | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
PyKrige | PyKrige-main/src/pykrige/kriging_tools.py | """
PyKrige
=======
Code by Benjamin S. Murphy and the PyKrige Developers
bscott.murphy@gmail.com
Summary
-------
Methods for reading/writing ASCII grid files.
Copyright (c) 2015-2020, PyKrige Developers
"""
import datetime
import io
import os
import warnings
import numpy as np
def write_asc_grid(x, y, z, filenam... | 15,629 | 32.612903 | 88 | py |
PyKrige | PyKrige-main/docs/source/sphinxext/github_link.py | # Adapted from scikit learn
import inspect
import os
import subprocess
import sys
from functools import partial
from operator import attrgetter
REVISION_CMD = "git rev-parse --short HEAD"
def _get_git_revision():
try:
revision = subprocess.check_output(REVISION_CMD.split()).strip()
except (subproces... | 2,645 | 29.767442 | 85 | py |
optisplit | optisplit-main/mean.py | import pandas as pd
import os
import numpy as np
from pdb import set_trace as bp
import sys
from pathlib import Path
"""Calculate means of result files."""
def sort_dfs(dfs):
res = []
for df in dfs:
start = df.iloc[:4,:].sort_values(by=[' method'], ascending=False)
end = df.iloc[4:,:].sort_val... | 1,226 | 26.266667 | 161 | py |
optisplit | optisplit-main/evaluation_metric_experiment.py | import numpy as np
import joblib
import matplotlib.pyplot as plt
import scipy.sparse as sp
import warnings
from copy import deepcopy
from pdb import set_trace as bp
from textwrap import wrap
import cv_balance
np.set_printoptions(formatter={'float': lambda x: "{0:0.5f}".format(x)})
warnings.filterwarnings('ignore', m... | 6,729 | 29.87156 | 144 | py |
optisplit | optisplit-main/cv_comparison_experiment.py | import argparse
import sys
import time
import arff
import joblib
import numpy as np
import scipy.sparse as sp
from copy import deepcopy
from datetime import timedelta
from joblib import Parallel, delayed
from pdb import set_trace as bp
from skmultilearn.model_selection import IterativeStratification
from cv_balance ... | 9,525 | 37.723577 | 166 | py |
optisplit | optisplit-main/cv_balance.py | import time
import numpy as np
import scipy.sparse as sp
from copy import deepcopy
from datetime import timedelta
from pdb import set_trace as bp
def rld(folds, targets):
tt = deepcopy(targets)
res = []
di = np.array(tt.sum(axis=0)).ravel() / tt.shape[0]
for f in folds:
pij = np.array(tt[f[1]... | 7,298 | 31.29646 | 152 | py |
optisplit | optisplit-main/stratified_sampling_for_XML/stratify_function/stratify.py | import random
import numpy as np
from datetime import datetime
import helper_funcs
def stratified_train_test_split(X, y, target_test_size, random_state=None, epochs=50, swap_probability=0.1, threshold_proportion=0.1, decay=0.1):
if random_state != None:
random.seed(random_state)
# To keep track of ho... | 4,788 | 40.284483 | 147 | py |
optisplit | optisplit-main/stratified_sampling_for_XML/stratify_function/helper_funcs.py | import random
import numpy as np
# 1. Create instances_dict to keep track of instance information:
# labels: array of labels, []
# train_or_test: string, 'train' or 'test'
# instance_score: float, adjusted sum of label scores
def create_instances_dict(X, y, target_test_size):
instances_dict = {}
instance_id = ... | 6,577 | 47.014599 | 127 | py |
PC-JeDi | PC-JeDi-main/src/plotting.py | from copy import deepcopy
from functools import partial
from pathlib import Path
from typing import Optional, Union
import matplotlib.pyplot as plt
import numpy as np
import PIL
import wandb
from jetnet.utils import efps
def plot_multi_hists(
data_list: Union[list, np.ndarray],
data_labels: Union[list, str],... | 14,847 | 36.589873 | 87 | py |
PC-JeDi | PC-JeDi-main/src/physics.py | # import jetnet
import numpy as np
import pytorch_lightning as pl
import torch as T
# FIX RANDOM SEED FOR REPRODUCIBILITY
pl.seed_everything(0, workers=True)
def locals_to_mass_and_pt(csts: T.Tensor, mask: T.BoolTensor) -> T.Tensor:
"""Calculate the overall jet pt and mass from the constituents. The
constitu... | 2,120 | 30.191176 | 84 | py |
PC-JeDi | PC-JeDi-main/src/numpy_utils.py | import numpy as np
def undo_log_squash(data: np.ndarray) -> np.ndarray:
"""Undo the log squash function above."""
return np.sign(data) * (np.exp(np.abs(data)) - 1)
def log_squash(data: np.ndarray) -> np.ndarray:
"""Apply a log squashing function for distributions with high tails."""
return np.sign(d... | 352 | 28.416667 | 75 | py |
PC-JeDi | PC-JeDi-main/src/torch_utils.py | from typing import Union
import numpy as np
import torch as T
import torch.nn as nn
def get_loss_fn(name: str, **kwargs) -> nn.Module:
"""Return a pytorch loss function given a name."""
if name == "none":
return None
# Regression losses
if name == "huber":
return nn.HuberLoss(reducti... | 918 | 26.848485 | 77 | py |
PC-JeDi | PC-JeDi-main/src/hydra_utils.py | """A collection of misculaneous functions usefull for the lighting/hydra
template."""
import logging
import os
from pathlib import Path
from typing import Any, List, Sequence
import hydra
import rich
import rich.syntax
import rich.tree
import wandb
from omegaconf import DictConfig, OmegaConf
from pytorch_lightning im... | 5,097 | 30.8625 | 86 | py |
PC-JeDi | PC-JeDi-main/src/datamodules/jetnet.py | from copy import deepcopy
from typing import Mapping
import numpy as np
from jetnet.datasets import JetNet
from pytorch_lightning import LightningDataModule
from torch.utils.data import DataLoader, Dataset
from src.numpy_utils import log_squash
from src.physics import numpy_locals_to_mass_and_pt
class JetNetData(Da... | 3,490 | 34.989691 | 86 | py |
PC-JeDi | PC-JeDi-main/src/models/diffusion.py | import math
from typing import Optional, Tuple
import torch as T
from tqdm import tqdm
class VPDiffusionSchedule:
def __init__(self, max_sr: float = 1, min_sr: float = 1e-2) -> None:
self.max_sr = max_sr
self.min_sr = min_sr
def __call__(self, time: T.Tensor) -> T.Tensor:
return cosi... | 11,263 | 33.873065 | 86 | py |
PC-JeDi | PC-JeDi-main/src/models/transformers.py | """Some classes to describe transformer architectures."""
import math
from typing import Mapping, Optional, Union
import torch as T
import torch.nn as nn
from torch.nn.functional import dropout, softmax
from .modules import DenseNetwork
def merge_masks(
q_mask: Union[T.BoolTensor, None],
kv_mask: Union[T.B... | 15,049 | 33.837963 | 87 | py |
PC-JeDi | PC-JeDi-main/src/models/schedulers.py | from torch.optim import Optimizer
from torch.optim.lr_scheduler import _LRScheduler
class WarmupToConstant(_LRScheduler):
"""Gradually warm-up learning rate in optimizer to a constant value."""
def __init__(self, optimizer: Optimizer, num_steps: int = 100) -> None:
"""
args:
optim... | 793 | 32.083333 | 85 | py |
PC-JeDi | PC-JeDi-main/src/models/modules.py | """Collection of pytorch modules that make up the networks."""
import math
from typing import Optional, Union
import torch as T
import torch.nn as nn
def get_act(name: str) -> nn.Module:
"""Return a pytorch activation function given a name."""
if name == "relu":
return nn.ReLU()
if name == "lrlu... | 20,518 | 35.575758 | 90 | py |
PC-JeDi | PC-JeDi-main/src/models/pc_jedi.py | import copy
from functools import partial
from typing import Mapping, Optional, Tuple
import numpy as np
import pytorch_lightning as pl
import torch as T
import wandb
from jetnet.evaluation import w1efp, w1m, w1p
from src.models.diffusion import VPDiffusionSchedule, run_sampler
from src.models.modules import CosineEn... | 12,805 | 38.403077 | 87 | py |
PC-JeDi | PC-JeDi-main/scripts/train.py | import pyrootutils
root = pyrootutils.setup_root(search_from=__file__, pythonpath=True)
import logging
import hydra
import pytorch_lightning as pl
from omegaconf import DictConfig
from src.hydra_utils import (
instantiate_collection,
log_hyperparameters,
print_config,
reload_original_config,
sav... | 1,731 | 23.742857 | 87 | py |
trees_from_transformers | trees_from_transformers-master/run.py | import argparse
import datetime
import logging
import os
import pickle
from tqdm import tqdm
import torch
from transformers import *
from data.dataset import Dataset
from utils.measure import Measure
from utils.parser import not_coo_parser, parser
from utils.tools import set_seed, select_indices, group_indices
from u... | 11,441 | 45.893443 | 85 | py |
trees_from_transformers | trees_from_transformers-master/utils/yk.py | """
The functions in this file are originated from the code for
Compound Probabilistic Context-Free Grammars for Grammar Induction,
Y. Kim et al., ACL 2019.
For more details, visit https://github.com/harvardnlp/compound-pcfg.
"""
import re
def clean_number(w):
new_w = re.sub('[0-9]{1,}([,.]?[0-9]*)*', 'N', w)
... | 4,935 | 29.097561 | 78 | py |
trees_from_transformers | trees_from_transformers-master/utils/parser.py | import numpy as np
def not_coo_parser(score, sent):
assert len(score) == len(sent) - 1
if len(score) == 0:
parse_tree = f'(T {sent[0]} )'
elif len(score) == 1:
parse_tree = f'(T (T {sent[0]} ) (T {sent[1]} ) )'
else:
idx_max = np.argmax(score)
l_len = len(sent[:idx_max... | 1,936 | 33.589286 | 80 | py |
trees_from_transformers | trees_from_transformers-master/utils/score.py | import numpy as np
import torch
from utils.yk import get_stats
class Score(object):
def __init__(self, n):
self.corpus_f1 = torch.zeros(n, 3, dtype=torch.float)
self.sent_f1 = torch.zeros(n, dtype=torch.float)
self.n = n
self.cnt = 0
self.labels = ['SBAR', 'NP', 'VP', 'PP'... | 2,521 | 35.550725 | 79 | py |
trees_from_transformers | trees_from_transformers-master/utils/tools.py | import logging
import random
import torch
specials = {'bert': '#', 'gpt2': 'Ġ', 'xlnet': '▁', 'roberta': 'Ġ'}
def set_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
random.seed(seed)
def select_indices(tokens, raw_tokens, model, mode):
mask = []
raw_i = 0
collapsed = ''
... | 1,612 | 24.603175 | 68 | py |
trees_from_transformers | trees_from_transformers-master/utils/extractor.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class Extractor(nn.Module):
def __init__(self, n_hidden):
super(Extractor, self).__init__()
self.linear = nn.Linear(n_hidden * 2, 1)
nn.init.uniform_(self.linear.weight, -0.01, 0.01)
nn.init.uniform_(self.linear.bias... | 752 | 27.961538 | 77 | py |
trees_from_transformers | trees_from_transformers-master/utils/measure.py | import math
import torch
import torch.nn.functional as F
from utils.score import Score
class Measure(object):
def __init__(self, n_layers, n_att):
self.h_measures = ['cos', 'l1', 'l2']
self.a_measures = ['hellinger', 'jsd']
self.a_avg_measures = ['avg_hellinger', 'avg_jsd']
self.m... | 3,102 | 33.477778 | 82 | py |
trees_from_transformers | trees_from_transformers-master/data/dataset.py | from utils.yk import get_actions, get_nonbinary_spans, get_tags_tokens_lowercase
class Dataset(object):
def __init__(self, path, tokenizer):
self.path = path
self.tokenizer = tokenizer
self.cnt = 0
self.sents = []
self.raw_tokens = []
self.tokens = []
self.... | 1,271 | 32.473684 | 80 | py |
SSTAP | SSTAP-main/main.py | import sys
from dataset import VideoDataSet, VideoDataSet_unlabel
from loss_function import bmn_loss_func, get_mask
import os
import json
import torch
import torch.nn.parallel
import torch.nn.functional as F
import torch.nn as nn
import torch.optim as optim
import numpy as np
import opts
from ipdb import set_trace
from... | 42,436 | 48.173812 | 190 | py |
SSTAP | SSTAP-main/gen_unlabel_videos.py | import numpy as np
import pandas as pd
import json
import random
def load_json(file):
with open(file) as json_file:
json_data = json.load(json_file)
return json_data
anno_df = pd.read_csv("./data/activitynet_annotations/video_info_new.csv")
anno_database = load_json("./data/activitynet_annotatio... | 2,370 | 36.046875 | 115 | py |
SSTAP | SSTAP-main/opts.py | import argparse
def parse_opt():
parser = argparse.ArgumentParser()
# Overall settings
parser.add_argument(
'--mode',
type=str,
default='train')
parser.add_argument(
'--checkpoint_path',
type=str,
default='./checkpoint')
parser.add_argument(
... | 2,615 | 21.747826 | 71 | py |
SSTAP | SSTAP-main/utils.py | import numpy as np
def ioa_with_anchors(anchors_min, anchors_max, box_min, box_max):
# calculate the overlap proportion between the anchor and all bbox for supervise signal,
# the length of the anchor is 0.01
len_anchors = anchors_max - anchors_min
int_xmin = np.maximum(anchors_min, box_min)
int_x... | 960 | 37.44 | 92 | py |
SSTAP | SSTAP-main/dataset.py | import numpy as np
import pandas as pd
import json
import torch.utils.data as data
import torch
from utils import ioa_with_anchors, iou_with_anchors
from ipdb import set_trace
def load_json(file):
with open(file) as json_file:
json_data = json.load(json_file)
return json_data
class VideoDataSet(... | 14,230 | 51.707407 | 155 | py |
SSTAP | SSTAP-main/loss_function.py | import torch
import numpy as np
import torch.nn.functional as F
def get_mask(tscale):
bm_mask = []
for idx in range(tscale):
mask_vector = [1 for i in range(tscale - idx)
] + [0 for i in range(idx)]
bm_mask.append(mask_vector)
bm_mask = np.array(bm_mask, dtype=np.flo... | 3,482 | 32.171429 | 90 | py |
SSTAP | SSTAP-main/eval.py | import sys
import warnings
warnings.filterwarnings('ignore')
sys.path.append('./Evaluation')
from eval_proposal import ANETproposal
import matplotlib.pyplot as plt
import numpy as np
def run_evaluation(ground_truth_filename, proposal_filename,
max_avg_nr_proposals=100,
tiou_thre... | 3,247 | 44.111111 | 122 | py |
SSTAP | SSTAP-main/models.py | import math
import numpy as np
import torch
import torch.nn as nn
from ipdb import set_trace
import random
import torch.nn.functional as F
class TemporalShift(nn.Module):
def __init__(self, n_segment=3, n_div=8, inplace=False):
super(TemporalShift, self).__init__()
# self.net = net
self.n_... | 13,366 | 43.115512 | 138 | py |
SSTAP | SSTAP-main/data/activitynet_feature_cuhk/data_process.py |
import random
import numpy as np
import scipy
import pandas as pd
import pandas
import numpy
import json
def resizeFeature(inputData,newSize):
# inputX: (temporal_length,feature_dimension) #
originalSize=len(inputData)
#print originalSize
if originalSize==1:
inputData=np.reshape(inputData,[-1... | 4,484 | 31.737226 | 103 | py |
SSTAP | SSTAP-main/data/activitynet_feature_cuhk/ldb_process.py | """
Created on Mon May 15 22:31:31 2017
@author: wzmsltw
"""
import caffe
import leveldb
import numpy as np
from caffe.proto import caffe_pb2
import pandas as pd
col_names=[]
for i in range(200):
col_names.append("f"+str(i))
df=pd.read_table("./input_spatial_list.txt",names=['image','frame','label'],sep=" ")
db... | 983 | 21.883721 | 84 | py |
SSTAP | SSTAP-main/Evaluation/eval_proposal.py | import json
import numpy as np
import pandas as pd
def interpolated_prec_rec(prec, rec):
"""Interpolated AP - VOCdevkit from VOC 2011.
"""
mprec = np.hstack([[0], prec, [0]])
mrec = np.hstack([[0], rec, [1]])
for i in range(len(mprec) - 1)[::-1]:
mprec[i] = max(mprec[i], mprec[i + 1])
... | 13,318 | 38.877246 | 119 | py |
SSTAP | SSTAP-main/Evaluation/utils.py | import json
import urllib2
import numpy as np
API = 'http://ec2-52-11-11-89.us-west-2.compute.amazonaws.com/challenge16/api.py'
def get_blocked_videos(api=API):
api_url = '{}?action=get_blocked'.format(api)
req = urllib2.Request(api_url)
response = urllib2.urlopen(req)
return json.loads(response.read... | 2,648 | 33.855263 | 81 | py |
xSLHA | xSLHA-master/setup.py | import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="xslha",
version="1.0.2",
author="Florian Staub",
author_email="florian.staub@gmail.com",
description="A python package to read (big/many) SLHA files",
long_description=long_description... | 710 | 28.625 | 65 | py |
xSLHA | xSLHA-master/xslha/main.py | import subprocess
import os
from six import string_types
# SLHA parser
# SLHA Class
class SLHA():
def __init__(self):
self.blocks = {}
self.br = {}
self.widths = {}
self.br1L = {}
self.widths1L = {}
self.xsections = {}
self.block_name = None
self... | 10,207 | 34.817544 | 90 | py |
enterprise_extensions | enterprise_extensions-master/setup.py |
"""The setup script."""
from setuptools import setup
with open("README.rst") as readme_file:
readme = readme_file.read()
with open("HISTORY.rst") as history_file:
history = history_file.read()
requirements = [
"numpy>=1.16.3",
"scipy>=1.2.0",
"ephem>=3.7.6.0",
"healpy>=1.14.0",
"scikit-... | 2,094 | 27.310811 | 104 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/hypermodel.py |
import os
import numpy as np
import scipy.linalg as sl
from enterprise import constants as const
from PTMCMCSampler.PTMCMCSampler import PTSampler as ptmcmc
from .sampler import JumpProposal, get_parameter_groups, save_runtime_info
class HyperModel(object):
"""
Class to define hyper-model that is the conc... | 16,731 | 37.200913 | 102 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/gp_kernels.py |
import numpy as np
from enterprise.signals import signal_base, utils
__all__ = ['linear_interp_basis_dm',
'linear_interp_basis_freq',
'dmx_ridge_prior',
'periodic_kernel',
'se_kernel',
'se_dm_kernel',
'get_tf_quantization_matrix',
'tf_kernel... | 5,878 | 28.691919 | 86 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/deterministic.py |
import numpy as np
from enterprise import constants as const
from enterprise.signals import (deterministic_signals, parameter, signal_base,
utils)
def fdm_block(Tmin, Tmax, amp_prior='log-uniform', name='fdm',
amp_lower=-18, amp_upper=-11,
freq_lower=-9, fr... | 26,111 | 34.334235 | 116 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/sampler.py |
import glob
import os
import pickle
import platform
import healpy as hp
import numpy as np
from PTMCMCSampler import __version__ as __vPTMCMC__
from PTMCMCSampler.PTMCMCSampler import PTSampler as ptmcmc
from enterprise_extensions import __version__
from enterprise_extensions.empirical_distr import (EmpiricalDistrib... | 47,414 | 37.330639 | 165 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/model_utils.py |
import time
import matplotlib.pyplot as plt
import numpy as np
import scipy.stats as scistats
try:
import acor
except ImportError:
from emcee.autocorr import integrated_time as acor
from enterprise_extensions import models
# Log-spaced frequncies
def linBinning(T, logmode, f_min, nlin, nlog):
"""
... | 12,737 | 31.914729 | 115 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/empirical_distr.py |
import logging
import pickle
import numpy as np
try:
from sklearn.neighbors import KernelDensity
sklearn_available=True
except ModuleNotFoundError:
sklearn_available=False
from scipy.interpolate import interp1d, interp2d
logger = logging.getLogger(__name__)
class EmpiricalDistribution1D(object):
"... | 12,755 | 35.033898 | 149 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/sky_scrambles.py |
import pickle
import sys
import time
import numpy as np
from enterprise.signals import utils
def compute_match(orf1, orf1_mag, orf2, orf2_mag):
"""Computes the match between two different ORFs."""
match = np.abs(np.dot(orf1, orf2))/(orf1_mag*orf2_mag)
return match
def make_true_orf(psrs):
"""Com... | 6,532 | 33.75 | 111 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/timing.py |
from collections import OrderedDict
import numpy as np
from enterprise.signals import deterministic_signals, parameter, signal_base
# timing model delay
@signal_base.function
def tm_delay(residuals, t2pulsar, tmparams_orig, tmparams, which='all'):
"""
Compute difference in residuals due to perturbed timing... | 2,236 | 31.897059 | 80 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/dropout.py |
import enterprise
import numpy as np
from enterprise import constants as const
from enterprise.signals import (deterministic_signals,
parameter,
signal_base,
utils)
@signal_base.function
def dropout_powerlaw(f, name, log... | 8,010 | 39.872449 | 87 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/models.py |
import functools
from collections import OrderedDict
import numpy as np
from enterprise import constants as const
from enterprise.signals import (deterministic_signals, gp_signals, parameter,
selections, signal_base, white_signals)
from enterprise.signals.signal_base import LogLikeliho... | 122,774 | 41.973399 | 152 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/blocks.py |
import types
import numpy as np
from enterprise import constants as const
from enterprise.signals import deterministic_signals
from enterprise.signals import gp_bases as gpb
from enterprise.signals import gp_priors as gpp
from enterprise.signals import (gp_signals, parameter, selections, utils,
... | 34,848 | 42.506866 | 119 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/chromatic/chromatic.py |
import numpy as np
from enterprise import constants as const
from enterprise.signals import deterministic_signals, parameter, signal_base
__all__ = ['chrom_exp_decay',
'chrom_exp_cusp',
'chrom_dual_exp_cusp',
'chrom_yearly_sinusoid',
'chromatic_quad_basis',
'chro... | 12,928 | 33.569519 | 96 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/chromatic/solar_wind.py |
import os
import numpy as np
import scipy.stats as sps
import scipy.special as spsf
from enterprise import constants as const
from enterprise.signals import (deterministic_signals, gp_signals, parameter,
signal_base, utils)
from .. import gp_kernels as gpk
defpath = os.path.dirname(... | 13,958 | 35.637795 | 81 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/frequentist/optimal_statistic.py |
import warnings
import numpy as np
import scipy.linalg as sl
from enterprise.signals import gp_priors, signal_base, utils
from enterprise_extensions import model_orfs, models
# Define the output to be on a single line.
def warning_on_one_line(message, category, filename, lineno, file=None, line=None):
return '... | 17,367 | 38.205418 | 120 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/frequentist/Fe_statistic.py |
import numpy as np
import scipy.linalg as sl
from enterprise.signals import (gp_signals, parameter, signal_base, utils,
white_signals)
class FeStat(object):
"""
Class for the Fe-statistic.
:param psrs: List of `enterprise` Pulsar instances.
:param params: Dictionary o... | 8,981 | 35.661224 | 118 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/frequentist/F_statistic.py |
import numpy as np
import scipy.special
from enterprise.signals import deterministic_signals, gp_signals, signal_base
from enterprise_extensions import blocks, deterministic
def get_xCy(Nvec, T, sigmainv, x, y):
"""Get x^T C^{-1} y"""
TNx = Nvec.solve(x, left_array=T)
TNy = Nvec.solve(y, left_array=T)
... | 5,418 | 33.297468 | 112 | py |
enterprise_extensions | enterprise_extensions-master/enterprise_extensions/frequentist/chi_squared.py |
import numpy as np
import scipy.linalg as sl
def get_chi2(pta, xs):
"""Compute generalize chisq for pta:
chisq = y^T (N + F phi F^T)^-1 y
= y^T N^-1 y - y^T N^-1 F (F^T N^-1 F + phi^-1)^-1 F^T N^-1 y
"""
params = xs if isinstance(xs, dict) else pta.map_params(xs)
# chisq = y^T... | 1,704 | 29.446429 | 81 | py |
Graph-Unlearning | Graph-Unlearning-main/main.py | import logging
import torch
from exp.exp_graph_partition import ExpGraphPartition
from exp.exp_node_edge_unlearning import ExpNodeEdgeUnlearning
from exp.exp_unlearning import ExpUnlearning
from exp.exp_attack_unlearning import ExpAttackUnlearning
from parameter_parser import parameter_parser
def config_logger(save... | 1,499 | 27.846154 | 131 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_node_embedding/node_embedding.py | import logging
import config
from lib_gnn_model.graphsage.graphsage import SAGE
from lib_dataset.data_store import DataStore
class NodeEmbedding:
def __init__(self, args, graph, data):
super(NodeEmbedding, self)
self.logger = logging.getLogger(__name__)
self.args = args
self.grap... | 1,606 | 34.711111 | 103 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_node_embedding/ge/walker.py | import itertools
import math
import random
import numpy as np
import pandas as pd
from joblib import Parallel, delayed
from tqdm import trange
from .alias import alias_sample, create_alias_table
from .utils import partition_num
class RandomWalker:
def __init__(self, G, p=1, q=1, use_rejection_sampling=0):
... | 9,789 | 34.34296 | 136 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_node_embedding/ge/classify.py | from __future__ import print_function
import numpy
from sklearn.metrics import f1_score, accuracy_score
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import MultiLabelBinarizer
class TopKRanker(OneVsRestClassifier):
def predict(self, X, top_k_list):
probs = numpy.asarray(... | 2,772 | 31.244186 | 78 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_node_embedding/ge/alias.py | import numpy as np
def create_alias_table(area_ratio):
"""
:param area_ratio: sum(area_ratio)=1
:return: accept,alias
"""
l = len(area_ratio)
accept, alias = [0] * l, [0] * l
small, large = [], []
area_ratio_ = np.array(area_ratio) * l
for i, prob in enumerate(area_ratio_):
... | 1,261 | 21.945455 | 59 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_node_embedding/ge/utils.py | def preprocess_nxgraph(graph):
node2idx = {}
idx2node = []
node_size = 0
for node in graph.nodes():
node2idx[node] = node_size
idx2node.append(node)
node_size += 1
return idx2node, node2idx
def partition_dict(vertices, workers):
batch_size = (len(vertices) - 1) // worke... | 1,191 | 23.326531 | 55 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_utils/utils.py | import os
import errno
import numpy as np
import pandas as pd
import networkx as nx
import torch
from scipy.sparse import coo_matrix
from tqdm import tqdm
def graph_reader(path):
"""
Function to read the graph from the path.
:param path: Path to the edge list.
:return graph: NetworkX object returned.... | 4,851 | 27.046243 | 117 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_utils/logger.py | from texttable import Texttable
def tab_printer(args):
"""
Function to print the logs in a nice tabular format.
:param args: Parameters used for the model.
"""
# args = vars(args)
keys = sorted(args.keys())
t = Texttable()
t.add_rows([["Parameter", "Value"]] + [[k.replace("_"," ").capi... | 373 | 30.166667 | 101 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_aggregator/opt_dataset.py | from torch.utils.data import Dataset
class OptDataset(Dataset):
def __init__(self, posteriors, labels):
self.posteriors = posteriors
self.labels = labels
def __getitem__(self, index):
ret_posterior = {}
for shard, post in self.posteriors.items():
ret_posterior[sha... | 448 | 22.631579 | 51 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_aggregator/optimal_aggregator.py | import copy
import logging
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import optim
from torch.optim.lr_scheduler import MultiStepLR
from torch.utils.data import DataLoader
from torch_geometric.data import Data
from lib_aggregator.opt_dataset import OptDataset
from... | 4,054 | 37.990385 | 120 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_aggregator/aggregator.py | import logging
import torch
torch.cuda.empty_cache()
from sklearn.metrics import f1_score
import numpy as np
from lib_aggregator.optimal_aggregator import OptimalAggregator
from lib_dataset.data_store import DataStore
class Aggregator:
def __init__(self, run, target_model, data, shard_data, args):
self... | 2,958 | 35.9875 | 117 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/constrained_kmeans.py | import logging
import copy
from tqdm import tqdm
import numpy as np
import cupy as np
class ConstrainedKmeans:
def __init__(self, data_feat, num_clusters, node_threshold, terminate_delta, max_iteration=20):
self.logger = logging.getLogger('constrained_kmeans')
self.data_feat = data_feat
... | 4,038 | 34.743363 | 118 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/graph_partition.py | import logging
from lib_graph_partition.partition_kmeans import PartitionKMeans
from lib_graph_partition.partition_lpa import PartitionConstrainedLPA, PartitionLPA, PartitionConstrainedLPABase
from lib_graph_partition.metis_partition import MetisPartition
from lib_graph_partition.partition_random import PartitionRando... | 1,708 | 42.820513 | 112 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/constrained_kmeans_base.py | # An implementation of ``Balanced K-Means for Clustering.'' (https://rdcu.be/cESzk)
import logging
import copy
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from munkres import Munkres
from lib_graph_partition.hungarian import Hungarian
from lib_graph_partition.hungarian_1 import KMMatcher
... | 4,307 | 35.820513 | 118 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/metis_partition.py | import numpy as np
import networkx as nx
import pymetis
from torch_geometric.data import ClusterData
from torch_geometric.utils import from_networkx
from lib_graph_partition.partition import Partition
class MetisPartition(Partition):
def __init__(self, args, graph, dataset):
super(MetisPartition, self)._... | 2,609 | 38.545455 | 170 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/constrained_lpa.py | import copy
import logging
from collections import defaultdict
import numpy as np
class ConstrainedLPA:
def __init__(self, adj, num_communities, node_threshold, terminate_delta):
self.logger = logging.getLogger('constrained_lpa_single')
self.adj = adj
self.num_nodes = adj.shape[0]
... | 5,167 | 38.450382 | 104 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/partition_kmeans.py | import math
import pickle
import cupy as cp
import numpy as np
import logging
from sklearn.cluster import KMeans
import config
from lib_graph_partition.constrained_kmeans_base import ConstrainedKmeansBase
from lib_graph_partition.partition import Partition
from lib_graph_partition.constrained_kmeans import Constrain... | 3,881 | 43.62069 | 124 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/hungarian.py | #!/usr/bin/python
"""
Implementation of the Hungarian (Munkres) Algorithm using Python and NumPy
References: http://www.ams.jhu.edu/~castello/362/Handouts/hungarian.pdf
http://weber.ucsd.edu/~vcrawfor/hungar.pdf
http://en.wikipedia.org/wiki/Hungarian_algorithm
http://www.public.iastate.edu/~ddot... | 19,635 | 40.252101 | 120 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/constrained_lpa_base.py | # An implementation of `` Balanced Label Propagation for Partitioning MassiveGraphs'' (https://stanford.edu/~jugander/papers/wsdm13-blp.pdf)
import copy
import logging
from collections import defaultdict
import numpy as np
import cvxpy as cp
from scipy.stats import linregress
class ConstrainedLPABase:
def __ini... | 8,700 | 45.77957 | 164 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/partition_random.py | import numpy as np
from lib_graph_partition.partition import Partition
class PartitionRandom(Partition):
def __init__(self, args, graph):
super(PartitionRandom, self).__init__(args, graph)
def partition(self):
graph_nodes = np.array(self.graph.nodes)
np.random.shuffle(graph_nodes)
... | 472 | 28.5625 | 82 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/partition.py | import numpy as np
class Partition:
def __init__(self, args, graph, dataset=None):
self.args = args
self.graph = graph
self.dataset = dataset
self.partition_method = self.args['partition_method']
self.num_shards = self.args['num_shards']
self.dataset_name = self.ar... | 738 | 26.37037 | 61 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_graph_partition/hungarian_1.py | '''
reference: https://www.topcoder.com/community/competitive-programming/tutorials/assignment-problem-and-hungarian-algorithm/
'''
import numpy as np
#max weight assignment
class KMMatcher:
## weights : nxm weight matrix (numpy , float), n <= m
def __init__(self, weights):
weights = np.array(weights... | 3,953 | 31.146341 | 123 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gnn_base.py | import logging
import pickle
import torch
class GNNBase:
def __init__(self):
self.logger = logging.getLogger('gnn')
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# self.device = torch.device('cpu')
self.model = None
self.embedding_dim = 0
... | 1,482 | 28.078431 | 82 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/node_classifier.py | import logging
import os
import torch
from sklearn.model_selection import train_test_split
torch.cuda.empty_cache()
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
from torch_geometric.data import NeighborSampler
from torch_geometric.nn.conv.gcn_co... | 7,966 | 38.636816 | 114 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gin/gin.py | import os
import logging
import torch
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid, Reddit
from lib_gnn_model.gnn_base import GNNBase
from lib_gnn_model.gin.gin_net import GINNet
import config
class GIN(GNNBase):
def __init__(self, num_fea... | 2,338 | 31.943662 | 92 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gin/gin_net.py | import torch
import torch.nn.functional as F
from torch.nn import Sequential, Linear, ReLU
from torch_geometric.nn import GINConv
class GINNet(torch.nn.Module):
def __init__(self, num_feats, num_classes):
super(GINNet, self).__init__()
dim = 32
nn1 = Sequential(Linear(num_feats, dim), Re... | 1,558 | 30.18 | 74 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gat/gat_net.py | import torch
import torch.nn.functional as F
from torch_geometric.nn import GATConv
class GATNet(torch.nn.Module):
def __init__(self, num_feats, num_classes, dropout=0.6):
super(GATNet, self).__init__()
self.dropout = dropout
self.conv1 = GATConv(num_feats, 8, heads=8, dropout=self.dropou... | 1,074 | 36.068966 | 117 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gat/gat.py | import logging
import os
import torch
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
import config
from lib_gnn_model.gnn_base import GNNBase
from lib_gnn_model.gat.gat_net import GATNet
class GAT(GNNBase):
def __init__(self, num_feats, num_... | 2,273 | 31.028169 | 92 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/graphsage/graphsage.py | import os
import logging
import torch
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
from torch_geometric.data import NeighborSampler
from lib_gnn_model.graphsage.graphsage_net import SageNet
from lib_gnn_model.gnn_base import GNNBase
import confi... | 4,883 | 39.363636 | 96 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/graphsage/graphsage_net.py | import torch
import torch.nn.functional as F
from torch_geometric.nn import SAGEConv
class SageNet(torch.nn.Module):
def __init__(self, in_channels, hidden_channels, out_channels):
super(SageNet, self).__init__()
self.num_layers = 2
self.convs = torch.nn.ModuleList()
self.convs.a... | 2,154 | 37.482143 | 79 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gcn/gcn_net.py | import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
class GCNNet(torch.nn.Module):
def __init__(self, num_feats, num_classes):
super(GCNNet, self).__init__()
self.conv1 = GCNConv(num_feats, 16, cached=True, add_self_loops=False)
self.conv2 = GCNConv(16, num... | 781 | 31.583333 | 80 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/gcn/gcn.py | import os
import logging
import torch
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
from lib_gnn_model.gnn_base import GNNBase
from lib_gnn_model.gcn.gcn_net import GCNNet
import config
class GCN(GNNBase):
def __init__(self, num_feats, num_... | 2,221 | 31.202899 | 92 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/mlp/mlp.py | import os
import logging
import torch
import torch.nn.functional as F
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
from lib_gnn_model.gnn_base import GNNBase
from lib_gnn_model.mlp.mlpnet import MLPNet
import config
class MLP(GNNBase):
def __init__(self, num_feats, num_c... | 2,518 | 31.294872 | 107 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_gnn_model/mlp/mlpnet.py | from torch import nn
import torch.nn.functional as F
class MLPNet(nn.Module):
def __init__(self, input_size, num_classes):
super(MLPNet, self).__init__()
self.xent = nn.CrossEntropyLoss()
self.layers = nn.Sequential(
nn.Linear(input_size, 250),
nn.Linear(250, 100),... | 668 | 23.777778 | 50 | py |
Graph-Unlearning | Graph-Unlearning-main/exp/exp_graph_partition.py | import logging
import time
import torch
from sklearn.model_selection import train_test_split
import numpy as np
from torch_geometric.data import Data
import torch_geometric as tg
import networkx as nx
from exp.exp import Exp
from lib_utils.utils import connected_component_subgraphs
from lib_graph_partition.graph_part... | 6,423 | 44.560284 | 155 | py |
Graph-Unlearning | Graph-Unlearning-main/exp/exp_attack_unlearning.py | import logging
import time
from collections import defaultdict
import numpy as np
import torch
import torch_geometric as tg
from torch_geometric.data import Data
from scipy.spatial import distance
import config
from exp.exp import Exp
from lib_graph_partition.graph_partition import GraphPartition
from lib_gnn_model.n... | 13,321 | 48.895131 | 154 | py |
Graph-Unlearning | Graph-Unlearning-main/exp/exp.py | import logging
from lib_dataset.data_store import DataStore
class Exp:
def __init__(self, args):
self.logger = logging.getLogger('exp')
self.args = args
self.data_store = DataStore(args)
def load_data(self):
pass
| 258 | 16.266667 | 46 | py |
Graph-Unlearning | Graph-Unlearning-main/exp/exp_node_edge_unlearning.py | import logging
import pickle
import time
from collections import defaultdict
import numpy as np
import torch
from torch_geometric.data import Data
import config
from exp.exp import Exp
from lib_gnn_model.graphsage.graphsage import SAGE
from lib_gnn_model.gat.gat import GAT
from lib_gnn_model.gin.gin import GIN
from l... | 7,194 | 42.606061 | 123 | py |
Graph-Unlearning | Graph-Unlearning-main/exp/exp_unlearning.py | import logging
import time
import numpy as np
from exp.exp import Exp
from lib_gnn_model.graphsage.graphsage import SAGE
from lib_gnn_model.gat.gat import GAT
from lib_gnn_model.gin.gin import GIN
from lib_gnn_model.gcn.gcn import GCN
from lib_gnn_model.mlp.mlp import MLP
from lib_gnn_model.node_classifier import Nod... | 5,345 | 39.195489 | 132 | py |
Graph-Unlearning | Graph-Unlearning-main/lib_dataset/data_store.py | import os
import pickle
import logging
import shutil
import numpy as np
import torch
from torch_geometric.datasets import Planetoid, Coauthor
import torch_geometric.transforms as T
import config
class DataStore:
def __init__(self, args):
self.logger = logging.getLogger('data_store')
self.args = ... | 9,583 | 44.421801 | 129 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.