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 |
|---|---|---|---|---|---|---|
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/data/field.py | # -*- coding: utf-8 -*-
from typing import List
import torch
EOS_TOKEN = "<eos>"
BOS_TOKEN = "<bos>"
UNK_TOKEN = "<unk>"
PAD_TOKEN = "<pad>"
class Field(object):
def __init__(self, bos: bool, eos: bool, pad: bool, unk: bool):
self.bos_token = BOS_TOKEN if bos else None
self.eos_token = EOS_TOKEN... | 2,418 | 25.582418 | 115 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/data/dataset.py | # -*- coding: utf-8 -*-
import random
from collections import namedtuple
from typing import Dict
import torch
from beaver.data.field import Field
Batch = namedtuple("Batch", ['src', 'tgt', 'batch_size'])
Example = namedtuple("Example", ['src', 'tgt'])
class TranslationDataset(object):
def __init__(self,
... | 2,164 | 29.069444 | 89 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/infer/beam.py | # -*- coding: utf-8 -*-
import torch
class Beam(object):
def __init__(self, beam_size, pad, bos, eos, device, lp):
self.size = beam_size
self.alpha = lp
self.scores = torch.full([beam_size], -1e20).float().to(device)
self.scores[0] = 0.
self.hypotheses = torch.full([1, ... | 1,652 | 32.06 | 118 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/infer/translator.py | # -*- coding: utf-8 -*-
import torch
from beaver.infer.beam import Beam
def beam_search(opt, model, src, fields, flag):
batch_size = src.size(0)
beam_size = opt.beam_size
device = src.device
encoder = model.encoder
if flag:
decoder = model.task1_decoder
generator = model.task1_... | 2,156 | 32.184615 | 86 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/model/embeddings.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
def positional_encoding(dim, max_len=5000):
pe = torch.zeros(max_len, dim)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp((torch.arange(0, dim, 2, dtype=torch.float) * -(math.log(10000.0) / dim)))
pe[:, 0::... | 1,313 | 31.04878 | 110 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/model/transformer.py | # -*- coding: utf-8 -*-
import math
import torch
import torch.nn as nn
class FeedForward(nn.Module):
def __init__(self, hidden_size, inner_size, dropout):
super(FeedForward, self).__init__()
self.linear_in = nn.Linear(hidden_size, inner_size, bias=False)
self.linear_out = nn.Linear(inner_... | 6,591 | 35.622222 | 120 | py |
NCLS-Corpora | NCLS-Corpora-master/code/beaver-2task+/beaver/model/nmt_model.py | # -*- coding: utf-8 -*-
from typing import Dict
import torch
import torch.nn as nn
from beaver.model.embeddings import Embedding
from beaver.model.transformer import Decoder, Encoder
class Generator(nn.Module):
def __init__(self, hidden_size: int, tgt_vocab_size: int):
self.vocab_size = tgt_vocab_size
... | 4,315 | 38.962963 | 100 | py |
rpn_bo | rpn_bo-main/Code and results/brusselator_pde_MLP.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
#
from jax import vmap, random, jit
from jax import numpy as np
import numpy as onp
from rpn_bo_utilities import uniform_prior
from rpn_bo_models import EnsembleRegression
from rpn_bo_dataloaders import BootstrapLoader
from rpn_bo_acquisitions import MCAcqu... | 6,056 | 32.65 | 150 | py |
rpn_bo | rpn_bo-main/Code and results/environmental_model_function_DON.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
import numpy as onp
from rpn_bo_utilities import uniform_prior
from rpn_bo_models import ParallelDeepOnet
from rpn_bo_dataloaders import DataGenerator_batch
from rpn_bo_acquisitions import MCAcq... | 5,739 | 32.764706 | 126 | py |
rpn_bo | rpn_bo-main/Code and results/brusselator_pde_DON.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
from pyDOE import lhs
import numpy as onp
from rpn_bo_utilities import uniform_prior, output_weights
from rpn_bo_models import ParallelDeepOnet
from rpn_bo_dataloaders import DataGenerator_batch... | 6,387 | 35.090395 | 199 | py |
rpn_bo | rpn_bo-main/Code and results/environmental_model_function_MLP.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
import numpy as onp
from rpn_bo_utilities import uniform_prior
from rpn_bo_models import EnsembleRegression
from rpn_bo_dataloaders import BootstrapLoader
from rpn_bo_acquisitions import MCAcqui... | 5,266 | 33.424837 | 126 | py |
rpn_bo | rpn_bo-main/Code and results/rpn_bo_architectures.py | from jax import numpy as np
from jax import random
def MLP(layers, activation=np.tanh):
def init(rng_key):
def init_layer(key, d_in, d_out):
k1, k2 = random.split(key)
glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
W = glorot_stddev*random.normal(k1, (d_in, d_out))
... | 783 | 33.086957 | 69 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_MLP_step_0.py | from jax import numpy as np
from jax.scipy.special import logsumexp
from jax import vmap
N_y = 64 # each frame is an N_y by N_y image
xx, yy = np.meshgrid( np.arange(N_y) / N_y, np.arange(N_y) / N_y )
# prediction function mapping vectorial output to scalar obective value
def output(y):
y = y.reshape((16,N_y,N_y)... | 1,179 | 37.064516 | 144 | py |
rpn_bo | rpn_bo-main/Code and results/rpn_bo_acquisitions.py | from jax import numpy as np
from jax import jit, vjp, random
from jax.scipy.special import expit as sigmoid
import numpy as onp
from functools import partial
from pyDOE import lhs
from tqdm import trange
from rpn_bo_optimizers import minimize_lbfgs
class MCAcquisition:
def __init__(self, posterior, bounds, *args,... | 5,600 | 42.418605 | 116 | py |
rpn_bo | rpn_bo-main/Code and results/rpn_bo_models.py | from jax import numpy as np
from jax import grad, vmap, random, jit
from jax.example_libraries import optimizers
from jax.nn import relu, gelu
from functools import partial
from tqdm import trange
import itertools
from rpn_bo_architectures import MLP
class EnsembleRegression:
def __init__(self, layers, ensemble_s... | 8,651 | 41.411765 | 121 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_DON_step_0.py | from jax import numpy as np
from jax.scipy.special import logsumexp
output_dim = (64, 64, 16) # 16 frames of 64 by 64 images
P1 = output_dim[0]
P2 = output_dim[1]
xx, yy = np.meshgrid( np.arange(P1) / P1, np.arange(P2) / P2 )
# prediction function mapping vectorial output to scalar obective value
def output(new_y):
... | 1,269 | 34.277778 | 144 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_MLP_all_steps.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
from jax.scipy.special import logsumexp
from jax.nn import relu
from gym_interf import InterfEnv
import numpy as onp
from rpn_bo_utilities import uniform_prior
from rpn_bo_models import Ensemble... | 5,958 | 35.335366 | 174 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_DON_step_1.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
from jax.scipy.special import logsumexp
from rpn_bo_models import ParallelDeepOnet
from rpn_bo_dataloaders import DataGenerator_batch
from rpn_bo_acquisitions import MCAcquisition
from rpn_bo_ut... | 4,309 | 33.206349 | 185 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_MLP_step_2.py | from jax import numpy as np
from jax.scipy.special import logsumexp
from gym_interf import InterfEnv
# function mapping the vectorial input x to the vectorial output consisting of the 16 images
def f(x):
gym = InterfEnv()
gym.reset(actions=(1e-4, 1e-4, 1e-4, 1e-4))
action = x[:4]
state = gym.step(actio... | 2,088 | 51.225 | 211 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_DON_step_2.py | from jax import numpy as np
from jax.scipy.special import logsumexp
from gym_interf import InterfEnv
output_dim = (64, 64, 16) # 16 frames of 64 by 64 images
soln_dim = output_dim[2]
P1 = output_dim[0]
P2 = output_dim[1]
# function mapping the vectorial input x to the vectorial output consisting of the 16 images
def ... | 1,953 | 45.52381 | 136 | py |
rpn_bo | rpn_bo-main/Code and results/optical_interferometer_MLP_step_1.py | import os
os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
from jax import vmap, random, jit
from jax import numpy as np
from jax.scipy.special import logsumexp
from jax.nn import relu
import numpy as onp
from rpn_bo_models import EnsembleRegression
from rpn_bo_dataloaders import BootstrapLoader
from rpn_bo_acquis... | 3,973 | 31.842975 | 106 | py |
rpn_bo | rpn_bo-main/Code and results/rpn_bo_utilities.py | from jax import numpy as np
from jax import jit, vmap, random
from jax.scipy.stats import multivariate_normal, uniform
import numpy as onp
from scipy.stats import gaussian_kde
from sklearn import mixture
from pyDOE import lhs
from KDEpy import FFTKDE
def fit_kde(predict_fn, prior_pdf, bounds, num_samples=10000, bw=Non... | 4,097 | 34.327586 | 97 | py |
rpn_bo | rpn_bo-main/Code and results/create_BO_cv_plots.py | problem = 'comp_blades_shape' # choose from 'environment' 'brusselator' 'optical_interferometer' 'comp_blades_shape'
from matplotlib import pyplot as plt
plt.close('all')
plt.rcParams.update(plt.rcParamsDefault)
plt.rcParams.update({'font.weight': 'bold',
'font.size': 28,
'lin... | 20,736 | 52.862338 | 128 | py |
rpn_bo | rpn_bo-main/Code and results/rpn_bo_dataloaders.py | from jax import vmap, random, jit
from jax import numpy as np
from functools import partial
from torch.utils import data
class BootstrapLoader(data.Dataset):
def __init__(self, X, y, batch_size=128, ensemble_size=32, fraction=0.5, is_Gauss=1, LF_pred=None, rng_key=random.PRNGKey(1234)):
'Initialization'
... | 6,289 | 42.680556 | 163 | py |
mcfit | mcfit-master/mcfit/mcfit.py | import math
import cmath
import warnings
import numpy
try:
import jax
jax.config.update("jax_enable_x64", True)
except ModuleNotFoundError as e:
JAXNotFoundError = e
class mcfit(object):
r"""Compute integral transforms as a multiplicative convolution.
The generic form is
.. math:: G(y) = \in... | 15,495 | 34.541284 | 100 | py |
FCtL | FCtL-main/train_deep_globe.py | #!/usr/bin/env python
# coding: utf-8
from __future__ import absolute_import, division, print_function
import os
import numpy as np
import torch
import torch.nn as nn
from torchvision import transforms
from tqdm import tqdm
from dataset.deep_globe import DeepGlobe, classToRGB, is_image_file
from utils.loss import Foc... | 8,219 | 46.514451 | 202 | py |
FCtL | FCtL-main/helper.py | #!/usr/bin/env python
# coding: utf-8
from __future__ import absolute_import, division, print_function
import cv2
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision import transforms
from utils.metrics import ConfusionMatrix
from ... | 16,004 | 42.140162 | 246 | py |
FCtL | FCtL-main/option.py | import os
import argparse
import torch
class Options():
def __init__(self):
parser = argparse.ArgumentParser(description='PyTorch Segmentation')
# model and dataset
parser.add_argument('--n_class', type=int, default=7, help='segmentation classes')
parser.add_argument('--data_path',... | 2,367 | 61.315789 | 136 | py |
FCtL | FCtL-main/dataset/deep_globe.py | import os
import torch.utils.data as data
import numpy as np
from PIL import Image, ImageFile
import random
from torchvision.transforms import ToTensor
from torchvision import transforms
import cv2
ImageFile.LOAD_TRUNCATED_IMAGES = True
def is_image_file(filename):
return any(filename.endswith(extension) for ext... | 3,527 | 32.6 | 120 | py |
FCtL | FCtL-main/models/base_model.py | import logging
import torch.nn as nn
import numpy as np
class BaseModel(nn.Module):
def __init__(self):
super(BaseModel, self).__init__()
self.logger = logging.getLogger(self.__class__.__name__)
def forward(self):
raise NotImplementedError
def summary(self):
model_paramete... | 734 | 32.409091 | 79 | py |
FCtL | FCtL-main/models/fcn.py | from .base_model import BaseModel
import torch.nn as nn
import torch.nn.functional as F
from torchvision import models
from .helpers import get_upsampling_weight
import torch
from itertools import chain
from .FCtL import FCtL
class MiniFCN8(BaseModel):
def __init__(self, num_classes, pretrained=True):
... | 6,910 | 43.301282 | 122 | py |
FCtL | FCtL-main/models/FCtL.py | import torch
import torch.nn.functional as F
from torch import nn
from torch.nn import init
import math
class _FCtL(nn.Module):
def __init__(self, inplanes, planes, lr_mult, weight_init_scale):
conv_nd = nn.Conv2d
bn_nd = nn.BatchNorm2d
super(_FCtL, self).__init__()
self.co... | 5,866 | 39.462069 | 122 | py |
FCtL | FCtL-main/models/helpers.py | import os
import torch
import torch.nn as nn
import numpy as np
import math
import PIL
def dir_exists(path):
if not os.path.exists(path):
os.makedirs(path)
def initialize_weights(*models):
for model in models:
for m in model.modules():
if isinstance(m, nn.Conv2d):
... | 1,837 | 31.245614 | 94 | py |
FCtL | FCtL-main/utils/loss.py | import torch.nn as nn
import torch.nn.functional as F
import torch
def one_hot(index, classes):
# index is flatten (during ignore) ##################
size = index.size()[:1] + (classes,)
view = index.size()[:1] + (1,)
#####################################################
mask = torch.Tensor(size).fill... | 1,585 | 27.321429 | 90 | py |
inFairness | inFairness-main/setup.py | from setuptools import setup, find_packages
with open("README.md", "r") as f:
long_description = f.read()
setup(
name="inFairness",
packages=[
"inFairness",
*["inFairness." + p for p in find_packages(where="./inFairness")],
],
package_dir={"": ".",},
install_requires=[
... | 1,031 | 27.666667 | 113 | py |
inFairness | inFairness-main/examples/postprocess-sentiment-analysis/data.py | import torch
import re
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import seaborn as sns
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
sns.set_context(rc={'figure.figsize': (9, 9)}, font_scale=2.)
TOKEN_RE = re.compi... | 11,968 | 44.858238 | 1,229 | py |
inFairness | inFairness-main/examples/fair-ranking-synthetic-data/trainer.py |
class Trainer(object):
"""Main trainer class that orchestrates the entire learning routine
Use this class to start training a model using individual fairness routines
Args:
dataloader (torch.util.data.DataLoader): training data loader
model (inFairness.fairalgo): Individual fairness algori... | 1,760 | 31.018182 | 94 | py |
inFairness | inFairness-main/examples/adult-income-prediction/data.py | import os
import requests
import pandas as pd
import numpy as np
import torch
from sklearn.preprocessing import StandardScaler
from sklearn.utils.random import sample_without_replacement
def _download_data_(rootdir=None):
URLS = {
'train': 'https://archive.ics.uci.edu/ml/machine-learning-databases/adult... | 6,759 | 33.666667 | 118 | py |
inFairness | inFairness-main/examples/adult-income-prediction/metrics.py | import torch
import numpy as np
from sklearn.metrics import confusion_matrix
def accuracy(model, test_dl, device):
model.eval()
corr, total = 0, 0
for x, y in test_dl:
x, y = x.to(device), y.to(device)
y_pred = model(x)
_, y_pred = torch.max(y_pred, dim=1)
total += y.sha... | 1,950 | 24.012821 | 64 | py |
inFairness | inFairness-main/examples/sentiment-analysis/data.py | import torch
import re
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import seaborn as sns
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
sns.set_context(rc={'figure.figsize': (9, 9)}, font_scale=2.)
TOKEN_RE = re.compi... | 9,005 | 38.327511 | 132 | py |
inFairness | inFairness-main/examples/synthetic-data/trainer.py |
class Trainer(object):
"""Main trainer class that orchestrates the entire learning routine
Use this class to start training a model using individual fairness routines
Args:
dataloader (torch.util.data.DataLoader): training data loader
model (inFairness.fairalgo): Individual fairness algori... | 1,516 | 29.959184 | 94 | py |
inFairness | inFairness-main/tests/postprocessing/test_data_ds.py | import pytest
import torch
import numpy as np
from inFairness.distances import EuclideanDistance
from inFairness.postprocessing.data_ds import PostProcessingDataStore
def test_add_data():
ntries = 10
B, D = 10, 50
distance_x = EuclideanDistance()
data_ds = PostProcessingDataStore(distance_x)
cou... | 1,153 | 22.08 | 70 | py |
inFairness | inFairness-main/tests/postprocessing/test_glif.py | import pytest
import torch
import torch.nn.functional as F
import numpy as np
from inFairness.distances import EuclideanDistance
from inFairness.postprocessing import GraphLaplacianIF
def test_postprocess_incorrectargs():
params = (1.0, 1.0, 100.0, True)
dist_x = EuclideanDistance()
pp = GraphLaplacian... | 1,926 | 29.109375 | 90 | py |
inFairness | inFairness-main/tests/distances/test_common_distances.py | import pytest
import math
import torch
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from inFairness import distances
def test_euclidean_distance():
dist = distances.EuclideanDistance()
X = torch.FloatTensor([[0.0... | 7,261 | 26.507576 | 112 | py |
inFairness | inFairness-main/tests/distances/test_distance_state.py | import pytest
import torch
from inFairness import distances
def test_mahalanobis_dist_state_buffer_set():
dist = distances.MahalanobisDistances()
sigma = torch.rand(size=(10, 10))
dist.fit(sigma)
state_dict = dist.state_dict()
assert "sigma" in state_dict
assert torch.all(state_dict["sigma"... | 4,247 | 26.230769 | 70 | py |
inFairness | inFairness-main/tests/utils/test_normalized_discounted_cumulative_gain.py | import torch
import inFairness.utils.ndcg as ndcg
def test_normalized_discounted_cumulative_gain():
x = torch.tensor([10, 8.0, 1.0])
assert ndcg.normalized_discounted_cumulative_gain(x) == 1.0
x = torch.tensor([1.,2,3])
assert ndcg.normalized_discounted_cumulative_gain(x) - 0.7397 < 0.01
batch_x = torch.... | 597 | 32.222222 | 89 | py |
inFairness | inFairness-main/tests/utils/test_plackett_luce.py | import torch
from torch.nn.parameter import Parameter
from functorch import vmap
from inFairness.utils import plackett_luce
from inFairness.utils.plackett_luce import PlackettLuce
from inFairness.utils.ndcg import vect_normalized_discounted_cumulative_gain as v_ndcg
vect_gather = vmap(torch.gather, in_dims=(None,Non... | 1,752 | 34.77551 | 100 | py |
inFairness | inFairness-main/tests/auditor/test_senstir_auditor.py | import pytest
import torch
from mock import patch
from inFairness.auditor import SenSTIRAuditor
from inFairness.distances import (
SensitiveSubspaceDistance,
SquaredEuclideanDistance,
)
def mock_torch_rand_like(*size):
return torch.ones_like(*size)
@patch("torch.rand_like", mock_torch_rand_like)
def t... | 2,070 | 30.378788 | 141 | py |
inFairness | inFairness-main/tests/auditor/test_sensei_auditor.py | import pytest
import numpy as np
from mock import patch
import torch
from torch.nn import functional as F
from inFairness.auditor import SenSeIAuditor
def mock_adam_optim(
params, lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False
):
return torch.optim.SGD(params, lr=lr)
def my_dist(s, t):
... | 3,926 | 24.5 | 88 | py |
inFairness | inFairness-main/tests/auditor/test_auditor.py | from re import X
import pytest
import numpy as np
from inFairness.auditor import Auditor
from mock import patch
import torch
from torch.nn import functional as F
def mock_adam_optim(
params, lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False
):
return torch.optim.SGD(params, lr=lr)
def my_dis... | 1,177 | 21.226415 | 88 | py |
inFairness | inFairness-main/tests/auditor/test_sensr_auditor.py | import pytest
import numpy as np
from inFairness.auditor import SenSRAuditor
from mock import patch
import torch
from torch.nn import functional as F
def mock_adam_optim(
params, lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False
):
return torch.optim.SGD(params, lr=lr)
def my_dist(s, t):
... | 3,772 | 25.384615 | 87 | py |
inFairness | inFairness-main/tests/fairalgo/test_sensei.py | import pytest
import numpy as np
from inFairness.auditor import SenSeIAuditor
from inFairness.fairalgo import SenSeI
from mock import patch
import torch
from torch.nn import functional as F
def mock_generate_worst_case_examples(cls, network, x, lambda_param):
return torch.ones_like(x) * -1.0
def mock_dist(s, t... | 1,593 | 24.709677 | 80 | py |
inFairness | inFairness-main/tests/fairalgo/test_senstir.py | import torch
from inFairness.distances import (
SensitiveSubspaceDistance,
SquaredEuclideanDistance,
)
from inFairness.fairalgo import SenSTIR
def generate_test_data(num_batches, queries_per_batch, items_per_query):
num_features = 2
item_data = torch.rand(
num_batches, queries_per_batch, item... | 2,236 | 28.826667 | 110 | py |
inFairness | inFairness-main/tests/fairalgo/test_sensr.py | import pytest
import numpy as np
from inFairness.auditor import SenSRAuditor
from inFairness.fairalgo import SenSR
from mock import patch
import torch
from torch.nn import functional as F
def mock_generate_worst_case_examples(cls, network, x, y, lambda_param):
return torch.ones_like(x) * -1.0
def mock_dist(s, ... | 1,576 | 24.852459 | 83 | py |
inFairness | inFairness-main/docs/source/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
# -- Path setup --------------------------------------------------------------
# If ex... | 3,873 | 27.910448 | 79 | py |
inFairness | inFairness-main/inFairness/postprocessing/datainterfaces.py | from typing import Dict
import torch
from dataclasses import dataclass
@dataclass
class PostProcessingObjectiveResponse:
"""Class to store the result from a post-processing algorithm"""
y_solution: torch.Tensor = None
objective: Dict = None
| 256 | 20.416667 | 68 | py |
inFairness | inFairness-main/inFairness/postprocessing/data_ds.py | import torch
from inFairness.postprocessing.distance_ds import DistanceStructure
class PostProcessingDataStore(object):
"""Data strucuture to hold the data used for post-processing
Parameters
-------------
distance_x: inFairness.distances.Distance
Distance metric in the input space
... | 2,843 | 30.955056 | 80 | py |
inFairness | inFairness-main/inFairness/postprocessing/glif.py | import torch
import numpy as np
from inFairness.utils.postprocessing import (
build_graph_from_dists,
get_laplacian,
laplacian_solve,
)
from inFairness.postprocessing.base_postprocessing import BasePostProcessing
from inFairness.postprocessing.datainterfaces import PostProcessingObjectiveResponse
class G... | 11,440 | 34.977987 | 174 | py |
inFairness | inFairness-main/inFairness/postprocessing/base_postprocessing.py | import torch
from typing import Tuple
from inFairness.postprocessing.data_ds import PostProcessingDataStore
class BasePostProcessing(object):
"""Base class for Post-Processing methods
Parameters
-------------
distance_x: inFairness.distances.Distance
Distance matrix in the input spac... | 2,253 | 28.272727 | 84 | py |
inFairness | inFairness-main/inFairness/postprocessing/distance_ds.py | import torch
class DistanceStructure(object):
"""Data structure to store and track the distance matrix between data points
Parameters
-------------
distance_x: inFairness.distances.Distance
Distance metric in the input space
"""
def __init__(self, distance_x):
self.di... | 1,604 | 28.722222 | 84 | py |
inFairness | inFairness-main/inFairness/distances/wasserstein_distance.py | import torch
from ot import emd2
from inFairness.distances import MahalanobisDistances
class WassersteinDistance(MahalanobisDistances):
"""computes a batched Wasserstein Distance for pairs of sets of items on each batch in the tensors
with dimensions B, N, D and B, M, D where B and D are the batch and featur... | 1,924 | 34.648148 | 136 | py |
inFairness | inFairness-main/inFairness/distances/explore_distance.py | import numpy as np
import torch
from scipy.stats import logistic
from inFairness.utils import datautils
from inFairness.distances.mahalanobis_distance import MahalanobisDistances
class EXPLOREDistance(MahalanobisDistances):
"""Implements the Embedded Xenial Pairs Logistic Regression metric
(EXPLORE) defined ... | 4,287 | 35.338983 | 101 | py |
inFairness | inFairness-main/inFairness/distances/euclidean_dists.py | import torch
from inFairness.distances.distance import Distance
class EuclideanDistance(Distance):
def __init__(self):
super().__init__()
def forward(self, x, y, itemwise_dist=True):
if itemwise_dist:
return torch.cdist(x.unsqueeze(1), y.unsqueeze(1)).reshape(-1, 1)
else... | 2,264 | 30.458333 | 88 | py |
inFairness | inFairness-main/inFairness/distances/logistic_sensitive_subspace.py | from typing import Iterable
import numpy as np
import torch
from sklearn.linear_model import LogisticRegression
from inFairness.distances import SensitiveSubspaceDistance
from inFairness.utils import datautils, validationutils
class LogisticRegSensitiveSubspace(SensitiveSubspaceDistance):
"""Implements the Softm... | 8,395 | 39.757282 | 174 | py |
inFairness | inFairness-main/inFairness/distances/mahalanobis_distance.py | import torch
import numpy as np
from functorch import vmap
from inFairness.distances.distance import Distance
class MahalanobisDistances(Distance):
"""Base class implementing the Generalized Mahalanobis Distances
Mahalanobis distance between two points X1 and X2 is computed as:
.. math:: \\text{dist}(X... | 5,180 | 30.785276 | 107 | py |
inFairness | inFairness-main/inFairness/distances/sensitive_subspace_dist.py | import numpy as np
import torch
from sklearn.decomposition import TruncatedSVD
from typing import List
from inFairness.distances.mahalanobis_distance import MahalanobisDistances
from inFairness.utils import datautils
class SensitiveSubspaceDistance(MahalanobisDistances):
"""Implements Sensitive Subspace metric b... | 5,490 | 35.852349 | 95 | py |
inFairness | inFairness-main/inFairness/distances/distance.py | from abc import ABCMeta, abstractmethod
from torch import nn
class Distance(nn.Module, metaclass=ABCMeta):
"""
Abstract base class for model distances
"""
def __init__(self):
super().__init__()
def fit(self, **kwargs):
"""
Fits the metric parameters for learnable metrics
... | 1,196 | 28.925 | 179 | py |
inFairness | inFairness-main/inFairness/utils/datautils.py | from typing import Iterable
import torch
import numpy as np
from itertools import product
def generate_data_pairs(n_pairs, datasamples_1, datasamples_2=None, comparator=None):
"""Utility function to generate (in)comparable data pairs given data samples. Use case includes
creating a dataset of comparable and... | 4,492 | 31.092857 | 105 | py |
inFairness | inFairness-main/inFairness/utils/ndcg.py | import torch
from functorch import vmap
def discounted_cumulative_gain(relevances):
numerator = torch.pow(torch.tensor([2.0]), relevances)
denominator = torch.log2(torch.arange(len(relevances), dtype=torch.float) + 2)
return (numerator / denominator).sum()
def normalized_discounted_cumulative_gain(relev... | 1,822 | 36.204082 | 108 | py |
inFairness | inFairness-main/inFairness/utils/plackett_luce.py | """
This file implements Plackett-Luce distribution and is taken from the
following source:
Source: Github PyTorch PR#50362 - Add Plackett-Luce Distribution
URL: https://github.com/pytorch/pytorch/pull/50362/
Author: Jeremy Salwen (https://github.com/jeremysalwen)
"""
from typing import Optional
import... | 5,646 | 39.335714 | 117 | py |
inFairness | inFairness-main/inFairness/utils/params.py | import torch.nn
def freeze_network(network: torch.nn.Module):
"""Freeze network parameters.
:param network: torch.nn.Module
:type network: torch.nn.Module
"""
for p in network.parameters():
p.requires_grad = False
def unfreeze_network(network: torch.nn.Module):
"""Unfreeze network pa... | 475 | 22.8 | 47 | py |
inFairness | inFairness-main/inFairness/utils/postprocessing.py | import torch
def build_graph_from_dists(
dists: torch.Tensor,
scale: float = None,
threshold: float = None,
normalize: bool = False,
):
"""Build the adjacency matrix `W` given distances
Parameters
-------------
dists: torch.Tensor
Distance matrix between data points. S... | 2,900 | 27.441176 | 86 | py |
inFairness | inFairness-main/inFairness/auditor/sensr_auditor.py | import torch
from torch.nn import Parameter
from inFairness.auditor import Auditor
from inFairness.utils.params import freeze_network, unfreeze_network
from inFairness.utils.datautils import get_device
class SenSRAuditor(Auditor):
"""SenSR Auditor implements the functionality to generate worst-case examples
... | 5,871 | 32.175141 | 125 | py |
inFairness | inFairness-main/inFairness/auditor/sensei_auditor.py | import torch
from torch.nn import Parameter
from inFairness.auditor.auditor import Auditor
from inFairness.utils.params import freeze_network, unfreeze_network
from inFairness.utils.datautils import get_device
class SenSeIAuditor(Auditor):
"""SenSeI Auditor implements the functionality to generate worst-case exa... | 5,904 | 33.331395 | 128 | py |
inFairness | inFairness-main/inFairness/auditor/datainterface.py | import torch
from dataclasses import dataclass
@dataclass
class AuditorResponse:
"""Class to store a result from the auditor"""
lossratio_mean: float = None
lossratio_std: float = None
lower_bound: float = None
threshold: float = None
pval: float = None
confidence: float = None
is_mo... | 342 | 19.176471 | 50 | py |
inFairness | inFairness-main/inFairness/auditor/senstir_auditor.py | import torch
from torch.nn.parameter import Parameter
from inFairness.distances import (
WassersteinDistance,
MahalanobisDistances,
)
from inFairness.auditor import Auditor
from inFairness.utils.params import freeze_network, unfreeze_network
class SenSTIRAuditor(Auditor):
"""SenSTIR Auditor generates wo... | 4,386 | 34.096 | 128 | py |
inFairness | inFairness-main/inFairness/auditor/auditor.py | import torch
import numpy as np
from abc import ABCMeta
from scipy.stats import norm
from inFairness.utils.datautils import convert_tensor_to_numpy
from inFairness.auditor.datainterface import AuditorResponse
class Auditor(metaclass=ABCMeta):
"""
Abstract class for model auditors, e.g. Sensei or Sensr
""... | 4,199 | 34.294118 | 85 | py |
inFairness | inFairness-main/inFairness/fairalgo/datainterfaces.py | import torch
from dataclasses import dataclass
@dataclass
class FairModelResponse:
"""Class to store a result from the fairmodel algorithm"""
loss: torch.Tensor = None
y_pred: torch.Tensor = None
| 212 | 16.75 | 62 | py |
inFairness | inFairness-main/inFairness/fairalgo/sensei.py | import torch
from torch import nn
from inFairness.auditor import SenSeIAuditor
from inFairness.fairalgo.datainterfaces import FairModelResponse
from inFairness.utils import datautils
class SenSeI(nn.Module):
"""Implementes the Sensitive Set Invariane (SenSeI) algorithm.
Proposed in `SenSeI: Sensitive Set In... | 3,743 | 27.580153 | 120 | py |
inFairness | inFairness-main/inFairness/fairalgo/senstir.py | import torch
from torch import nn
from functorch import vmap
from inFairness.auditor import SenSTIRAuditor
from inFairness.distances.mahalanobis_distance import MahalanobisDistances
from inFairness.fairalgo.datainterfaces import FairModelResponse
from inFairness.utils import datautils
from inFairness.utils.plackett_l... | 5,938 | 33.132184 | 97 | py |
inFairness | inFairness-main/inFairness/fairalgo/sensr.py | import torch
from torch import nn
from inFairness.auditor import SenSRAuditor
from inFairness.fairalgo.datainterfaces import FairModelResponse
from inFairness.utils import datautils
class SenSR(nn.Module):
"""Implementes the Sensitive Subspace Robustness (SenSR) algorithm.
Proposed in `Training individually... | 3,534 | 27.055556 | 125 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/KPN.py | import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torchsummary import summary
import torchvision.models as models
# KPN基本网路单元
class Basic(nn.Module):
def __init__(self, in_ch, out_ch, g=16, channel_att=False, spatial_att=False):
super(Basic, self).__init__()
... | 12,210 | 39.30033 | 150 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/train_eval_syn.py | import torch
import torch.optim as optim
from torch.optim import lr_scheduler
import torch.nn as nn
from torch.utils.data import DataLoader
import numpy as np
import argparse
import os, sys, time, shutil
from data_provider import OnTheFlyDataset, _configspec_path
from kpn_data_provider import TrainDataSet, UndosRGBG... | 13,114 | 37.014493 | 144 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/kpn_data_provider.py | import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import os
from PIL import Image
import numpy as np
from skimage.color import rgb2xyz
import inspect
from utils.training_util import read_config
from data_genera... | 10,342 | 37.737828 | 134 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_provider.py | import glob
import inspect
import os
import zlib
from time import time
import numpy as np
import torch
import torch.nn.functional as F
import torch.utils.data as data
from PIL import Image
from torch import FloatTensor
from data_generation.pipeline import ImageDegradationPipeline
from utils.image_utils import bayer_c... | 31,377 | 45.076358 | 193 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/generate_dataset.py | import tifffile
import skimage
import numpy as np
import os
import argparse
import glob
import json
from tqdm import tqdm
from sklearn.feature_extraction.image import extract_patches_2d
import torch
from torch.autograd import Variable
from torch import FloatTensor
from data_generation.pipeline import ImageDegradation... | 7,397 | 41.034091 | 149 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/constants.py | import math
import torch
from torch import FloatTensor
XYZ2sRGB = FloatTensor([[ 3.2406, -1.5372, -0.4986],
[-0.9689, 1.8758, 0.0415],
[ 0.0557, -0.2040, 1.0570]])
# http://brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
ProPhotoRGB2XYZ = FloatTensor([[0.79767... | 16,240 | 44.113889 | 990 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/data_utils.py | """ Utilities functions.
"""
import numbers
import numpy as np
import torch
from torch import FloatTensor
def random_crop(im, num_patches, w, h=None):
h = w if h is None else h
nw = im.size(-1) - w
nh = im.size(-2) - h
if nw < 0 or nh < 0:
raise RuntimeError("Image is to small {} for the desir... | 3,336 | 25.696 | 76 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/image_processing.py | import torch
import torch.nn as nn
from torch import FloatTensor, IntTensor
# For drawing motion blur kernel.
import numpy as np
import cv2
import scipy
import functools
import math
from .data_utils import mosaick_multiply, expand_to_4d_batch
from .data_utils import python_to_tensor, cuda_like, number_to_list, is_numb... | 60,184 | 36.615625 | 130 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/pipeline.py | import torch.nn as nn
import torch
from . import image_processing
class ImageDegradationPipeline(nn.Module):
def __init__(self, configs):
""" Image Degradation Pipeline.
Args:
configs: list of modules to be implemented and their parameters.
The list should contai... | 1,439 | 34.121951 | 92 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/data_generation/kernel.py | import torch
def gausskern1d(sig, sz=None):
""" 1D Gaussian kernel.
Args:
sz: kernel size.
sig: stdev of the kernel
"""
if sz is None:
sz = int(2*int(sig) + 1)
sz = max(sz, 3)
half_sz = int(sz / 2)
neg_half_sz = half_sz - sz + 1
neg_half_sz = float(neg_half... | 1,285 | 26.956522 | 129 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/utils/image_utils.py | import numpy as np
import torch
def center_crop_tensor(tensor, w, h):
tw = tensor.size(-1)
th = tensor.size(-2)
if tw < w or th < h:
raise RuntimeError("Crop size is larger than image size.")
h0 = int((th - h) / 2)
w0 = int((tw - w) / 2)
h1 = h0 + h
w1 = w0 + w
return tensor[..... | 1,497 | 26.740741 | 106 | py |
kernel-prediction-networks-PyTorch | kernel-prediction-networks-PyTorch-master/utils/training_util.py | import numpy as np
import glob
import torch
import shutil
import os
import cv2
import numbers
import skimage
from collections import OrderedDict
from configobj import ConfigObj
from validate import Validator
from data_generation.pipeline import ImageDegradationPipeline
class MovingAverage(object):
def __init__(se... | 7,118 | 34.41791 | 105 | py |
prospector | prospector-master/doc/conf.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# prospector documentation build configuration file, created by
# sphinx-quickstart on Sun Apr 8 16:26:26 2018.
#
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to th... | 5,534 | 30.99422 | 80 | py |
Efficient-FedRec | Efficient-FedRec-main/src/main.py | import argparse
from pathlib import Path
from tqdm import tqdm
import random
import wandb
import numpy as np
import os
import pickle
import torch
from torch.utils.data import DataLoader
import torch.optim as optim
from agg import Aggregator
from model import Model, TextEncoder, UserEncoder
from data import TrainData... | 13,768 | 33.946701 | 131 | py |
Efficient-FedRec | Efficient-FedRec-main/src/agg.py | import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from model import TextEncoder, UserEncoder
import torch.optim as optim
from data import NewsPartDataset
class NewsUpdatorDataset(Dataset):
def __init__(self, news_index, news_ids, news_grads):
self.news_index = news_index
... | 4,402 | 34.224 | 90 | py |
Efficient-FedRec | Efficient-FedRec-main/src/model.py | import torch
from torch import nn
import torch.nn.functional as F
from transformers import BertModel
import numpy as np
class ScaledDotProductAttention(nn.Module):
def __init__(self, d_k):
super(ScaledDotProductAttention, self).__init__()
self.d_k = d_k
def forward(self, Q, K, V, attn_mask=No... | 5,484 | 37.356643 | 101 | py |
Efficient-FedRec | Efficient-FedRec-main/src/data.py | import random
import numpy as np
from torch.utils.data import Dataset, DataLoader
def newsample(nnn, ratio):
if ratio > len(nnn):
return nnn + ["<unk>"] * (ratio - len(nnn))
else:
return random.sample(nnn, ratio)
class TrainDataset(Dataset):
def __init__(self, args, samples, users, user_i... | 2,760 | 28.063158 | 99 | py |
Guava-disease-detection | Guava-disease-detection-main/optimization/conversion/torch_to_onnx.py | import torch
from torchvision.models import mobilenet_v2
img_size = (640, 640)
batch_size = 1
onnx_model_path = 'model.onnx'
model = mobilenet_v2()
model.eval()
sample_input = torch.rand((batch_size, 3, *img_size))
y = model(sample_input)
torch.onnx.export(
model,
sample_input,
onnx_model_path,
ve... | 411 | 16.913043 | 53 | py |
CICDFuzzBench | CICDFuzzBench-master/experiments/fuzz duration/data/VD_A.py | import itertools as it
from bisect import bisect_left
from typing import List
import numpy as np
import pandas as pd
import scipy.stats as ss
from pandas import Categorical
def VD_A(treatment: List[float], control: List[float]):
"""
Computes Vargha and Delaney A index
A. Vargha and H. D. Delaney.
A... | 3,710 | 21.089286 | 79 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.