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 |
|---|---|---|---|---|---|---|
CPFN | CPFN-master/PointNet2/pointnet2_ops/modules/pointset_feature_propagation.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .geometry_utils import three_nn, three_weighted_sum
class PointsetFeaturePropagation(nn.Module):
"""
Propagate features from an abstracted point set back to the original point set,
analogous to upsampling followed by 1x1 convolutions o... | 2,234 | 41.980769 | 122 | py |
CPFN | CPFN-master/PointNet2/pointnet2_ops/modules/pointset_abstraction.py | from collections.abc import Sequence
import torch
import torch.nn as nn
import torch.nn.functional as F
from .geometry_utils import farthest_point_sample, select_point_subset, ball_query
class PointsetAbstraction(nn.Module):
"""
Abstract a point set (possibly with features) into a smaller point set,
analog... | 3,755 | 47.779221 | 114 | py |
CPFN | CPFN-master/PointNet2/pointnet2_ops/modules/geometry_utils.py | import torch
from .. import cuda_ops
def pairwise_squared_distance(src, dst):
"""
Calculate squared euclidean distance between each pair of points from src to dst.
src^T * dst = xn * xm + yn * ym + zn * zm；
sum(src^2, dim=-1) = xn*xn + yn*yn + zn*zn;
sum(dst^2, dim=-1) = xm*xm + ym*ym + zm*zm;
... | 10,626 | 36.419014 | 135 | py |
pdf2image | pdf2image-master/docs/conf.py | #
# Configuration file for the Sphinx documentation builder.
#
# This file does only contain a selection of the most common options. For a
# full list see the documentation:
# http://www.sphinx-doc.org/en/master/config
# -- Path setup --------------------------------------------------------------
# If extensions (or ... | 5,595 | 27.697436 | 79 | py |
learning-to-quantize | learning-to-quantize-master/args.py | import argparse
import yaml
import os
import torch
import utils
def add_args():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch NUQSGD')
# options overwritting yaml options
parser.add_argument('--path_opt', default='default.yaml',
type=str, help='pat... | 8,495 | 47 | 81 | py |
learning-to-quantize | learning-to-quantize-master/utils.py | import shutil
import torch
import numpy as np
class DictWrapper(object):
def __init__(self, d):
self.d = d
def __getattr__(self, key):
if key in self.d:
return self.d[key]
else:
return None
class SaveCheckpoint(object):
def __init__(self):
# remem... | 3,161 | 28.551402 | 76 | py |
learning-to-quantize | learning-to-quantize-master/data.py | import torch
from torchvision import datasets, transforms
import torch.utils.data as data
import numpy as np
import os
def get_loaders(opt):
if opt.dataset == 'mnist':
return get_mnist_loaders(opt)
elif opt.dataset == 'cifar10':
return get_cifar10_loaders(opt)
elif opt.dataset == 'cifar100... | 9,431 | 31.979021 | 78 | py |
learning-to-quantize | learning-to-quantize-master/log_utils.py | from collections import OrderedDict, defaultdict
import numpy as np
from tensorboardX import SummaryWriter
import time
import torch
import os
class TBXWrapper(object):
def configure(self, logger_name, flush_secs=5, opt=None):
self.writer = SummaryWriter(logger_name, flush_secs=flush_secs)
self.log... | 5,411 | 27.041451 | 75 | py |
learning-to-quantize | learning-to-quantize-master/log_plotter.py | from scipy import interpolate
import numpy as np
import os
import re
import torch
import pylab as plt
import matplotlib.ticker as mtick
from tensorboard.backend.event_processing import event_accumulator
def get_run_names(logdir, patterns):
run_names = []
for pattern in patterns:
for root, subdirs, fil... | 8,772 | 36.016878 | 104 | py |
learning-to-quantize | learning-to-quantize-master/models/cifar10_wresnet2.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... | 3,794 | 42.62069 | 116 | py |
learning-to-quantize | learning-to-quantize-master/models/logreg.py | import torch.nn as nn
import torch.nn.functional as F
class Linear(nn.Module):
def __init__(self, dim, num_class):
super(Linear, self).__init__()
self.linear = nn.Linear(dim, num_class)
def forward(self, x):
x = self.linear(x)
return F.log_softmax(x, dim=-1)
class TwoLinear(... | 637 | 24.52 | 48 | py |
learning-to-quantize | learning-to-quantize-master/models/linreg.py | import torch.nn as nn
# import torch.nn.functional as F
class Linear(nn.Module):
def __init__(self, dim, num_class):
super(Linear, self).__init__()
self.linear = nn.Linear(dim, num_class)
def forward(self, x):
x = self.linear(x)
return x
class TwoLinear(nn.Module):
def _... | 623 | 23 | 48 | py |
learning-to-quantize | learning-to-quantize-master/models/loss.py | import torch.nn.functional as F
def nll_loss(model, data, reduction='mean', weights=1):
data, target = data[0].cuda(), data[1].cuda()
model.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction=reduction)*weights
return loss
| 270 | 26.1 | 66 | py |
learning-to-quantize | learning-to-quantize-master/models/cifar10_wresnet.py | # https://github.com/xternalz/WideResNet-pytorch/blob/master/wideresnet.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.B... | 3,850 | 43.264368 | 116 | py |
learning-to-quantize | learning-to-quantize-master/models/cifar10.py | # https://github.com/akamaster/pytorch_resnet_cifar10
'''
Properly implemented ResNet-s for CIFAR10 as described in paper [1].
The implementation and structure of this file is hugely influenced by [2]
which is implemented for ImageNet and doesn't have option A for identity.
Moreover, most of the implementations on the... | 7,687 | 31.033333 | 78 | py |
learning-to-quantize | learning-to-quantize-master/models/__init__.py | import torch
import torch.nn
import models.mnist
import models.cifar10
import models.logreg
import models.imagenet
import models.cifar10_wresnet
import models.loss
def init_model(opt):
if opt.dataset == 'mnist':
if opt.arch == 'cnn':
model = models.mnist.Convnet(not opt.nodropout)
elif... | 1,969 | 36.169811 | 78 | py |
learning-to-quantize | learning-to-quantize-master/models/imagenet.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.models
class Model(nn.Module):
def __init__(self, arch, pretrained=False, nclass=None):
super(Model, self).__init__()
model = torchvision.models.__dict__[arch](pretrained)
if arch.startswith('alexnet') or... | 910 | 34.038462 | 73 | py |
learning-to-quantize | learning-to-quantize-master/models/clone_model.py | import torch
import torch.nn as nn
import copy
from torch.nn.parallel.parallel_apply import parallel_apply
class CloneModel(nn.Module):
def __init__(self, module, batch_size):
super(CloneModel, self).__init__()
self.replicas = [module]
self.batch_size = batch_size
for i in range(ba... | 887 | 28.6 | 75 | py |
learning-to-quantize | learning-to-quantize-master/models/mnist.py | import torch.nn as nn
import torch.nn.functional as F
class MNISTNet(nn.Module):
def __init__(self, dropout=True):
"""30 epochs no lr update
"""
super(MNISTNet, self).__init__()
self.dropout = dropout
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv... | 5,494 | 30.58046 | 61 | py |
learning-to-quantize | learning-to-quantize-master/estim/optim.py | import logging
import torch
import utils
from data import get_minvar_loader
from log_utils import LogCollector
from estim.gvar import MinVarianceGradient
class OptimizerFactory(object):
def __init__(self, model, train_loader, tb_logger, opt):
self.model = model
self.opt = opt
self.niters... | 2,964 | 33.476744 | 126 | py |
learning-to-quantize | learning-to-quantize-master/estim/sgd.py | import torch
import torch.nn
import torch.multiprocessing
from .gestim import GradientEstimator
class SGDEstimator(GradientEstimator):
def __init__(self, *args, **kwargs):
super(SGDEstimator, self).__init__(*args, **kwargs)
self.init_data_iter()
def grad(self, model, in_place=False):
... | 543 | 22.652174 | 59 | py |
learning-to-quantize | learning-to-quantize-master/estim/gvar.py | import torch
import torch.nn
import torch.multiprocessing
import numpy as np
from estim.sgd import SGDEstimator
from estim.nuq import NUQEstimator
#from estim.nuq import NUQEstimatorSingleGPUParallel
from estim.nuq import NUQEstimatorMultiGPUParallel
class MinVarianceGradient(object):
def __init__(self, model, ... | 7,202 | 41.875 | 198 | py |
learning-to-quantize | learning-to-quantize-master/estim/nuq.py | import torch
import torch.nn
import torch.multiprocessing
import numpy as np
import copy
import math
from args import opt_to_nuq_kwargs
from .gestim import GradientEstimator
from nuq.quantize import QuantizeMultiBucket
class NUQEstimator(GradientEstimator):
def __init__(self, *args, **kwargs):
super(NUQE... | 5,978 | 35.018072 | 78 | py |
learning-to-quantize | learning-to-quantize-master/estim/gestim.py | import torch
import torch.nn
import torch.multiprocessing
import numpy as np
import math
import random
import copy
import logging
from data import InfiniteLoader
class GradientEstimator(object):
def __init__(self, data_loader, opt, tb_logger=None, *args, **kwargs):
self.opt = opt
self.model = No... | 24,608 | 34.105563 | 167 | py |
learning-to-quantize | learning-to-quantize-master/nuq/quantize.py | import numpy as np
import torch
from cuquant import QDQ
import math
from estim.dist import TruncNorm, CondNormalTrunc, CondNormalTruncHist
import time
from scipy.stats import truncnorm, norm
import scipy.integrate as integrate
EPS = 1e-7
def get_quantile_levels(bits, grad_dist):
"""quantile levels """
num_l... | 17,549 | 35.036961 | 102 | py |
learning-to-quantize | learning-to-quantize-master/nuq/cuda/test.py | import torch
import cuquant as qdq
import numpy as np
def test_qdq_gpu():
if not torch.cuda.is_available():
return
x = torch.randn(1000).cuda().uniform_(-1, 1)
q = qdq.qdq_gpu(x)
dq = np.unique(q.cpu().numpy())
print('x', x)
print('q', q)
print('unique q', dq)
print('# unique q... | 380 | 18.05 | 48 | py |
learning-to-quantize | learning-to-quantize-master/nuq/cuda/qdq.py | import torch
import math
from cuquant import QDQ
def get_uniform_levels(bits):
num_levels = 2 << bits - 1
levels_uni = torch.linspace(-1, 1, steps=num_levels)
return levels_uni
def qdq_gpu(a):
assert isinstance(a, torch.cuda.FloatTensor)
bucket_size = 16
asize = a.size()
num_tail = math... | 867 | 26.125 | 69 | py |
learning-to-quantize | learning-to-quantize-master/nuq/cuda/setup.py | import os
from setuptools import setup
from torch.utils.cpp_extension import CUDAExtension, BuildExtension
os.system('make -j%d' % os.cpu_count())
# Python interface
setup(
name='CuQuantize',
version='0.1.0',
install_requires=['torch'],
packages=['cuquant'],
package_dir={'cuquant': './'},
ext_... | 735 | 23.533333 | 67 | py |
learning-to-quantize | learning-to-quantize-master/nuq/cuda/__init__.py | import torch
from cuquant_back import QDQ
from .qdq import qdq_gpu
| 69 | 10.666667 | 28 | py |
learning-to-quantize | learning-to-quantize-master/grid/cluster.py | from __future__ import print_function
def ssh(sargs):
"""
rm jobs/*.sh jobs/log/* -f && python grid_run.py --grid G --run_name X
pattern=""; for i in 1 2; do ./kill.sh $i $pattern; done
./start.sh
"""
jobs_0 = ['machine0_gpu0', 'machine0_gpu1',
'machine1_gpu0', 'machine1_gpu1',
... | 2,057 | 31.666667 | 76 | py |
learning-to-quantize | learning-to-quantize-master/main/gvar.py | from __future__ import print_function
import numpy as np
import logging
import os
import sys
import torch
import torch.nn
import torch.backends.cudnn as cudnn
import torch.optim
import torch.nn.functional as F
import torch.multiprocessing
import utils
import models
from data import get_loaders
from args import get_op... | 7,579 | 34.754717 | 94 | py |
PyBDSF | PyBDSF-master/doc/source/conf.py | # -*- coding: utf-8 -*-
#
# PyBDSF documentation build configuration file, created by
# sphinx-quickstart on Thu Jan 19 13:27:03 2012.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All ... | 9,149 | 30.6609 | 83 | py |
confident-sinkhorn-allocation | confident-sinkhorn-allocation-master/setup.py | from setuptools import setup, find_packages
setup(
name='csa',
version='1.0',
packages=find_packages(),
include_package_data = True,
description='Confident Sinkhorn Allocation',
install_requires=[
"colorama>=0.4.5",
"cycler>=0.11.0",
"fonttools>=4.33.3",
"joblib>... | 741 | 23.733333 | 48 | py |
confident-sinkhorn-allocation | confident-sinkhorn-allocation-master/algorithm/flexmatch.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 15 14:19:22 2021
@author: Vu Nguyen
"""
import numpy as np
from tqdm import tqdm
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
from scipy import stats
from .pseudo_labeling import Pseudo_Labeling
# FlexMatch Strategy for Pseudo-Labeling... | 8,767 | 42.405941 | 151 | py |
confident-sinkhorn-allocation | confident-sinkhorn-allocation-master/algorithm/pseudo_labeling.py |
import numpy as np
from tqdm import tqdm
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
import matplotlib.pyplot as plt
from sklearn.multioutput import MultiOutputClassifier
import copy
import sklearn
class Pseudo_Labeling(object):
# implementation of the master class for pseudo... | 16,406 | 38.439904 | 144 | py |
confident-sinkhorn-allocation | confident-sinkhorn-allocation-master/algorithm/csa.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 15 14:19:22 2021
@author: Vu Nguyen
"""
import numpy as np
from tqdm import tqdm
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
import matplotlib.pyplot as plt
from scipy import stats
import time
from .pseudo_labeling import Pseudo_Labe... | 16,573 | 38.368171 | 155 | py |
confident-sinkhorn-allocation | confident-sinkhorn-allocation-master/algorithm/ups.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 15 14:19:22 2021
@author: Vu Nguyen
"""
import numpy as np
from tqdm import tqdm
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
import matplotlib.pyplot as plt
from .pseudo_labeling import Pseudo_Labeling
# UPS: ==========================... | 7,123 | 42.175758 | 135 | py |
Unimer | Unimer-master/lr_scheduler_wrapper.py | # coding=utf8
from typing import Dict, Any
from overrides import overrides
from torch.optim.lr_scheduler import MultiStepLR
from allennlp.training.learning_rate_schedulers import LearningRateScheduler
class PyTorchMultiStepLearningRateSchedulerWrapper(LearningRateScheduler):
def __init__(self, lr_scheduler: Mu... | 816 | 27.172414 | 76 | py |
Unimer | Unimer-master/custom_trainer.py | # coding=utf8
import math
import time
import torch
import logging
from typing import Dict, List, Tuple, Optional, Iterable, Union, Callable, NoReturn
from allennlp.data import Instance
from allennlp.data.iterators.data_iterator import TensorDict, DataIterator
from allennlp.models import Model
from allennlp.training.ch... | 13,380 | 46.282686 | 119 | py |
Unimer | Unimer-master/model_builder.py | # coding=utf8
import numpy
import torch
from typing import Dict, List, Callable
from overrides import overrides
from allennlp.modules.seq2seq_encoders import PytorchSeq2SeqWrapper
from allennlp.training.metrics import Metric
from allennlp.models.model import Model
from allennlp.data.vocabulary import Vocabulary
from a... | 15,631 | 50.084967 | 120 | py |
Unimer | Unimer-master/run_parser.py | # coding=utf-8
import re
import os
import json
import copy
import random
import torch
import itertools
from typing import Dict, Any
from overrides import overrides
from absl import app
from absl import flags
import numpy as np
import torch
import torch.optim as optim
from torch.optim.lr_scheduler import MultiStepLR
fr... | 21,059 | 46.432432 | 120 | py |
Unimer | Unimer-master/neural_models/recombination_seq2seq_copy.py | # coding=utf8
from typing import Dict, List, Tuple
import numpy
from overrides import overrides
import torch
import torch.nn.functional as F
from torch.nn.modules.linear import Linear
from torch.nn.modules.rnn import LSTMCell
from allennlp.common.util import START_SYMBOL, END_SYMBOL
from allennlp.data.vocabulary imp... | 29,535 | 47.182708 | 137 | py |
Unimer | Unimer-master/neural_models/seq2seq_model.py | # coding=utf8
import torch
from overrides import overrides
from typing import Dict, List, Tuple
from allennlp.training.metrics import Metric
from allennlp.models.model import Model
from allennlp.data.vocabulary import Vocabulary
from allennlp.nn import util
from allennlp.modules import Attention, TextFieldEmbedder, Se... | 3,441 | 37.244444 | 98 | py |
Unimer | Unimer-master/neural_models/utils.py | # coding=utf8
import numpy
import torch
from typing import List
def has_nan(x: torch.Tensor) -> bool:
return torch.isnan(x).any()
def matrix_cosine_similarity(x: torch.Tensor, y: torch.Tensor, eps: float=1e-8):
"""
:param x (batch_size, length_1, dim)
:param y (batch_size, length_2, dim)
:retur... | 1,279 | 31.820513 | 80 | py |
Unimer | Unimer-master/neural_models/GNN.py | # coding=utf8
import numpy
import torch
import torch.nn as nn
from allennlp.models.model import Model
from allennlp.data.tokenizers import Token
from allennlp.common.util import START_SYMBOL, END_SYMBOL
from allennlp.data.vocabulary import Vocabulary
from allennlp.modules import Embedding
from allennlp.modules.text_fi... | 33,952 | 50.057143 | 122 | py |
Unimer | Unimer-master/neural_models/GNN2.py | # coding=utf8
import numpy
import torch
import torch.nn as nn
from allennlp.models.model import Model
from allennlp.data.tokenizers import Token
from allennlp.common.util import START_SYMBOL, END_SYMBOL
from allennlp.data.vocabulary import Vocabulary
from allennlp.modules import Embedding
from allennlp.modules.text_fi... | 34,001 | 50.130827 | 122 | py |
Unimer | Unimer-master/neural_models/grammar_based_models.py | # coding=utf8
import numpy
import torch
import torch.nn as nn
from typing import Dict, List
from overrides import overrides
from allennlp.training.metrics import Metric
from allennlp.models.model import Model
from allennlp.data.vocabulary import Vocabulary
from allennlp.nn import util
from allennlp.modules.text_field_... | 3,744 | 42.546512 | 134 | py |
Unimer | Unimer-master/neural_models/recombination_seq2seq.py | # coding=utf8
import numpy
import torch
from typing import Dict, Tuple, Union, List, Any
from allennlp.models import SimpleSeq2Seq
from allennlp.data.vocabulary import Vocabulary
from allennlp.modules import TextFieldEmbedder, Seq2SeqEncoder, Attention, SimilarityFunction
from allennlp.nn import util, InitializerAppli... | 11,830 | 47.093496 | 122 | py |
Unimer | Unimer-master/neural_models/modules/grammar_decoder.py | # coding=utf-8
import torch
import copy
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from overrides import overrides
from allennlp.modules import Embedding
from typing import Tuple, List, Dict
from .. import utils as nn_utils
class LSTMGrammarDecoder(nn.Module):
def __init__(self,
... | 14,904 | 44.166667 | 137 | py |
Unimer | Unimer-master/neural_models/modules/gnn_multi_head_attention.py | # coding=utf8
import math
import torch
import numpy as np
import torch.nn as nn
from allennlp.nn import util
from torch.nn import Parameter
import torch.nn.functional as F
from torch.nn.init import xavier_uniform_
class GNNMatrixMultiHeadAttention(nn.Module):
def __init__(self, d_model: int, nhead: int, nlabels... | 17,043 | 40.77451 | 134 | py |
Unimer | Unimer-master/neural_models/modules/gnn_encoder.py | # coding=utf8
import copy
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import MultiheadAttention
from .gnn_multi_head_attention import GNNMatrixMultiHeadAttention, GNNVectorMultiHeadAttention, \
GNNVectorContinuousMultiHeadAttention, GNNVectorMultiHeadAttention2
def _get_clone... | 20,183 | 48.349633 | 179 | py |
Unimer | Unimer-master/neural_models/modules/grammar_copy_decoder_2.py | # coding=utf-8
import torch
import copy
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from overrides import overrides
from allennlp.modules import Embedding
from typing import Tuple, List, Dict
from .. import utils as nn_utils
class LSTMGrammarCopyDecoder(nn.Module):
def __init__(self... | 20,773 | 46.429224 | 150 | py |
Unimer | Unimer-master/neural_models/modules/grammar_copy_decoder.py | # coding=utf-8
import torch
import copy
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from overrides import overrides
from allennlp.modules import Embedding
from typing import Tuple, List, Dict
from .. import utils as nn_utils
class LSTMGrammarCopyDecoder(nn.Module):
def __init__(self... | 20,697 | 46.363844 | 150 | py |
Unimer | Unimer-master/metrics/sequency_accuracy.py | # coding=utf8
import torch
from overrides import overrides
from allennlp.training.metrics import Metric
from typing import Union, Tuple, Dict, List, Optional
class SequenceAccuracy(Metric):
def __init__(self) -> None:
self._correct_counts = 0.
self._total_counts = 0.
self._pad_index = -1... | 1,684 | 29.636364 | 118 | py |
seld-dcase2023 | seld-dcase2023-main/visualize_seldnet_output.py | #
# A wrapper script that trains the SELDnet. The training stops when the early stopping metric - SELD error stops improving.
#
import numpy as np
import os
import sys
import cls_data_generator
import seldnet_model
import parameters
import torch
from IPython import embed
import matplotlib
matplotlib.use('Agg')
#matplot... | 5,100 | 41.157025 | 133 | py |
seld-dcase2023 | seld-dcase2023-main/seldnet_model.py | # The SELDnet architecture
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
from IPython import embed
class MSELoss_ADPIT(object):
def __init__(self):
super().__init__()
self._each_loss = nn.MSELoss(reduction='none')
def _each_calc(self, outpu... | 9,178 | 48.085561 | 215 | py |
seld-dcase2023 | seld-dcase2023-main/train_seldnet.py | #
# A wrapper script that trains the SELDnet. The training stops when the early stopping metric - SELD error stops improving.
#
import os
import sys
import numpy as np
import matplotlib.pyplot as plot
import cls_feature_class
import cls_data_generator
import seldnet_model
import parameters
import time
from time import... | 22,604 | 55.5125 | 369 | py |
AACVP-MVSNet | AACVP-MVSNet-main/train_AACVPMVSNet.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/8/3 0016 11:52
# @Author : Anzhu Yu
# @Site :
# @File : train_AACVPMVSNet.py
# @Software: PyCharm
# some packages used in this project
from argsParser import getArgsParser, checkArgs
import os
import logging
import torch
import torch.nn as nn
impo... | 7,685 | 33.466368 | 119 | py |
AACVP-MVSNet | AACVP-MVSNet-main/eval_AACVPMVSNet.py | # Evaluate AACVP-MVSNet
# Modified by: Bing Liu
import os, sys, time, logging, argparse, datetime, re
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
from torch.utils.data import DataLoader
from datasets import dtu_loader
from models import ... | 16,769 | 38.833729 | 120 | py |
AACVP-MVSNet | AACVP-MVSNet-main/utils.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/6/28 0028 11:55
# @Author : Anzhu Yu
# @Site :
# @File : utils.py
# @Software: PyCharm
import numpy as np
import torchvision.utils as vutils
import torch
import torch.nn.functional as F
# print arguments
def print_args(args):
print("########... | 5,284 | 31.623457 | 103 | py |
AACVP-MVSNet | AACVP-MVSNet-main/models/Module.py | # -*- coding: utf-8 -*-
# @Time : 2020/6/18 0018 20:57
# @Author : Anzhu Yu
# @Site :
# @File : module.py
# @Software: PyCharm
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.nn.init as init
def homo_warping(src_feature, ref_in, src_in, ref_ex, src_ex, depth_hypos):
# Ap... | 16,022 | 44.649573 | 133 | py |
AACVP-MVSNet | AACVP-MVSNet-main/models/AACVPMVSNet.py | # -*- coding: utf-8 -*-
# @Time : 2020/6/18 0018 20:57
# @Author : Anzhu Yu
# @Site :
# @File : AACVPMVSNet.py
# @Software: PyCharm
import torch
import torch.nn as nn
import torch.nn.functional as F
from .Module import *
class ConvBnReLU3D(nn.Module):
"""ConvBnReLU3D
3D CNN Blocks with batchnorm a... | 8,747 | 45.042105 | 119 | py |
AACVP-MVSNet | AACVP-MVSNet-main/datasets/utils.py | # Data io utilities for the dataloader
# by: Jiayu Yang
# date: 2019-07-31
# Note: This file use part of the code from the following projects.
# Thanks for the authors for the great code.
# MVSNet: https://github.com/YoYo000/MVSNet
# MVSNet_pytorch: https://github.com/xy-guo/MVSNet_pytorch
import nu... | 4,744 | 28.47205 | 96 | py |
AACVP-MVSNet | AACVP-MVSNet-main/datasets/dtu_loader.py | # Dataloader for the DTU dataset in Yaoyao's format.
# by: Jiayu Yang
# date: 2020-01-28
# Note: This file use part of the code from the following projects.
# Thanks for the authors for the great code.
# MVSNet: https://github.com/YoYo000/MVSNet
# MVSNet_pytorch: https://github.com/xy-guo/MVSNet_pyto... | 6,228 | 38.176101 | 145 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train_feature_extractor.py | import time
import sys
from data_loader.h36m_loader import Human36M
[sys.path.append(i) for i in ['.', '..']]
from torch import optim
import torch.nn.functional as F
import matplotlib
from model.embedding_net import EmbeddingNet
from train_eval.train_joint_embed import eval_embed
from utils.average_meter import Ave... | 8,374 | 34.189076 | 120 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/synthesize.py | import datetime
import logging
import math
import os
import pickle
import random
import sys
import librosa
import soundfile as sf
import lmdb
import numpy as np
import time
import pyarrow
import torch
from torch.utils.data import DataLoader
import utils
from data_loader.lmdb_data_loader import SpeechMotionDataset, d... | 18,129 | 40.0181 | 133 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train.py | import pprint
import time
from pathlib import Path
import sys
[sys.path.append(i) for i in ['.', '..']]
import matplotlib
import torch.nn.functional as F
from torch.utils.tensorboard import SummaryWriter
from model import speech2gesture, vocab
from model.embedding_net import EmbeddingNet
from model.seq2seq_net impor... | 23,232 | 45.005941 | 120 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/data_loader/h36m_loader.py | import math
import random
import torch
import numpy as np
from torch.utils.data import Dataset
from utils.data_utils import convert_pose_seq_to_dir_vec, convert_dir_vec_to_pose
train_subject = ['S1', 'S5', 'S6', 'S7', 'S8', 'S9', 'S11']
test_subject = ['S11']
class Human36M(Dataset):
def __init__(self, path, m... | 3,853 | 34.685185 | 134 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/data_loader/lmdb_data_loader.py | import datetime
import logging
import os
import pickle
import random
import numpy as np
import lmdb as lmdb
import torch
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import Dataset, DataLoader
from torch.utils.data.dataloader import default_collate
import utils.train_utils
import utils.data_util... | 8,022 | 39.933673 | 109 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train_eval/train_speech2gesture.py | import torch
import torch.nn.functional as F
def train_iter_speech2gesture(args, in_spec, target_poses, pose_decoder, discriminator,
pose_dec_optim, dis_optim, loss_fn):
# generation
pre_poses = target_poses[:, 0:args.n_pre_poses]
out_poses = pose_decoder(in_spec, pre_poses)
... | 1,430 | 36.657895 | 114 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train_eval/train_joint_embed.py | import torch
import torch.nn.functional as F
def train_iter_embed(args, epoch, in_text, in_audio, target_data, net, optim, mode=None):
pre_seq = target_data[:, 0:args.n_pre_poses]
# zero gradients
optim.zero_grad()
if mode == 'random': # joint embed model
variational_encoding = False # AE
... | 2,191 | 33.793651 | 101 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train_eval/train_gan.py | import random
import numpy as np
import torch
import torch.nn.functional as F
def add_noise(data):
noise = torch.randn_like(data) * 0.1
return data + noise
def train_iter_gan(args, epoch, in_text, in_audio, target_poses, vid_indices,
pose_decoder, discriminator,
pose_d... | 4,074 | 37.809524 | 121 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/train_eval/train_seq2seq.py | import logging
import torch
import torch.nn.functional as F
loss_i = 0
def custom_loss(output, target, args, epoch):
n_element = output.numel()
# mae
mse_loss = F.mse_loss(output, target)
mse_loss *= args.loss_regression_weight
# continuous motion
diff = [abs(output[:, n, :] - output[:, n-1, ... | 1,354 | 25.057692 | 88 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/utils/data_utils.py | import re
import librosa
import numpy as np
import torch
from scipy.interpolate import interp1d
from sklearn.preprocessing import normalize
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
skeleton_line_pairs = [(0, 1, 'b'), (1, 2, 'darkred'), (2, 3, 'r'), (3, 4, 'orange'), (1, 5, 'darkgreen'... | 4,295 | 34.504132 | 106 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/utils/train_utils.py | import logging
import os
import pickle
import random
import subprocess
from collections import defaultdict, namedtuple
from logging.handlers import RotatingFileHandler
from textwrap import wrap
import numpy as np
import re
import time
import math
import soundfile as sf
import librosa.display
import matplotlib
import ... | 6,259 | 31.604167 | 112 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/seq2seq_net.py | import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
import math
'''
Based on the following Se2Seq implementations:
- https://github.com/AuCson/PyTorch-Batch-Attention-Seq2seq
- https://github.com/spro/practical-pytorch/blob/master/seq2seq-translation/seq2seq-translati... | 10,719 | 41.039216 | 117 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/embedding_space_evaluator.py | import time
import numpy as np
import torch
import torch.nn.functional as F
import umap
from scipy import linalg
from model.embedding_net import EmbeddingNet
import warnings
warnings.filterwarnings("ignore", category=RuntimeWarning) # ignore warnings
class EmbeddingSpaceEvaluator:
def __init__(self, args, emb... | 6,387 | 39.687898 | 117 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/embedding_net.py | import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from model.multimodal_context_net import WavEncoder, TextEncoderTCN
def reparameterize(mu, logvar):
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
return mu + eps * std
def ConvNormRelu(in_channels, out_channel... | 10,527 | 30.806647 | 113 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/multimodal_context_net.py | import torch
import torch.nn as nn
from model import vocab
import model.embedding_net
from model.tcn import TemporalConvNet
class WavEncoder(nn.Module):
def __init__(self):
super().__init__()
self.feat_extractor = nn.Sequential(
nn.Conv1d(1, 16, 15, stride=5, padding=1600),
... | 9,831 | 37.86166 | 113 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/speech2gesture.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
""" reimplement speech2gesture model(https://github.com/amirbar/speech2gesture) with pytorch """
class Conv2d_tf(nn.Conv2d):
"""
Conv2d with the padding behavior from TF
from https://github.com/mlperf/inference/blob/482... | 8,841 | 32.116105 | 159 | py |
Gesture-Generation-from-Trimodal-Context | Gesture-Generation-from-Trimodal-Context-master/scripts/model/tcn.py | """ from https://github.com/locuslab/TCN/blob/master/TCN/tcn.py """
import torch
import torch.nn as nn
from torch.nn.utils import weight_norm
class Chomp1d(nn.Module):
def __init__(self, chomp_size):
super(Chomp1d, self).__init__()
self.chomp_size = chomp_size
def forward(self, x):
re... | 2,536 | 38.030769 | 110 | py |
neuralqa | neuralqa-master/setup.py | import os
from importlib.machinery import SourceFileLoader
from setuptools import setup, find_packages
version = SourceFileLoader('neuralqa.version', os.path.join(
'neuralqa', 'version.py')).load_module().VERSION
def package_files(directory):
paths = []
for (path, _, filenames) in os.walk(directory):
... | 1,762 | 27.435484 | 83 | py |
DeepAligned-Clustering | DeepAligned-Clustering-main/pretrain.py | from util import *
from model import *
from dataloader import *
class PretrainModelManager:
def __init__(self, args, data):
set_seed(args.seed)
self.model = BertForModel.from_pretrained(args.bert_model, cache_dir = "", num_labels = data.n_known_cls)
if args.freeze_bert_parameters:
... | 4,907 | 40.59322 | 129 | py |
DeepAligned-Clustering | DeepAligned-Clustering-main/DeepAligned.py | from model import *
from init_parameter import *
from dataloader import *
from pretrain import *
from util import *
class ModelManager:
def __init__(self, args, data, pretrained_model=None):
if pretrained_model is None:
pretrained_model = BertForModel.from_pretrained(args.bert_mod... | 10,443 | 36.3 | 136 | py |
DeepAligned-Clustering | DeepAligned-Clustering-main/dataloader.py | from util import *
def set_seed(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
class Data:
def __init__(self, args):
set_seed(args.seed)
max_seq_lengths = {'clinc':30, 'stackoverflow':45,'banking':55}
args.max_seq_length = max_seq_lengths[args.da... | 13,724 | 44.598007 | 175 | py |
DeepAligned-Clustering | DeepAligned-Clustering-main/util.py | import itertools
import subprocess
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import copy
import torch.nn.functional as F
import random
import csv
import sys
from torch import nn
from tqdm import tqdm_notebook, trange, tqdm
from pytorch_pretrained_bert.optimization imp... | 1,544 | 31.87234 | 110 | py |
lm-intervention | lm-intervention-master/experiment_num_agreement.py |
import torch
# import torch.nn as nn
import torch.nn.functional as F
import numpy as np
# import random
from functools import partial
from tqdm import tqdm
# from tqdm import tqdm_notebook
import math
import statistics
from utils_num_agreement import batch, convert_results_to_pd
from transformers import (
GPT2LMH... | 37,950 | 44.724096 | 129 | py |
lm-intervention | lm-intervention-master/attention_utils.py | import torch
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
from tqdm import tqdm
import pandas as pd
import numpy as np
from scipy.stats import ttest_ind
def perform_intervention(intervention, model, effect_types=('indirect', 'direct')):
"""Perform intervention and return results for specified ... | 9,550 | 44.265403 | 142 | py |
lm-intervention | lm-intervention-master/attention_figures3.py | """Creates figures showing attention for specific examples, based on JSON files"""
import json
import math
from operator import itemgetter
import numpy as np
import seaborn as sns
import torch
from matplotlib import pyplot as plt
from transformers import GPT2Model, GPT2Tokenizer
BLACK = '#000000'
GRAY = '#303030'
d... | 8,088 | 38.847291 | 128 | py |
lm-intervention | lm-intervention-master/attention_intervention_model.py |
"""
Changes the huggingface transformer attention module to allow interventions
in the attention distribution.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class AttentionOverride(nn.Module):
"""A copy of `modeling_gpt2.Attention` class, but with overridden attention values"... | 29,231 | 39.998597 | 127 | py |
lm-intervention | lm-intervention-master/transformers_modified/modeling_transfo_xl.py | """ A copy of transformers/modeling_transfo_xl.py from the Huggingface
transformers library modified so that the attention module is called with
non-keyword arguments (to make those arguments accessible to the hook).
"""
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Auth... | 40,378 | 42.795011 | 151 | py |
lm-intervention | lm-intervention-master/transformers_modified/modeling_xlnet.py | """ A copy of transformers/modeling_xlnet.py from the Huggingface
transformers library modified so that the attention module is called with
non-keyword arguments (to make those arguments accessible to the hook).
"""
# coding=utf-8
# Copyright 2018 Google AI, Google Brain and Carnegie Mellon University Authors a... | 79,781 | 47.946012 | 304 | py |
FPI | FPI-master/self_sup_task.py | import numpy as np
import tensorflow as tf
to_categorical = tf.keras.utils.to_categorical
'''
def to_categorical(y,num_classes):
onehot = np.zeros((len(y), num_classes))
onehot[np.arange(len(y)),y] = 1
return onehot
'''
def create_interp_mask(ima,patch_center,patch_width,patch_interp):
dims=np.shape(i... | 2,950 | 34.987805 | 119 | py |
FPI | FPI-master/fpiSubmit.py | import numpy as np
import itertools
import copy
from datetime import datetime
import os
import pickle
from sklearn.metrics import average_precision_score
import tensorflow as tf
import readData
import self_sup_task
from models.wide_residual_network import create_wide_residual_network_selfsup
from scipy.signal import ... | 9,435 | 34.078067 | 122 | py |
FPI | FPI-master/var_ops.py | """
Tools for manipulating sets of variables.
"""
import numpy as np
from keras import backend as K
import tensorflow as tf
import copy
def interpolate_vars(old_vars, new_vars, epsilon):
"""
Interpolate between two sequences of variables.
"""
return add_vars(old_vars, scale_vars(subtract_vars(new_vars... | 1,366 | 23.410714 | 143 | py |
FPI | FPI-master/models/wide_residual_network.py | #using code from https://github.com/asmith26/wide_resnets_keras.git
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from six.moves import range
import os
import logging
logging.basicConfig(level=logging.DEBUG)
import sys
#sys.stdout = sys.stderr
# Prevent ... | 12,583 | 43.624113 | 164 | py |
Age-and-Gender-Recognition | Age-and-Gender-Recognition-main/Age and Gender Recognition using Caffe Model - Youtube.py | #!/usr/bin/env python
# coding: utf-8
# In[1]:
import cv2
import os
os.chdir('D:\Python37\Projects\Gender-and-Age-Detection- Youtube\Gender-and-Age-Detection\models')
# In[33]:
def detectFace(net,frame,confidence_threshold=0.7):
frameOpencvDNN=frame.copy()
print(frameOpencvDNN.shape)
frameHeight=fram... | 2,680 | 29.123596 | 154 | py |
linbp-attack | linbp-attack-master/attack/imagenet/test.py | import os, sys
import torch
import models as MODEL
import torchvision.transforms as T
import torchvision
import argparse
from torch.backends import cudnn
import numpy as np
import torch.nn.functional as F
parser = argparse.ArgumentParser(description='test')
parser.add_argument('--dir', type=str, default='')
args = par... | 4,941 | 35.880597 | 146 | py |
linbp-attack | linbp-attack-master/attack/imagenet/utils.py | import torch
import torch.nn.functional as F
import torch.nn as nn
import torchvision
import numpy as np
from torch.utils.data import Dataset
import csv
import PIL.Image as Image
import os
import torchvision.transforms as T
import pickle
# Selected imagenet. The .csv file format:
# class_index, class, image_name
# 0... | 7,806 | 36 | 142 | py |
linbp-attack | linbp-attack-master/attack/imagenet/attack_resnet50.py | import os, sys
import torch
import torchvision.transforms as T
import torch.nn as nn
import argparse
import torch.nn.functional as F
import torchvision
import models as MODEL
from torch.backends import cudnn
import numpy as np
from utils import SelectedImagenet, Normalize, input_diversity, \
linbp_forw_resnet50, li... | 6,574 | 40.878981 | 132 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.