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 |
|---|---|---|---|---|---|---|
flex | flex-main/baselines/bao/model.py | from pathlib import Path
from typing import Iterable, Tuple, Sequence, Dict, Any, Optional
import pickle
import logging
import torch
from omegaconf import OmegaConf, DictConfig
from torchtext.vocab import Vocab, Vectors
from fewshot import Model
from bao.dataset.loader import _data_to_nparray
from bao.dataset.utils imp... | 7,056 | 41.769697 | 117 | py |
flex | flex-main/baselines/bao/train.py | # TODO: Check _read_words format for fewrel matches what bao et al did in paper
# TODO: Set the way
# TODO: Handle fewrel in for fewshot.eval
# TODO: Called 'flex.txt' in raw dataset, then set to 'txt' in challenge
from pathlib import Path
from torchtext.data import get_tokenizer
import pickle
import itertools
import c... | 8,582 | 34.17623 | 129 | py |
flex | flex-main/baselines/bao/bao/main.py | import os
import sys
import pickle
import signal
import argparse
import traceback
import torch
import numpy as np
from .embedding import factory as ebd
from .classifier import factory as clf
from .dataset import loader
from .train import factory as train_utils
def parse_args():
parser = argparse.ArgumentParser(... | 14,544 | 43.753846 | 85 | py |
flex | flex-main/baselines/bao/bao/classifier/r2d2.py | from typing import Optional
import torch
import torch.nn as nn
import torch.nn.functional as F
from .base import BASE
class R2D2(BASE):
'''
META-LEARNING WITH DIFFERENTIABLE CLOSED-FORM SOLVERS
'''
def __init__(self, ebd_dim, args):
super(R2D2, self).__init__(args)
self.ebd_dim = ... | 2,941 | 27.563107 | 82 | py |
flex | flex-main/baselines/bao/bao/classifier/base.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class BASE(nn.Module):
'''
BASE model
'''
def __init__(self, args):
super(BASE, self).__init__()
self.args = args
# cached tensor for speed
self.I_way = nn.Parameter(torch.eye(self.args.way, dtype=... | 3,566 | 27.309524 | 83 | py |
flex | flex-main/baselines/bao/bao/classifier/mlp.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.weight_norm import WeightNorm
from .base import BASE
class distLinear(nn.Module):
def __init__(self, indim, outdim):
super(distLinear, self).__init__()
self.L = nn.Linear(indim, outdim, bias=False)
# sp... | 3,304 | 31.401961 | 104 | py |
flex | flex-main/baselines/bao/bao/classifier/proto.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .base import BASE
class PROTO(BASE):
'''
PROTOTIPICAL NETWORK FOR FEW SHOT LEARNING
'''
def __init__(self, ebd_dim, args):
super(PROTO, self).__init__(args)
self.ebd_dim = ebd_dim
if args.embedding ==... | 1,913 | 25.957746 | 80 | py |
flex | flex-main/baselines/bao/bao/classifier/nn.py | import torch
from .base import BASE
class NN(BASE):
'''
Nearest neighbour classifier
'''
def __init__(self, ebd_dim, args):
super(NN, self).__init__(args)
self.ebd_dim = ebd_dim
def forward(self, XS, YS, XQ, YQ):
'''
@param XS (support x): support_size x e... | 1,001 | 25.368421 | 66 | py |
flex | flex-main/baselines/bao/bao/classifier/factory.py | import torch
from .nn import NN
from .proto import PROTO
from .r2d2 import R2D2
from .lrd2 import LRD2
from .mlp import MLP
from .routing import ROUTING
from ..dataset.utils import tprint
def get_classifier(ebd_dim, args):
tprint("Building classifier")
if args.classifier == 'nn':
model = NN(ebd_dim, ... | 1,428 | 29.404255 | 73 | py |
flex | flex-main/baselines/bao/bao/classifier/lrd2.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .base import BASE
class LRD2(BASE):
'''
META-LEARNING WITH DIFFERENTIABLE CLOSED-FORM SOLVERS
'''
def __init__(self, ebd_dim, args):
super(LRD2, self).__init__(args)
self.ebd_dim = ebd_dim
self.iters ... | 2,169 | 26.820513 | 95 | py |
flex | flex-main/baselines/bao/bao/classifier/routing.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .base import BASE
class ROUTING(BASE):
'''
Induction and Relation module of
"Induction Networks for Few-Shot Text Classification"
'''
def __init__(self, ebd_dim, args):
super(ROUTING, self).__init__(args)
... | 4,766 | 30.156863 | 104 | py |
flex | flex-main/baselines/bao/bao/dataset/parallel_sampler_orig.py | import time
import datetime
from multiprocessing import Process, Queue, cpu_count
import torch
import numpy as np
# from pytorch_transformers import BertModel
from transformers import BertModel
from . import utils
from . import stats
class ParallelSampler():
def __init__(self, data, args, num_episodes=None):
... | 5,130 | 35.65 | 87 | py |
flex | flex-main/baselines/bao/bao/dataset/stats.py | import os
from collections import defaultdict
from tqdm import tqdm
# from termcolor import colored
import torch.nn.functional as F
import torch.nn as nn
import torch
import numpy as np
from math import isnan
def _subset_selection(data, classes):
'''
Filter out examples in the data dictionary that do not ... | 6,947 | 28.692308 | 97 | py |
flex | flex-main/baselines/bao/bao/dataset/utils.py | import torch
import datetime
def tprint(s):
'''
print datetime and s
@params:
s (str): the string to be printed
'''
print('{}: {}'.format(
datetime.datetime.now().strftime('%02y/%02m/%02d %H:%M:%S'), s),
flush=True)
def to_tensor(data, cuda, exclude_keys=[]):
... | 1,147 | 23.425532 | 74 | py |
flex | flex-main/baselines/bao/bao/dataset/parallel_sampler.py | import time
import datetime
from multiprocessing import Process, cpu_count
from multiprocessing.queues import Queue
import multiprocessing
import torch
import numpy as np
# from pytorch_transformers import BertModel
from transformers import BertModel
from . import utils
from . import stats
class ParallelSampler():... | 7,451 | 36.074627 | 88 | py |
flex | flex-main/baselines/bao/bao/dataset/loader.py | import os
import itertools
import collections
import json
from collections import defaultdict
import numpy as np
import torch
from torchtext.vocab import Vocab, Vectors
from ..embedding.avg import AVG
from ..embedding.cxtebd import CXTEBD
from ..embedding.wordebd import WORDEBD
from .utils import tprint
from transfo... | 15,178 | 30.688935 | 89 | py |
flex | flex-main/baselines/bao/bao/embedding/idf.py | import torch
import torch.nn.functional as F
import torch.nn as nn
from .wordebd import WORDEBD
class IDF(nn.Module):
'''
An aggregation method that encodes every document by its the weighted
word embeddings.
The weight is computed by the inverse document frequency over the source
... | 1,209 | 27.139535 | 80 | py |
flex | flex-main/baselines/bao/bao/embedding/lstmatt.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .meta import RNN
from .auxiliary.factory import get_embedding
class LSTMAtt(nn.Module):
def __init__(self, ebd, args):
super(LSTMAtt, self).__init__()
... | 2,463 | 27.988235 | 106 | py |
flex | flex-main/baselines/bao/bao/embedding/cnn.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from .wordebd import WORDEBD
from .auxiliary.factory import get_embedding
from collections import OrderedDict
class CNN(nn.Module):
'''
An aggregation method that encodes every document through different
convol... | 4,117 | 31.944 | 79 | py |
flex | flex-main/baselines/bao/bao/embedding/avg.py | import torch
import torch.nn as nn
from .wordebd import WORDEBD
class AVG(nn.Module):
'''
An aggregation method that encodes every document by its average word
embeddings.
'''
def __init__(self, ebd, args):
super(AVG, self).__init__()
self.ebd = ebd
self.ebd_dim ... | 1,028 | 24.725 | 79 | py |
flex | flex-main/baselines/bao/bao/embedding/factory.py | import torch
import datetime
from .wordebd import WORDEBD
from .cxtebd import CXTEBD
from .avg import AVG
from .cnn import CNN
from .idf import IDF
from .meta import META
from .lstmatt import LSTMAtt
def get_embedding(vocab, args):
print("{}, Building embedding".format(
datetime.datetime.now().strftime(... | 1,685 | 29.654545 | 81 | py |
flex | flex-main/baselines/bao/bao/embedding/meta.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
from .wordebd import WORDEBD
from .auxiliary.factory import get_embedding
class RNN(nn.Module):
def __init__(self, input_dim, hidden_dim, num_layers, bidirectional,
... | 7,643 | 33.432432 | 101 | py |
flex | flex-main/baselines/bao/bao/embedding/wordebd.py | import torch.nn as nn
import torch.nn.functional as F
class WORDEBD(nn.Module):
'''
An embedding layer that maps the token id into its corresponding word
embeddings. The word embeddings are kept as fixed once initialized.
'''
def __init__(self, vocab, finetune_ebd):
super(WORDEBD, ... | 1,205 | 32.5 | 77 | py |
flex | flex-main/baselines/bao/bao/embedding/cxtebd.py | import datetime
import torch
import torch.nn as nn
from transformers import BertModel
class CXTEBD(nn.Module):
'''
An embedding layer directly returns precomputed BERT
embeddings.
'''
def __init__(self, pretrained_model_name_or_path=None, cache_dir=None,
finetune_ebd=Fals... | 2,597 | 33.64 | 94 | py |
flex | flex-main/baselines/bao/bao/embedding/auxiliary/pos.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class POS(nn.Module):
'''
Embedding module that combines position-aware embedding
and standard text embedding.
Position embedding should only be used with CNN or META
(sentences are of variable length)
'''
... | 2,014 | 33.741379 | 77 | py |
flex | flex-main/baselines/bao/bao/embedding/auxiliary/factory.py | import datetime
import torch
import torch.nn as nn
import torch.nn.functional as F
from .pos import POS
def get_embedding(args):
'''
@return AUX module with aggregated embeddings or None if args.aux
did not provide additional embeddings
'''
print("{}, Building augmented embedding".format... | 1,792 | 26.584615 | 78 | py |
flex | flex-main/baselines/bao/bao/train/regular.py | import os
import time
import datetime
import torch
import torch.nn as nn
import numpy as np
from tqdm import tqdm
from termcolor import colored
from ..dataset.parallel_sampler import ParallelSampler
from .utils import named_grad_param, grad_param, get_norm
def train(train_data, val_data, model, args):
'''
... | 7,383 | 30.421277 | 89 | py |
flex | flex-main/baselines/bao/bao/train/maml.py | import os
import time
import datetime
from collections import OrderedDict
import itertools
import copy
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from tqdm import tqdm
from termcolor import colored
from ..dataset.parallel_sampler import ParallelSampler
from .utils import nam... | 13,707 | 30.95338 | 83 | py |
flex | flex-main/baselines/bao/bao/train/finetune.py | import os
import copy
import itertools
import datetime
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from tqdm import tqdm
from termcolor import colored
from . import utils
from ..classifier.mlp import MLP
from ..dataset.parallel_sampler import ParallelSampler
def test(test_d... | 2,870 | 25.33945 | 87 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/ptq_qa_quant.py | import numpy as np
import os
import sys
import torch
import random
import logging
import datasets
from datasets import load_metric
import argparse
import transformers
from transformers import (
DataCollatorWithPadding,
EvalPrediction,
TrainingArguments,
default_data_collator,
)
from quant_transformer.q... | 12,550 | 42.130584 | 114 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/gamma_migration.py | import torch
from collections import OrderedDict
from quant_transformer.model.util_layernorm import GammaResidual, QuantizedLayerNorm, QuantizedSplitLayerNorm
import logging
logger = logging.getLogger("transformer")
def get_weight_modules(model, config_model):
num_layer = model.config.num_hidden_layers
weight... | 3,323 | 39.536585 | 109 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/ptq_glue_quant.py | import os
import numpy as np
import logging
import sys
import argparse
import transformers
from transformers import (
DataCollatorWithPadding,
EvalPrediction,
Trainer,
PretrainedConfig,
TrainingArguments,
default_data_collator,
)
import datasets
import random
from datasets import load_metric
imp... | 11,291 | 41.611321 | 120 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/token_wise_clipping.py | from torch.nn import MSELoss
import torch
import logging
from quant_transformer.quantization.fake_quant import QuantizeBase, LSQPlusFakeQuantize, LSQFakeQuantize
from quant_transformer.quantization.state import disable_all
logger = logging.getLogger("transformer")
# support ptq glue, ptq squad, ptq summ
task_type = Non... | 5,481 | 36.292517 | 104 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/ptq_summ_quant.py | import os
import numpy as np
import logging
import sys
import nltk
import argparse
import transformers
from transformers import (
DataCollatorForSeq2Seq,
Seq2SeqTrainingArguments,
Seq2SeqTrainer,
)
import datasets
import random
from tqdm import tqdm
from datasets import load_metric
import torch # noqa E401... | 13,205 | 42.584158 | 119 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/solver/utils/qa_utils.py | import numpy as np
import os
import yaml
import json
import logging
import collections
from easydict import EasyDict
from datasets import load_dataset
from typing import Optional, Tuple
from tqdm.auto import tqdm
from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import (
Predi... | 26,732 | 48.597403 | 119 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/model/quant_bart.py | """PyTorch Quantized BART model. """
import random
import torch
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from typing import Optional, Tuple
from transformers.modeling_outputs import (
BaseModelOutput,
Seq2SeqLMOutput,
Seq2SeqModelOutput,
Seq2SeqSequenceClass... | 63,680 | 44.195884 | 133 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/model/util_layernorm.py | import torch
from torch import nn
from quant_transformer.quantization import QuantizedModule, Quantizer
class QuantizedLayerNorm(QuantizedModule):
def __init__(self, org_module, w_qconfig, a_qconfig, qoutput=True, backend='academic'):
super().__init__(backend=backend)
self.qoutput = qoutput
... | 1,966 | 36.113208 | 101 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/model/quant_roberta.py | """PyTorch Quantized RoRobertaa model. """
# TODO: relative keys
# TODO: remove all the decoder, for some tasks, we need to add it.
# TODO: remove the past-key value
import math
import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transfo... | 39,203 | 45.727056 | 213 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/model/quant_bert.py | """PyTorch Quantized BERT model. """
# TODO: relative keys
# TODO: add all the decoder, for some tasks, we need to add it.
# TODO: add the past-key value
import math
import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transformers.file_u... | 36,806 | 45.947704 | 213 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/quantization/quantized_module.py | from torch import nn
from .observer import AvgPruneMinMaxObserver, MinMaxObserver, AvgMinMaxObserver, \
MSEObserver, AvgMSEObserver, MSEFastObserver, AvgMSEFastObserver,\
AvgQuantileObserver, LSQPlusObserver
from .fake_quant import FixedFakeQuantize, LSQFakeQuantize, LSQPlusFakeQuantize
import torch.nn.function... | 5,919 | 33.418605 | 131 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/quantization/fake_quant.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .observer import MinMaxObserver
from .util_quant import (
fake_quantize_per_channel_affine,
fake_quantize_per_tensor_affine,
fake_quantize_learnable_per_tensor_affine_training,
fake_quantize_learnable_per_channel_affine_training,
... | 9,911 | 46.2 | 120 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/quantization/util_quant.py | import torch
def round_ste(x: torch.Tensor):
"""
Implement Straight-Through Estimator for rounding operation.
"""
return (x.round() - x).detach() + x
def fake_quantize_per_tensor_affine(x, scale, zero_point, quant_min, quant_max):
x_int = round_ste(x / scale) + zero_point
x_quant = torch.cla... | 2,769 | 37.472222 | 126 | py |
outlier_suppression | outlier_suppression-main/quant_transformer/quantization/observer.py | import numpy as np # noqa: F401
import torch
import torch.nn as nn
import os
import logging
import seaborn as sns
from scipy.optimize import minimize_scalar
import matplotlib.pyplot as plt
from .util_quant import fake_quantize_per_tensor_affine, fake_quantize_per_channel_affine
def _transform_to_ch_axis(x, ch_axis):... | 23,280 | 39.987676 | 115 | py |
famos | famos-master/network.py | import torch
import torch.nn as nn
from config import bfirstNoise, opt
from torchvision import models
from prepareTemplates import getTemplateMixImage
norma = nn.BatchNorm2d
def calc_gradient_penalty(netD, real_data, fake_data):
from torch import autograd
LAMBDA=1
BATCH_SIZE=fake_data.shape[0]
alpha =... | 17,708 | 35.140816 | 127 | py |
famos | famos-master/utils.py | import torch
from torch.utils.data import Dataset
import os
from PIL import Image
import numpy as np
import PIL
import torch.nn as nn
from config import opt
class TextureDataset(Dataset):
"""Dataset wrapping images from a random folder with textures
Arguments:
Path to image folder
Extension o... | 9,908 | 33.526132 | 143 | py |
famos | famos-master/config.py | import argparse
import torch.nn as nn
import datetime
import os
parser = argparse.ArgumentParser()
##data path and loading parameters
parser.add_argument('--texturePath', required=True, help='path to texture image folder')
parser.add_argument('--contentPath', default='', help='path to content image folder')
parser.add... | 5,947 | 65.088889 | 158 | py |
famos | famos-master/GANOSAIC.py | from __future__ import print_function
import random
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
from utils import TextureDataset, contentLoss, plotStats, setNoise, learnedWN
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
imp... | 7,790 | 35.924171 | 168 | py |
famos | famos-master/prepareTemplates.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import torch
import torch.nn.functional as F
import numpy as np
import torchvision.utils as vutils
import os
from PIL import Image
import PIL
from config import opt,bMirror,nDep
import sys
##normal coordinate grid
def getCanonic(x):
theta= torch.tensor([1, 0, 0, 0, 1,... | 7,627 | 34.152074 | 130 | py |
famos | famos-master/mosaicGAN.py | from __future__ import print_function
import random
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
from utils import TextureDataset, contentLoss, plotStats, setNoise, learnedWN
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
imp... | 8,541 | 36.79646 | 168 | py |
famos | famos-master/splitInference.py | from config import nDep as gen_ls
import torch
import torch.nn as nn
import sys
import gc
nUp_n = 2 ** gen_ls ##noise and image tensor relation
nUp = 2**(gen_ls+1) ##for buffer ovelap calculation, >=nUp_n
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
def splitH(Im_tri, noise,te,f,sH):
... | 4,705 | 30.583893 | 135 | py |
famos | famos-master/PSGAN.py | from __future__ import print_function
import random
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
from utils import TextureDataset, setNoise, learnedWN
import torchvision.transforms as transforms
import torchvision.utils as vutils
import sys
from network import weights_init,Di... | 4,855 | 32.958042 | 168 | py |
famos | famos-master/mosaicFAMOS.py | from __future__ import print_function
import os
import random
import torch.nn as nn
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
from utils import TextureDataset,contentLoss,plotStats,blend,total_variation,rgb_channels,gramMatrix,invblend,tvArray,setNoise,learnedWN
import tor... | 12,087 | 42.482014 | 196 | py |
LaCE | LaCE-main/lace/emulator/nn_architecture.py | import numpy as np
import pandas as pd
import torch
from torch import nn, optim
from torch.optim import lr_scheduler
class MDNemulator_polyfit(torch.nn.Module):
def __init__(self, nhidden, ndeg, ninput=6):
super().__init__()
self.inputlay = torch.nn.Sequential(nn.Linear(ninput, 10), nn.LeakyReLU(... | 1,037 | 28.657143 | 85 | py |
LaCE | LaCE-main/lace/emulator/nn_emulator.py | import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import os
import time
import sys
import sklearn
import copy
# Torch related modules
import torch
from torch.utils.data import DataLoader, dataset, TensorDataset
from torch import nn, optim
from torch.optim import lr_scheduler
# LaCE modules
from l... | 19,433 | 36.589942 | 135 | py |
pcfi | pcfi-main/pcfi.py | """
Copyright 2023 Daeho Um
SPDX-License-Identifier: Apache-2.0
"""
import random
import numpy as np
import torch
import torch_geometric.utils
from torch import Tensor
from torch_geometric.typing import Adj, OptTensor
from torch_scatter import scatter_add
def pcfi(edge_index, X, feature_mask, num_iterations=None, mas... | 5,276 | 41.556452 | 123 | py |
pcfi | pcfi-main/data_loading.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import os
from torch_geometric.datasets import Planetoid
import torch_geometric.transforms as transforms
from torch_geometric.utils import to_undirected, add_remaining_self_loops
from ogb.nodeproppred imp... | 1,422 | 34.575 | 117 | py |
pcfi | pcfi-main/utils.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import torch
from torch_scatter import scatter_add
def get_missing_feature_mask(rate, n_nodes, n_features, seed, type="uniform"):
"""
Return mask of shape [n_nodes, n_features] indicating whether... | 1,892 | 39.276596 | 120 | py |
pcfi | pcfi-main/data_utils.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import math
import random
import numpy as np
import torch
from torch_geometric.data import Data, InMemoryDataset
from utils import get_mask
DATA_PATH = "data"
def keep_only_largest_connected_component(d... | 7,426 | 31.291304 | 134 | py |
pcfi | pcfi-main/run_node.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import numpy as np
import argparse
import torch
from data_loading import get_dataset
from data_utils import set_train_val_test_split
from utils import get_missing_feature_mask
from models import get_model
... | 4,901 | 36.419847 | 132 | py |
pcfi | pcfi-main/models.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import torch
import torch.nn.functional as F
from torch.nn import ModuleList, Linear, BatchNorm1d
from torch_geometric.nn import (
GCNConv,
GATConv,
JumpingKnowledge,
)
def get_model(model_n... | 4,752 | 36.132813 | 119 | py |
pcfi | pcfi-main/run_link.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import numpy as np
from tqdm import tqdm
import argparse
import torch
from data_loading import get_dataset
from utils import get_missing_feature_mask
from seeds import seeds
from utils_link import train, t... | 4,393 | 37.884956 | 153 | py |
pcfi | pcfi-main/evaluation.py | """
Copyright 2020 Twitter, Inc.
SPDX-License-Identifier: Apache-2.0
Modified by Daeho Um (daehoum1@snu.ac.kr)
"""
import torch
@torch.no_grad()
def test(model, x, data, logits=None, evaluator=None, inference_loader=None, device="cuda"):
model.eval()
logits = inference_full_batch(model, x, data.edge_index)
... | 910 | 29.366667 | 94 | py |
pcfi | pcfi-main/utils_link.py | """
Copyright 2023 Daeho Um
SPDX-License-Identifier: Apache-2.0
"""
import torch
def train(model, x, train_pos_edge_index, optimizer):
model.train()
optimizer.zero_grad()
z = model.encode(x, train_pos_edge_index)
loss = model.recon_loss(z, train_pos_edge_index)
loss.backward()
optimizer.step()
... | 568 | 26.095238 | 73 | py |
ExHiRD-DKG | ExHiRD-DKG-master/train.py | #!/usr/bin/env python
"""
Main training workflow
"""
import configargparse
import os
import signal
import torch
import onmt.opts as opts
import onmt.utils.distributed
from onmt.utils.logging import logger
from onmt.train_single import main as single_main
def main(opt):
if opt.rnn_type == "SRU" and not opt.... | 4,087 | 30.689922 | 89 | py |
ExHiRD-DKG | ExHiRD-DKG-master/preprocess.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Pre-process Data / features files and build vocabulary
"""
import configargparse
import glob
import sys
import gc
import os
import codecs
from itertools import islice
import torch
from onmt.utils.logging import init_logger, logger
import onmt.inputters as inputter... | 6,742 | 30.957346 | 89 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/opts.py | """ Implementation of all available options """
from __future__ import print_function
import configargparse
from onmt.models.sru import CheckSRU
def config_opts(parser):
parser.add('-config', '--config', required=False,
is_config_file_arg=True, help='config file path')
parser.add('-save_config... | 49,002 | 53.508343 | 141 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/train_single.py | #!/usr/bin/env python
"""
Training on a single process
"""
import configargparse
import os
import glob
import random
from itertools import chain
import torch
import onmt.opts as opts
from onmt.inputters.inputter import build_dataset_iter, \
load_fields_from_vocab, old_style_vocab
from onmt.model_builder im... | 6,270 | 32.715054 | 78 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/model_builder.py | """
This file is for models creation, which consults options
and creates each encoder and decoder accordingly.
"""
import re
import torch
import torch.nn as nn
import numpy as np
from torch.nn.init import xavier_uniform_
import onmt.inputters as inputters
import onmt.modules
from onmt.encoders.rnn_encoder import RNNEn... | 24,342 | 36.393241 | 127 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/trainer.py | """
This is the loadable seq2seq trainer library that is
in charge of training details, loss compute, and statistics.
See train.py for a use case of this library.
Note: To make this a general library, we implement *only*
mechanism things here(i.e. what to do), and leave the strategy
... | 20,833 | 39.691406 | 129 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/text_dataset.py | # -*- coding: utf-8 -*-
import torch
from onmt.inputters.dataset_base import DatasetBase
class TextDataset(DatasetBase):
"""
Build `Example` objects, `Field` objects, and filter_pred function
from text corpus.
Args:
fields (dict): a dictionary of `torchtext.data.Field`.
Keys are... | 3,421 | 33.22 | 73 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/dataset_base.py | # coding: utf-8
from itertools import chain
from collections import Counter
import codecs
import torch
from torchtext.data import Example, Dataset, NestedField
from torchtext.vocab import Vocab
# add by wchen
import itertools
class DatasetBase(Dataset):
"""
A dataset is an object that accepts sequences of ... | 7,317 | 41.300578 | 112 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/my_fields.py | from torchtext.data import Field
class SentPosiField(Field):
def pad(self, minibatch):
"""
Pad a batch of examples using this field.
:param data: [[[b1_s1_fp, b1_s1_bp], [b1_s2_fp, b1_s2_bp], ...], ...], list of examples' sent positions
:return: a padded list and the sent numbers,... | 1,343 | 37.4 | 122 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/inputter.py | # -*- coding: utf-8 -*-
import glob
import os
import codecs
from collections import Counter, defaultdict
from itertools import chain, cycle
from functools import partial
import torch
import torchtext.data
from torchtext.data import Field, NestedField
from torchtext.vocab import Vocab
from onmt.inputters.text_dataset... | 35,469 | 37.139785 | 122 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/audio_dataset.py | # -*- coding: utf-8 -*-
import os
from tqdm import tqdm
import torch
from onmt.inputters.dataset_base import DatasetBase
class AudioDataset(DatasetBase):
data_type = 'audio' # get rid of this class attribute asap
@staticmethod
def sort_key(ex):
""" Sort using duration time of the sound spectro... | 3,785 | 33.418182 | 76 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/image_dataset.py | # -*- coding: utf-8 -*-
import os
from onmt.inputters.dataset_base import DatasetBase
class ImageDataset(DatasetBase):
data_type = 'img' # get rid of this class attribute asap
@staticmethod
def sort_key(ex):
""" Sort using the size of the image: (width, height)."""
return ex.src.size(2... | 1,791 | 31.581818 | 77 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/test_vocab.py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from collections import Counter
import os
import pickle
import numpy as np
from numpy.testing import assert_allclose
import torch
from torchtext import vocab
from torchtext.vocab import Vectors, FastText, GloVe, CharNGram
from .common.test_markers impor... | 15,348 | 45.093093 | 90 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/language_modeling.py | from torchtext import data
from torchtext import datasets
from torchtext.vocab import GloVe
# Approach 1:
# set up fields
TEXT = data.Field(lower=True, batch_first=True)
# make splits for data
train, valid, test = datasets.WikiText2.splits(TEXT)
# print information about the data
print('train.fields', train.fields)
... | 1,013 | 25 | 87 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/translation.py | from torchtext import data
from torchtext import datasets
import re
import spacy
spacy_de = spacy.load('de')
spacy_en = spacy.load('en')
url = re.compile('(<url>.*</url>)')
def tokenize_de(text):
return [tok.text for tok in spacy_de.tokenizer(url.sub('@URL@', text))]
def tokenize_en(text):
return [tok.te... | 2,306 | 21.398058 | 81 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/sequence_tagging.py | from torchtext import data
from torchtext import datasets
from torchtext.vocab import GloVe
# Define the fields associated with the sequences.
WORD = data.Field(init_token="<bos>", eos_token="<eos>")
UD_TAG = data.Field(init_token="<bos>", eos_token="<eos>")
# Download and the load default data.
train, val, test = da... | 2,738 | 30.482759 | 88 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/nli.py | from torchtext import data
from torchtext import datasets
# Testing SNLI
print("Run test on SNLI...")
TEXT = datasets.nli.ParsedTextField()
LABEL = data.LabelField()
TREE = datasets.nli.ShiftReduceField()
train, val, test = datasets.SNLI.splits(TEXT, LABEL, TREE)
print("Fields:", train.fields)
print("Number of examp... | 2,066 | 29.850746 | 88 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/babi.py | from torchtext import datasets
# en-valid
TRAIN_NUM = [0] + [900] * 16 + [904, 905, 900, 904]
VAL_NUM = [0] + [100] * 16 + [96, 95, 100, 96]
TEST_NUM = [0] + [1000] * 20
# Testcase 1 (joint training)
train_iter, val_iter, test_iter = datasets.BABI20.iters(task=1, joint=True)
assert len(train_iter.dataset) == sum(TRAI... | 1,930 | 36.862745 | 86 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data.py | from torchtext import data
TEXT = data.Field()
LABELS = data.Field()
train, val, test = data.TabularDataset.splits(
path='~/chainer-research/jmt-data/pos_wsj/pos_wsj', train='.train',
validation='.dev', test='.test', format='tsv',
fields=[('text', TEXT), ('labels', LABELS)])
print(train.fields)
print(le... | 701 | 24.071429 | 86 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/imdb.py | from torchtext import data
from torchtext import datasets
from torchtext.vocab import GloVe
# Approach 1:
# set up fields
TEXT = data.Field(lower=True, include_lengths=True, batch_first=True)
LABEL = data.Field(sequential=False)
# make splits for data
train, test = datasets.IMDB.splits(TEXT, LABEL)
# print informa... | 1,080 | 23.568182 | 69 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/trec.py | from torchtext import data
from torchtext import datasets
from torchtext.vocab import GloVe, CharNGram
# Approach 1:
# set up fields
TEXT = data.Field(lower=True, include_lengths=True, batch_first=True)
LABEL = data.Field(sequential=False)
# make splits for data
train, test = datasets.TREC.splits(TEXT, LABEL, fine_... | 1,197 | 24.489362 | 77 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/sst.py | from torchtext import data
from torchtext import datasets
from torchtext.vocab import Vectors, GloVe, CharNGram, FastText
# Approach 1:
# set up fields
TEXT = data.Field()
LABEL = data.Field(sequential=False)
# make splits for data
train, val, test = datasets.SST.splits(
TEXT, LABEL, fine_grained=True, train_sub... | 1,903 | 26.2 | 89 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/common/torchtext_test_case.py | # -*- coding: utf-8 -*-
from unittest import TestCase
import json
import logging
import os
import shutil
import subprocess
import tempfile
logger = logging.getLogger(__name__)
class TorchtextTestCase(TestCase):
def setUp(self):
logging.basicConfig(format=('%(asctime)s - %(levelname)s - '
... | 6,162 | 45.689394 | 88 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_dataset.py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import torchtext.data as data
import tempfile
import six
import pytest
from ..common.torchtext_test_case import TorchtextTestCase
import os
class TestDataset(TorchtextTestCase):
def test_tabular_simple_data(self):
for data_format in ["csv",... | 21,690 | 40.633397 | 85 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_pipeline.py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import six
import torchtext.data as data
from ..common.torchtext_test_case import TorchtextTestCase
class TestPipeline(TorchtextTestCase):
@staticmethod
def repeat_n(x, n=3):
"""
Given a sequence, repeat it n times.
"""
... | 2,049 | 36.272727 | 83 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_batch.py | from __future__ import unicode_literals
import torch
import torchtext.data as data
from ..common.torchtext_test_case import TorchtextTestCase
class TestDataset(TorchtextTestCase):
def test_batch_with_missing_field(self):
# smoke test to see if batches with missing attributes are shown properly
wi... | 2,020 | 43.911111 | 81 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_field.py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from collections import Counter
import os
from numpy.testing import assert_allclose
import torch
import torchtext.data as data
import pytest
from torch.nn import init
from ..common.torchtext_test_case import TorchtextTestCase, verify_numericalized_exampl... | 42,288 | 44.717838 | 90 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_builtin_datasets.py | import os
import torchtext.data as data
from torchtext.datasets import WikiText2, PennTreebank
from ..common.test_markers import slow
from ..common.torchtext_test_case import TorchtextTestCase
def conditional_remove(f):
if os.path.isfile(f):
os.remove(f)
class TestDataset(TorchtextTestCase):
@slow
... | 1,834 | 35.7 | 80 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_subword.py | import unittest
import pytest
import sys
from torchtext import data
from torchtext.datasets import TREC
class TestSubword(unittest.TestCase):
@pytest.mark.skipif(sys.version_info < (3, 0),
reason="revtok currently breaks for python 2.7")
def test_subword_trec(self):
TEXT = dat... | 857 | 29.642857 | 72 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/inputters/test/data/test_utils.py | import six
import torchtext.data as data
from ..common.torchtext_test_case import TorchtextTestCase
class TestUtils(TorchtextTestCase):
def test_get_tokenizer(self):
# Test the default case with str.split
assert data.get_tokenizer(str.split) == str.split
test_str = "A string, particularly... | 1,794 | 42.780488 | 82 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/sparse_losses.py | import torch
import torch.nn as nn
from torch.autograd import Function
from onmt.modules.sparse_activations import _threshold_and_support
from onmt.utils.misc import aeq
class SparsemaxLossFunction(Function):
@staticmethod
def forward(ctx, input, target):
"""
input (FloatTensor): n x num_clas... | 2,907 | 36.282051 | 78 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/sparse_activations.py | """
An implementation of sparsemax (Martins & Astudillo, 2016). See
https://arxiv.org/pdf/1602.02068 for detailed description.
By Ben Peters and Vlad Niculae
"""
import torch
from torch.autograd import Function
import torch.nn as nn
def _make_ix_like(input, dim=0):
d = input.size(dim)
rho = torch.arange(1, ... | 2,659 | 27 | 78 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/structured_attention.py | import torch.nn as nn
import torch
import torch.cuda
from onmt.utils.logging import init_logger
class MatrixTree(nn.Module):
"""Implementation of the matrix-tree theorem for computing marginals
of non-projective dependency parsing. This attention layer is used
in the paper "Learning Structured Text Repres... | 1,643 | 31.88 | 77 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/util_class.py | """ Misc classes """
import torch
import torch.nn as nn
# At the moment this class is only used by embeddings.Embeddings look-up tables
class Elementwise(nn.ModuleList):
"""
A simple network container.
Parameters are a list of modules.
Inputs are a 3d Tensor whose last dimension is the same length
... | 1,157 | 32.085714 | 79 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/conv_multi_step_attention.py | """ Multi Step Attention for CNN """
import torch
import torch.nn as nn
import torch.nn.functional as F
from onmt.utils.misc import aeq
SCALE_WEIGHT = 0.5 ** 0.5
def seq_linear(linear, x):
""" linear transform for 3-d tensor """
batch, hidden_size, length, _ = x.size()
h = linear(torch.transpose(x, 1, 2... | 2,856 | 33.421687 | 77 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/average_attn.py | # -*- coding: utf-8 -*-
""" Average Attention module """
import torch
import torch.nn as nn
from onmt.modules.position_ffn import PositionwiseFeedForward
class AverageAttention(nn.Module):
"""
Average Attention module from
"Accelerating Neural Transformer via an Average Attention Network"
:cite:`htt... | 4,041 | 35.414414 | 79 | py |
ExHiRD-DKG | ExHiRD-DKG-master/onmt/modules/copy_generator.py | import torch
import torch.nn as nn
import onmt
import onmt.inputters as inputters
from onmt.utils.misc import aeq, sequence_mask
from onmt.utils.loss import LossComputeBase
# add by wchen
from data_utils import P_START, A_START, KEY_SEPERATOR
EPS = 1e-8
class CopyGenerator(nn.Module):
"""An implementation of poi... | 36,327 | 42.350835 | 167 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.