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 |
|---|---|---|---|---|---|---|
udvd | udvd-main/utils/noise_model.py | import torch
from torch.distributions import Poisson
def get_noise(data, dist='G', noise_std = float(25)/255.0, mode='S',
min_noise = float(5)/255., max_noise = float(55)/255.):
if(dist == 'G'):
noise_std /= 255.
min_noise /= 255.
max_noise /= 255.
noise = torch.... | 846 | 34.291667 | 85 | py |
udvd | udvd-main/utils/meters.py | import time
import torch
class AverageMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
if isinstance(val, torch.Tensor):
val = val.item()
... | 1,309 | 20.129032 | 75 | py |
simulst | simulst-main/eval/generate.py | #!/usr/bin/env python3 -u
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Translate pre-processed data with a trained model.
"""
import ast
import logging
import math
import os
import sy... | 15,840 | 36.897129 | 180 | py |
simulst | simulst-main/eval/interactive.py | #!/usr/bin/env python3 -u
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Translate raw text with a trained model. Batches data on-the-fly.
"""
import ast
import fileinput
import logging... | 11,500 | 35.166667 | 88 | py |
simulst | simulst-main/DATA/data_utils.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import csv
from pathlib import Path
import zipfile
from functools import reduce
from multiprocessing import cpu_count
from typing import Any, ... | 12,483 | 31.010256 | 88 | py |
simulst | simulst-main/DATA/mustc/prep_mustc_data.py | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import logging
import os
from pathlib import Path
import shutil
from itertools import groupby
from temp... | 12,521 | 38.253918 | 104 | py |
simulst | simulst-main/DATA/mustc/seg_mustc_data.py | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import logging
from pathlib import Path
from itertools import groupby
from typing import Tuple
import ... | 5,204 | 33.932886 | 114 | py |
simulst | simulst-main/scripts/average_checkpoints.py | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import collections
import os
import re
import torch
from fairseq.file_io import PathManager
def aver... | 6,587 | 37.752941 | 175 | py |
simulst | simulst-main/codebase/modules/monotonic_multihead_attention.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# from asyncio.log import logger
import math
import torch
from torch import Tensor
import torch.nn as nn
from codebase.utils.p_choose_strate... | 19,678 | 32.018456 | 115 | py |
simulst | simulst-main/codebase/modules/fixed_pre_decision.py | from functools import partial
import torch
from torch import Tensor
import math
import torch.nn.functional as F
from . import register_monotonic_attention
from .monotonic_multihead_attention import (
MonotonicAttention,
MonotonicInfiniteLookbackAttention,
WaitKAttention
)
from typing import Dict, Optional... | 7,373 | 37.60733 | 91 | py |
simulst | simulst-main/codebase/modules/causal_conv.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from typing import Optional, Dict, List
from fairseq.incremental_decoding_utils import with_incremental_state
from fairseq.modules import ConvTBC
from fairseq.models.transformer import Linear
def make_causal(klass):
@with_... | 8,921 | 37.960699 | 130 | py |
simulst | simulst-main/codebase/models/transducer_model.py | import logging
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional, Dict, List
from torch import Tensor
from fairseq import checkpoint_utils
from fairseq.models import (
register_model,
register_model_architecture,
)
from fairseq.models.transformer import (
Transfo... | 10,911 | 34.086817 | 95 | py |
simulst | simulst-main/codebase/models/s2t_emformer.py | #!/usr/bin/env python3
import re
import logging
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from typing import Optional, Dict
from fairseq import checkpoint_utils
from fairseq.models import (
FairseqEncoder,
register_model,
register_model_architect... | 15,252 | 35.842995 | 113 | py |
simulst | simulst-main/codebase/models/cif_transformer.py | import re
import math
import torch
import torch.nn as nn
import logging
from typing import Optional, Dict, List
from torch import Tensor
from pathlib import Path
from fairseq import checkpoint_utils
from fairseq.models import (
register_model,
register_model_architecture
)
from fairseq.models.transformer import... | 26,903 | 35.554348 | 102 | py |
simulst | simulst-main/codebase/models/s2t_transformer.py | #!/usr/bin/env python3
import math
import torch.nn as nn
import logging
from pathlib import Path
from fairseq import checkpoint_utils
from fairseq.data.data_utils import lengths_to_padding_mask
from fairseq.modules import (
SamePad
)
from fairseq.models import (
register_model,
register_model_architecture,
... | 5,205 | 31.135802 | 84 | py |
simulst | simulst-main/codebase/models/mma_model.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Dict, List, Optional
import logging
from torch import Tensor
from fairseq import checkpoint_utils
from fairseq.models impor... | 9,436 | 34.081784 | 104 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wav2letter.py | from torch import Tensor
from torch import nn
__all__ = [
"Wav2Letter",
]
class Wav2Letter(nn.Module):
r"""Wav2Letter model architecture from *Wav2Letter: an End-to-End ConvNet-based Speech
Recognition System* [:footcite:`collobert2016wav2letter`].
:math:`\text{padding} = \frac{\text{ceil}(\text{ke... | 3,273 | 43.849315 | 113 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wavernn.py | import math
from typing import List, Tuple, Optional
import torch
import torch.nn.functional as F
from torch import Tensor
from torch import nn
__all__ = [
"ResBlock",
"MelResNet",
"Stretch2d",
"UpsampleNetwork",
"WaveRNN",
]
class ResBlock(nn.Module):
r"""ResNet block based on *Efficient Ne... | 15,136 | 36.467822 | 118 | py |
simulst | simulst-main/codebase/models/torchaudio_models/conv_tasnet.py | """Implements Conv-TasNet with building blocks of it.
Based on https://github.com/naplab/Conv-TasNet/tree/e66d82a8f956a69749ec8a4ae382217faa097c5c
"""
from typing import Tuple, Optional
import torch
class ConvBlock(torch.nn.Module):
"""1D Convolutional block.
Args:
io_channels (int): The number of... | 11,648 | 37.572848 | 119 | py |
simulst | simulst-main/codebase/models/torchaudio_models/deepspeech.py | import torch
__all__ = ["DeepSpeech"]
class FullyConnected(torch.nn.Module):
"""
Args:
n_feature: Number of input features
n_hidden: Internal hidden unit size.
"""
def __init__(self, n_feature: int, n_hidden: int, dropout: float, relu_max_clip: int = 20) -> None:
super(FullyC... | 2,754 | 31.034884 | 109 | py |
simulst | simulst-main/codebase/models/torchaudio_models/conformer.py | from typing import Optional, Tuple
import torch
__all__ = ["Conformer"]
def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor:
batch_size = lengths.shape[0]
max_length = int(torch.max(lengths).item())
padding_mask = torch.arange(max_length, device=lengths.device, dtype=lengths.dtype).expa... | 8,462 | 31.301527 | 115 | py |
simulst | simulst-main/codebase/models/torchaudio_models/emformer.py | import math
from typing import List, Optional, Tuple
import torch
from fairseq.modules import LayerNorm
__all__ = ["Emformer"]
def _lengths_to_padding_mask(lengths: torch.Tensor) -> torch.Tensor:
batch_size = lengths.shape[0]
max_length = int(torch.max(lengths).item())
padding_mask = torch.arange(max_l... | 38,325 | 41.726867 | 120 | py |
simulst | simulst-main/codebase/models/torchaudio_models/tacotron2.py | # *****************************************************************************
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions... | 45,802 | 42.705153 | 120 | py |
simulst | simulst-main/codebase/models/torchaudio_models/rnnt.py | from typing import List, Optional, Tuple
import torch
from . import Emformer
__all__ = ["RNNT", "emformer_rnnt_base", "emformer_rnnt_model"]
class _TimeReduction(torch.nn.Module):
r"""Coalesces frames along time dimension into a
fewer number of frames with higher feature dimensionality.
Args:
... | 34,383 | 42.689962 | 117 | py |
simulst | simulst-main/codebase/models/torchaudio_models/rnnt_decoder.py | from typing import Callable, Dict, List, Optional, NamedTuple, Tuple
import torch
from . import RNNT
__all__ = ["Hypothesis", "RNNTBeamSearch"]
class Hypothesis(NamedTuple):
r"""Represents hypothesis generated by beam search decoder ``RNNTBeamSearch``.
:ivar List[int] tokens: Predicted sequence of tokens.... | 13,542 | 36.619444 | 111 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wav2vec2/model.py | from typing import Optional, Tuple, List
import torch
from torch import Tensor
from torch.nn import Module
from . import components
class Wav2Vec2Model(Module):
"""torchaudio.models.Wav2Vec2Model(feature_extractor: torch.nn.Module, encoder: torch.nn.Module, aux: Optional[torch.nn.Module] = None)
Encoder mo... | 46,834 | 39.584922 | 896 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wav2vec2/components.py | import logging
from typing import Optional, Tuple, List
import torch
from torch import Tensor, nn
from torch.nn import Module, Parameter
_LG = logging.getLogger(__name__)
class LayerNorm(nn.LayerNorm):
"""Layer norm with transpose"""
def forward(self, input: Tensor) -> Tensor:
x = input.transpose(-... | 41,286 | 38.699038 | 161 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wav2vec2/utils/import_huggingface.py | """Import Hugging Face transformers's wav2vec2.0 pretrained weights to torchaudios's format.
"""
import logging
from torch.nn import Module
from ..model import Wav2Vec2Model, wav2vec2_model
_LG = logging.getLogger(__name__)
def _get_config(cfg):
config = {
"extractor_mode": f"{cfg.feat_extract_norm}_no... | 3,089 | 38.113924 | 107 | py |
simulst | simulst-main/codebase/models/torchaudio_models/wav2vec2/utils/import_fairseq.py | """Import fariseq's wav2vec2.0 pretrained weights to torchaudios's format.
For this module to work, you need `fairseq`.
"""
import re
from torch.nn import Module
from ..model import Wav2Vec2Model, wav2vec2_model
def _parse_config(w2v_model):
encoder = w2v_model.encoder
conv_layers = w2v_model.feature_extra... | 9,359 | 41.93578 | 110 | py |
simulst | simulst-main/codebase/agents/default_agent.py | import os
import ast
import logging
import numpy as np
import torch
from fairseq import utils, checkpoint_utils, tasks
from fairseq.data.audio.audio_utils import (
_get_kaldi_fbank, _get_torchaudio_fbank
)
logger = logging.getLogger(__name__)
try:
from kaldi.feat import fbank
logger.info(f"using kaldi fbank... | 17,885 | 36.41841 | 108 | py |
simulst | simulst-main/codebase/agents/cif_agent.py | import os
import logging
import numpy as np
import torch
from fairseq import utils, checkpoint_utils, tasks
from fairseq.data.audio.audio_utils import (
_get_kaldi_fbank, _get_torchaudio_fbank
)
logger = logging.getLogger(__name__)
try:
from kaldi.feat import fbank
logger.info(f"using kaldi fbank: {fbank.__... | 18,131 | 37.012579 | 108 | py |
simulst | simulst-main/codebase/criterion/ssnt_criterion.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from dataclasses import dataclass, field
import torch
from typing import Optional
from fairseq.criterions import (
register_criterion,
)
f... | 6,913 | 33.743719 | 114 | py |
simulst | simulst-main/codebase/criterion/rnnt_criterion.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from dataclasses import dataclass, field
import torch
from typing import Optional
from fairseq.criterions import (
register_criterion,
)
f... | 4,854 | 31.804054 | 112 | py |
simulst | simulst-main/codebase/criterion/cif_criterion.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from dataclasses import dataclass, field
import torch
import torch.nn.functional as F
from typing import Optional
from fairseq import metrics
... | 11,798 | 35.757009 | 117 | py |
simulst | simulst-main/codebase/criterion/mma_criterion.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from dataclasses import dataclass, field
import torch
from fairseq import metrics, utils
from fairseq.criterions import register_criterion
fro... | 8,196 | 36.090498 | 105 | py |
simulst | simulst-main/codebase/criterion/joint_ctc_criterion.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from dataclasses import dataclass, field
import torch
import torch.nn.functional as F
from typing import Optional
from fairseq import metrics
... | 7,207 | 32.525581 | 112 | py |
simulst | simulst-main/codebase/criterion/best_alignment/__init__.py | import torch
import torch.utils.cpp_extension
from pathlib import Path
import logging
module_path = Path(__file__).parent
build_path = module_path / "build"
build_path.mkdir(exist_ok=True)
try:
extension = torch.utils.cpp_extension.load(
"best_alignment_fn",
sources=[
module_path / "bes... | 3,920 | 34.008929 | 91 | py |
simulst | simulst-main/codebase/utils/monotonic_attention.py | from typing import Optional
import torch
from torch import Tensor
from codebase.utils.functions import (
exclusive_cumprod,
prob_check,
moving_sum,
)
def expected_alignment_from_p_choose(
p_choose: Tensor,
padding_mask: Optional[Tensor] = None,
eps: float = 1e-6
):
"""
Calculating exp... | 5,420 | 26.378788 | 78 | py |
simulst | simulst-main/codebase/utils/p_choose_strategy.py | from typing import Optional, Dict
from torch import Tensor
import torch
def waitk_p_choose(
tgt_len: int,
src_len: int,
bsz: int,
waitk_lagging: int,
key_padding_mask: Optional[Tensor] = None,
incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None
):
# Assuming the p_ch... | 2,025 | 25.311688 | 88 | py |
simulst | simulst-main/codebase/utils/functions.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
def prob_check(tensor, eps=1e-10):
assert not torch.isnan(tensor).any(), (
"Nan in a probability tensor."
)
... | 3,535 | 27.063492 | 84 | py |
simulst | simulst-main/codebase/tasks/speech_to_text_infer.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
import torch
import numpy as np
from fairseq import metrics, utils
from fairseq.tasks import register_task
from fairseq.logging... | 11,295 | 37.951724 | 107 | py |
simulst | simulst-main/codebase/tasks/translation_infer.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
import torch
import numpy as np
from typing import Optional
from argparse import Namespace
from dataclasses import dataclass, f... | 8,752 | 38.075893 | 91 | py |
CBP | CBP-main/main.py | import os
import time
import numpy as np
import pandas as pd
import argparse
import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
from torch.hub import load_state_dict_from_url
import torchvision
import torchvision.transforms as transforms
import torchvision.datasets as... | 12,052 | 36.431677 | 210 | py |
CBP | CBP-main/evaluate.py | import os
import time
import datetime
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import torch.backends.cudnn as cudnn
import torchvision
import torchvision.transforms as transforms
import torchvision.datasets as datasets
fr... | 3,533 | 33.990099 | 181 | py |
CBP | CBP-main/resnet_mode.py | import torch
import torch.nn as nn
from module import *
from torch.hub import load_state_dict_from_url
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
'wide_resnet50_2', 'wide_resnet101_2']
model_urls = {
'resnet18': '... | 15,321 | 42.405099 | 143 | py |
CBP | CBP-main/module.py | import torch.nn as nn
import torch.nn.functional as F
import torch
import math
from torch.autograd import Function
import torch
#Straight-Through-Estimator
class Quantizetotal(Function):
@staticmethod
def forward(ctx, weight,scale, b,df):
ctx.save_for_backward(weight,scale)
out = df[0]*(torch.s... | 4,580 | 34.789063 | 138 | py |
CBP | CBP-main/dali.py | import time
import torch.utils.data
import nvidia.dali.ops as ops
import nvidia.dali.types as types
import torchvision.datasets as datasets
from nvidia.dali.pipeline import Pipeline
import torchvision.transforms as transforms
from nvidia.dali.plugin.pytorch import DALIClassificationIterator, DALIGenericIterator
from PI... | 4,653 | 52.494253 | 124 | py |
CBP | CBP-main/alexnet_mode.py | import torch
import torch.nn as nn
from module import *
from torch.autograd import Variable
def conv(in_planes, out_planes, kernel_size, stride=1,padding = 1, groups=1, dilation=1, mode=None,bias = False):
if mode in ['bin', 'ter', '1bit', '2bit']:
return QConv2d(in_planes, out_planes, kernel_size, strid... | 3,101 | 36.373494 | 114 | py |
KernelGAN | KernelGAN-master/kernelGAN.py | import torch
import loss
import networks
import torch.nn.functional as F
from util import save_final_kernel, run_zssr, post_process_k
class KernelGAN:
# Constraint co-efficients
lambda_sum2one = 0.5
lambda_bicubic = 5
lambda_boundaries = 0.5
lambda_centralized = 0
lambda_sparse = 0
def __... | 5,718 | 43.679688 | 118 | py |
KernelGAN | KernelGAN-master/loss.py | import torch
import torch.nn as nn
from torch.autograd import Variable
from util import shave_a2b, resize_tensor_w_kernel, create_penalty_mask, map2tensor
# noinspection PyUnresolvedReferences
class GANLoss(nn.Module):
"""D outputs a [0,1] map of size of the input. This map is compared in a pixel-wise manner to 1... | 5,575 | 53.666667 | 186 | py |
KernelGAN | KernelGAN-master/data.py | import numpy as np
from torch.utils.data import Dataset
from imresize import imresize
from util import read_image, create_gradient_map, im2tensor, create_probability_map, nn_interpolation
class DataGenerator(Dataset):
"""
The data generator loads an image once, calculates it's gradient map on initialization a... | 4,008 | 49.1125 | 125 | py |
KernelGAN | KernelGAN-master/networks.py | import torch
import torch.nn as nn
from util import swap_axis
class Generator(nn.Module):
def __init__(self, conf):
super(Generator, self).__init__()
struct = conf.G_structure
# First layer - Converting RGB image to latent space
self.first_layer = nn.Conv2d(in_channels=1, out_chann... | 3,546 | 45.064935 | 157 | py |
KernelGAN | KernelGAN-master/util.py | import os
import time
import torch
import numpy as np
from PIL import Image
import scipy.io as sio
import matplotlib.pyplot as plt
from scipy.signal import convolve2d
from torch.nn import functional as F
from scipy.ndimage import measurements, interpolation
from ZSSRforKernelGAN.ZSSR import ZSSR
def move2cpu(d):
... | 10,519 | 44.150215 | 177 | py |
KernelGAN | KernelGAN-master/configs.py | import argparse
import torch
import os
# noinspection PyPep8
class Config:
def __init__(self):
self.parser = argparse.ArgumentParser()
self.conf = None
# Paths
self.parser.add_argument('--img_name', default='image1', help='image name for saving purposes')
self.parser.add_a... | 4,083 | 51.358974 | 158 | py |
disc-span-parser-release | disc-span-parser-release-master/pred_disc_biaffine.py | import argparse
import torch.optim
import sys
import pydestruct.data.ptb
import pydestruct.input
import disc_span_parser.network
import pydestruct.eval
import disc_span_parser
import pydestruct.data.export
import cpp_disc_span_parser
from pydestruct.timer import Timer
from disc_span_parser.biaffine_network import Biaf... | 6,140 | 35.123529 | 195 | py |
disc-span-parser-release | disc-span-parser-release-master/train_disc_biaffine.py | from __future__ import print_function
import argparse
import torch.optim
import random
import sys
import torch.nn as nn
import pydestruct.data.export
import disc_span_parser
import pydestruct.timer
from disc_span_parser.biaffine_network import BiaffineParserNetwork
from disc_span_parser.biaffine_input import build_tor... | 11,524 | 36.786885 | 191 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/optim.py | from torch.optim.optimizer import Optimizer
import torch
import transformers
class MetaOptimizer:
def __init__(self, args, params, filter_freezed=True, steps_per_epoch=-1, n_epochs=-1):
if filter_freezed:
# remove freezed parts of the model (e.g. Bert)
params = filter(lambda p: p.re... | 7,449 | 39.934066 | 121 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/batch.py | import random
from sklearn.cluster import KMeans
import numpy as np
import torch
def batch_iterator_factory(data, batch_size, n_clusters=-1, size_getter=None, shuffle=False):
if n_clusters > 1:
if size_getter is None:
raise RuntimeError("You need to give a function to compute the size of an in... | 3,085 | 33.674157 | 126 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/network.py | import torch.nn as nn
import torch
import itertools
import numpy as np
from pydestruct.nn.bert import Bert
from pydestruct.nn.characters import CharacterEncoder
#from pydestruct.nn.transformer import Transformer
from pydestruct.nn.bilstm import BiLSTM
#from pydestruct.nn.dependency import DependencyModule
import pydes... | 22,557 | 44.479839 | 175 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/functional.py | import ctypes
import torch.autograd
import pydestruct
# TODO: this use the old C++ API base on ctype!
# so it won't work...
# WARNING:
# you should not use directly the functions/classes of this file
# please use what is in the __init__.py file instead
def _log_partition_forward(ctx, input, fencepost):
pydestruc... | 3,412 | 27.923729 | 75 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/dict.py | import torch
import pydestruct.input
class Dict:
def __init__(self, words, unk=None, boundaries=False, pad=False, lower=False):
self._boundaries = boundaries
self._unk = unk
self._lower = lower
self._word_to_id = dict()
self._id_to_word = list()
if pad:
... | 3,174 | 29.238095 | 128 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/input.py | import torch
import pydestruct.network
def constituents_as_matrix(size, n_constituents, constituents, device="cpu"):
indices = torch.zeros((size, size, n_constituents), requires_grad=False, device="cpu")
for label, i, j in constituents:
# we use +=1 so it also works for discontinuous constituents
... | 5,136 | 46.564815 | 145 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/bert.py | import torch
import torch.nn
def get_scalar_mix():
from allennlp.modules.scalar_mix import ScalarMix
return ScalarMix
def get_transformers():
import transformers
return transformers
BERT_TOKEN_MAPPING = {
"-LRB-": "(",
"-RRB-": ")",
"-LCB-": "{",
"-RCB-": "}",
"-LSB-": "[",
"-... | 9,872 | 40.309623 | 220 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/tagger.py | import torch
import torch.nn as nn
# as of now this ia very simple, but it could be extended to allow for an hidden layer!
class TaggerModule(nn.Module):
def __init__(self, input_dim, n_labels, bias=True):
super(TaggerModule, self).__init__()
self.linear = nn.Linear(input_dim, n_labels, bias=bias)... | 385 | 31.166667 | 87 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/tree.py | import torch
import torch.autograd
import torch.nn as nn
class MatrixTree(nn.Module):
"""
Updateed code of: https://github.com/gujiuxiang/NMT.pytorch/blob/master/onmt/modules/StructuredAttention.py
instead, this ones take an adjacency matrix
"""
def __init__(self, eps=1e-5):
self.eps = ... | 2,024 | 31.142857 | 132 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/dependency.py | import torch
import torch.nn as nn
import math
import sys
from pydestruct.nn.mlp import MLP
from pydestruct.nn.dropout import SharedDropout
from pydestruct.nn.transformer import LayerNorm
class StandardDependencyModule(nn.Module):
def __init__(self,
input_dim,
proj_dim,
... | 13,127 | 36.616046 | 150 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/bilstm.py | # stolen from https://github.com/yzhangcs/biaffine-parser/blob/master/parser/modules/bilstm.py
from pydestruct.nn.dropout import SharedDropout
import torch
import torch.nn as nn
from torch.nn.modules.rnn import apply_permutation
from torch.nn.utils.rnn import PackedSequence
class BiLSTM(nn.Module):
def __init__... | 4,780 | 36.944444 | 94 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/fencepost.py | import torch
import torch.nn as nn
import torch.nn.functional as F
# THIS IS NOT MAINTAINED ANYMORE!
# Most of the code of this class comes from here: https://github.com/nikitakit/self-attentive-parser/blob/acl2018/src/parse_nk.py
# but packed as a nn and without batch support
class FencepostModule(nn.Module):
# ... | 6,303 | 43.70922 | 129 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/mlp.py |
import torch.nn as nn
from pydestruct.nn.dropout import SharedDropout
class MLP(nn.Module):
def __init__(self, dim_input, dim_output, dropout=0, activation="tanh", shared_dropout=True, negative_slope=0.1):
super(MLP, self).__init__()
if activation == "tanh":
activation = nn.Tanh()
... | 1,063 | 29.4 | 117 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/dropout.py | import torch
import torch.nn as nn
# Stolen from: https://github.com/yzhangcs/biaffine-parser/blob/master/parser/modules/dropout.py
class SharedDropout(nn.Module):
def __init__(self, p=0.5, batch_first=True):
super(SharedDropout, self).__init__()
self.p = p
self.batch_first = batch_first
... | 1,539 | 31.083333 | 96 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/transformer.py | import torch.nn as nn
import torch.nn.init
import torch.nn.functional as F
from pydestruct.nn.dropout import SharedDropout, IndependentDropout
#import pydestruct.nn.transformer_klein
class LayerNorm(nn.Module):
def __init__(self, dim, mean=0., std=1., fixed=False, eps=1e-6, ball=False):
super(LayerNorm, s... | 12,714 | 38.858934 | 115 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/nn/characters.py | import torch
import torch.nn as nn
import pydestruct.nn.dropout
class CharacterEncoder(nn.Module):
def __init__(self, emb_dim, voc_size, lstm_dim, input_dropout=0., default_lstm_init=False):
super(CharacterEncoder, self).__init__()
self.input_dropout = pydestruct.nn.dropout.IndependentDropout(inpu... | 2,981 | 39.849315 | 98 | py |
disc-span-parser-release | disc-span-parser-release-master/pydestruct/algorithms/msa.py | import torch
import numpy as np
# from https://github.com/UppsalaNLP/uuparser/blob/master/barchybrid/src/chuliu_edmonds.py
def msa_multi_root(scores):
""""""
np.fill_diagonal(scores, -float('inf')) # prevent self-loops
scores[0] = -float('inf')
scores[0,0] = 0
tree = np.argmax(scores, axis=1)
... | 7,448 | 38.62234 | 108 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/network.py | import torch.nn as nn
import torch
from pydestruct.network import FeatureExtractionModule, WeightingModule, LSTMWeightingModule
from pydestruct.nn.dependency import DependencyModule
from pydestruct.nn.tagger import TaggerModule
class Network(nn.Module):
def __init__(self, args, n_labels, n_disc_labels, predict_t... | 6,148 | 45.938931 | 138 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/loss.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import pydestruct
import disc_span_parser
import cpp_disc_span_parser
import pydestruct.input
def get_indices(cst_weights, pred_cst, device="cpu"):
pred_cst_indices = torch.zeros_like(cst_weights, requires_grad=False, device="cpu")
for label, ... | 8,211 | 42.449735 | 176 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/biaffine_input.py | import torch
import collections
from pydestruct.dict import Dict
from pydestruct.input import tensor_from_dict
from pydestruct.text import is_punct
import pydestruct.nn.bert
def build_constituent_inputs(sentence, dicts, device="cpu"):
cont_span1, cont_span2, cont_labels = list(), list(), list()
disc_span1, dis... | 4,720 | 37.382114 | 148 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/biaffine_network.py | import torch
import torch.nn as nn
from pydestruct.input import tensor_from_dict
import numpy as np
from pydestruct.network import FeatureExtractionModule
from pydestruct.nn.bilstm import BiLSTM
from pydestruct.nn.dropout import SharedDropout
from pydestruct.nn.dependency import BatchedBiaffine
from pydestruct.dict im... | 5,758 | 45.072 | 135 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/__init__.py | import pydestruct.functional
import torch.nn as nn
import torch
import cpp_disc_span_parser
LIB_PARALLEL = False
ARGMAX_DISC_CHART = None
ARGMAX_CUBIC_CHART = None
def load_cpp_lib_cubic(max_size, n_labels):
global ARGMAX_CUBIC_CHART
if max_size <= 0:
raise RuntimeError("The chart size must be positiv... | 4,281 | 37.232143 | 120 | py |
disc-span-parser-release | disc-span-parser-release-master/disc_span_parser/biaffine_loss.py | import torch
import torch.nn as nn
import numpy as np
import sys
import disc_span_parser
"""
class MarginLoss(nn.Module):
def __init__(self, complexity, ill_nested, reduction="mean"):
super(MarginLoss, self).__init__()
self.complexity = complexity
self.ill_nested = ill_nested
self.m... | 12,651 | 44.185714 | 149 | py |
deviation-network | deviation-network-master/devnet.py | # -*- coding: utf-8 -*-
"""
@author: Guansong Pang
The algorithm was implemented using Python 3.6.6, Keras 2.2.2 and TensorFlow 1.10.1.
More details can be found in our KDD19 paper.
Guansong Pang, Chunhua Shen, and Anton van den Hengel. 2019.
Deep Anomaly Detection with Deviation Networks.
In The 25th ACM SIGKDDConfe... | 14,968 | 41.768571 | 185 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/sam.py | import torch
class SAM(torch.optim.Optimizer):
def __init__(self, params, base_optimizer, rho=0.05, **kwargs):
assert rho >= 0.0, f"Invalid rho, should be non-negative: {rho}"
defaults = dict(rho=rho, **kwargs)
super(SAM, self).__init__(params, defaults)
self.base_optimizer = bas... | 2,128 | 33.901639 | 131 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/sgd_train.py | import argparse
import torch
import os
from model.wide_res_net import Wide_ResNet
from model.shake_shake import ShakeShake
from model.pyramidnet import PyramidNet
from cifar import Cifar
from utility.log import Log
from utility.initialize import initialize
from utility.step_lr import StepLR, get_cosine_annealing_schedu... | 9,100 | 36.763485 | 124 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/sam_train.py | import argparse
import torch
import os
from model.wide_res_net import Wide_ResNet
from model.shake_shake import ShakeShake
from model.pyramidnet import PyramidNet
from cifar import Cifar
from utility.log import Log
from utility.initialize import initialize
from utility.step_lr import StepLR, get_cosine_annealing_schedu... | 9,475 | 36.752988 | 124 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/cifar.py | import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from utility.cutout import Cutout
from utility.autoaugment import AutoAugment
class Cifar:
def __init__(self, batch_size, threads, want_cifar100=False, cutout=False, autoaugment=False):
self... | 2,532 | 41.216667 | 134 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/lpf_train.py | import argparse
import torch
import os
from model.wide_res_net import Wide_ResNet
from model.shake_shake import ShakeShake
from model.pyramidnet import PyramidNet
from cifar import Cifar
from utility.log import Log
from utility.initialize import initialize
from utility.step_lr import StepLR, get_cosine_annealing_schedu... | 11,094 | 37.524306 | 161 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utility/initialize.py | import random
import torch
def initialize(args, seed: int):
random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
torch.backends.cudnn.deterministic = False
| 312 | 21.357143 | 46 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utility/train_utils.py | import torch
from torchvision import transforms
from torch.utils.data import DataLoader
from torchvision.datasets import CIFAR10, CIFAR100, ImageNet, MNIST, ImageFolder
def get_loader(args, training, augment=False):
""" function to get data loader specific to different datasets
"""
if args.dtype == 'cifar... | 7,451 | 32.41704 | 80 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utility/cutout.py | import torch
class Cutout:
def __init__(self, size=16, p=0.5):
self.size = size
self.half_size = size // 2
self.p = p
def __call__(self, image):
if torch.rand([1]).item() > self.p:
return image
left = torch.randint(-self.half_size, image.size(1) - self.hal... | 620 | 28.571429 | 89 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utility/step_lr.py | import torch
import numpy as np
import logging
class StepLR:
def __init__(self, optimizer, learning_rate: float, total_epochs: int):
self.optimizer = optimizer
self.total_epochs = total_epochs
self.base = learning_rate
def step(self, epoch):
# let total_epochs = 200
... | 1,927 | 29.603175 | 118 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utils/fit.py | import torch
import logging
import time
from utils.train_utils import AverageMeter, accuracy
import numpy as np
def class_model_run(phase, loader, model, criterion, optimizer, args):
"""
Function to forward pass through classification problem
"""
logger = logging.getLogger('my_log')
if phase ... | 1,918 | 28.984375 | 79 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utils/spectral_utils.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import torch
from tqdm import tqdm
import math
import numpy as np
def get_hessian(batch_loss, model):
grads = torch.autograd.grad(batch_loss, model.parameters(), create_graph=True)
grads = torch.cat([x.vie... | 9,806 | 38.071713 | 108 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utils/train_utils.py | import sys
sys.path.append("../")
import torch
from torchvision import datasets, transforms
from sklearn.metrics import average_precision_score
from utils.data_loader_mnist import MNIST
from utils.data_loader_cifar import CIFAR10, CIFAR10_NOISY
def get_loader(args, training, data_load_fraction=1.0, label_noise=0.0):
... | 5,324 | 31.668712 | 91 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utils/data_loader_cifar.py | from __future__ import print_function
from PIL import Image
import os
import os.path
import numpy as np
import sys
if sys.version_info[0] == 2:
import cPickle as pickle
else:
import pickle
import torch.utils.data as data
from torchvision.datasets.utils import download_url, check_integrity
import torch
from tor... | 9,561 | 37.401606 | 120 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/utils/data_loader_mnist.py | from __future__ import print_function
from torchvision.datasets.vision import VisionDataset
import warnings
from PIL import Image
import os
import os.path
import numpy as np
import torch
import codecs
from sklearn.model_selection import train_test_split
from torchvision.datasets.utils import download_url, download_and_... | 9,832 | 36.10566 | 118 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/model/pyramidnet.py | import torch
import torch.nn as nn
import math
#from math import round
import torch.utils.model_zoo as model_zoo
def conv3x3(in_planes, out_planes, stride=1):
"3x3 convolution with padding"
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
clas... | 9,017 | 36.732218 | 168 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/model/shake_shake.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import torch
from torch.autograd import Function
class ShakeFunction(Function):
@staticmethod
def forward(ctx, x1, x2, alpha, beta):
ctx.save_for_backward(x1, x2, alpha, beta)
y = x1 * alpha + x2 * (1 - alpha)
return ... | 7,669 | 30.825726 | 78 | py |
LPF-SGD | LPF-SGD-master/codes/wrn_dataaug/example/model/wide_res_net.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
def __init__(self, in_planes, out_planes, stride, dropRate=0.0):
super(BasicBlock, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)
self.relu1 = nn.ReLU(inplace=True)
se... | 12,862 | 42.60339 | 116 | py |
LPF-SGD | LPF-SGD-master/codes/adversarial/main.py | import torchvision.models as models
import eagerpy as ep
from foolbox import PyTorchModel, accuracy, samples
import foolbox.attacks as fa
import numpy as np
from models import Wide_ResNet, ShakeShake, PyramidNet
import torch
import argparse
from utils import accuracy, AverageMeter
from cifar import Cifar
from tqdm impo... | 4,278 | 32.692913 | 118 | py |
LPF-SGD | LPF-SGD-master/codes/adversarial/utils.py | import torch
def accuracy(output, target, topk=(1,)):
with torch.no_grad():
maxk = max(topk)
batch_size = target.size(0)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.reshape(1, -1).expand_as(pred))
res = []
for k in topk... | 866 | 24.5 | 76 | py |
LPF-SGD | LPF-SGD-master/codes/adversarial/cifar.py | import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from utility.cutout import Cutout
from utility.autoaugment import AutoAugment
class Cifar:
def __init__(self, batch_size, threads, want_cifar100=False, cutout=False, autoaugment=False):
self... | 2,619 | 41.258065 | 134 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.