python_code stringlengths 0 4.04M | repo_name stringlengths 7 58 | file_path stringlengths 5 147 |
|---|---|---|
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
sys.path.insert(1, project_root + '/fairseq')
sys.path.insert(2, project_root + '/fairseq/scripts')
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH']... | butterfly-master | transformer/dynamic_conv_experiment.py |
import math
import unittest
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
import torch_butterfly
class ButterflyTest(unittest.TestCase):
def setUp(self):
self.rtol = 1e-3
self.atol = 1e-5
def test_multiply(self):
for batch_size, n in [(1... | butterfly-master | tests/test_multiply.py |
import copy
import itertools
import unittest
import torch
import torch_butterfly
class ButterflyCombineTest(unittest.TestCase):
def setUp(self):
self.rtol = 1e-3
self.atol = 1e-5
def test_diagonal_butterfly(self):
batch_size = 10
for in_size, out_size in [(9, 15), (15, 9)]:... | butterfly-master | tests/test_combine.py |
import math
import unittest
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
import torch_butterfly
class ButterflyBase4Test(unittest.TestCase):
def setUp(self):
self.rtol = 1e-3
self.atol = 1e-5
def test_butterfly_imul(self):
batch_size = ... | butterfly-master | tests/test_butterfly_base4.py |
import copy
import itertools
import unittest
import torch
import torch_butterfly
from torch_butterfly.complex_utils import complex_matmul, index_last_dim
class ButterflyComplexUtilsTest(unittest.TestCase):
def setUp(self):
self.rtol = 1e-3
self.atol = 1e-5
def test_complex_matmul(self):
... | butterfly-master | tests/test_complex_utils.py |
import math
import unittest
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
from torch_butterfly.multiply import butterfly_multiply_torch
from torch_butterfly.multiply_base4 import butterfly_multiply_base4_torch
from torch_butterfly.multiply_base4 import twiddle_base2_to_bas... | butterfly-master | tests/test_multiply_base4.py |
import math
import unittest
import numpy as np
import torch
from torch import nn
from torch.nn import functional as F
import torch.fft
import torch_butterfly
from torch_butterfly import Butterfly
from torch_butterfly.complex_utils import complex_matmul
from torch_butterfly.combine import TensorProduct
from torch_but... | butterfly-master | tests/test_butterfly.py |
import math
import unittest
import numpy as np
from scipy import linalg as la
import scipy.fft
import torch
from torch import nn
from torch.nn import functional as F
import torch.fft
import pywt # To test wavelet
import torch_butterfly
class ButterflySpecialTest(unittest.TestCase):
def setUp(self):
... | butterfly-master | tests/test_special.py |
import copy
import itertools
import math
import unittest
import numpy as np
import torch
import torch_butterfly
from torch_butterfly.permutation import perm_vec_to_mat, invert, matrix_to_butterfly_factor
class ButterflyPermutationTest(unittest.TestCase):
def setUp(self):
self.rtol = 1e-3
self.... | butterfly-master | tests/test_permutation.py |
import os, sys, subprocess
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import math
from pathlib impor... | butterfly-master | learning_transforms/learning_transforms.py |
import math
import operator
import functools
import torch
from torch import nn
from complex_utils import complex_mul, complex_matmul
from ops import polymatmul, ops_transpose_mult_br
from sparsemax import sparsemax
from utils import bitreversal_permutation
class HstackDiag(nn.Module):
"""Horizontally stacked di... | butterfly-master | learning_transforms/hstack_diag.py |
import numpy as np
import torch
from target_matrix import named_target_matrix
def baseline_rmse(name, size, param_fn):
# dft = named_target_matrix('dft', 512)
# dft = dft.view('complex128').squeeze(-1)
# n, m = size, int(np.log(size)/np.log(2))
n = size
params = int(param_fn(n))
# sparsity = 2... | butterfly-master | learning_transforms/baselines.py |
import pickle
import numpy as np
import matplotlib.pyplot as plt
plt.switch_backend('agg')
from matplotlib.colors import LinearSegmentedColormap
with open('rmse.pkl', 'rb') as f:
data = pickle.load(f)
transform_names = data['names']
our_rmse = np.array(data['rmse'])
our_rmse = np.delete(our_rmse, -2, axis=0)
wit... | butterfly-master | learning_transforms/heatmap.py |
import math
import operator
import functools
import torch
from torch import nn
from butterfly.complex_utils import real_to_complex, complex_mul, complex_matmul
from factor_multiply import permutation_factor_even_odd_multiply, permutation_factor_even_odd_multiply_backward
from factor_multiply import permutation_facto... | butterfly-master | learning_transforms/permutation_factor.py |
import pickle
import numpy as np
import matplotlib.pyplot as plt
plt.switch_backend('agg')
import matplotlib.patches as mpatches
plt.rcParams['font.family'] = 'serif'
rs = [1]
markers = ['o', 'v', 'D', 'p', 's', '>']
loc = 'speed_data.pkl'
data = pickle.load(open(loc,'rb'))
colors = ['red', 'orange', 'green', 'blue']... | butterfly-master | learning_transforms/speed_plot.py |
import itertools
import multiprocessing as mp
import os
import numpy as np
import cvxpy as cp
os.environ['MKL_NUM_THREADS'] = '1'
os.environ['OMP_NUM_THREADS'] = '1'
os.environ['NUMEXPR_NUM_THREADS'] = '1'
os.environ['VECLIB_MAXIMUM_THREADS'] = '1'
from target_matrix import named_target_matrix
ntrials = 1
# sizes... | butterfly-master | learning_transforms/robust_pca.py |
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
from scipy.linalg import circulant
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackObser... | butterfly-master | learning_transforms/learning_circulant.py |
import math
import torch
from torch import nn
from butterfly.complex_utils import real_to_complex, complex_mul, complex_matmul
from factor_multiply import butterfly_factor_multiply, butterfly_factor_multiply_backward
from factor_multiply import butterfly_multiply_intermediate, butterfly_multiply_intermediate_backwar... | butterfly-master | learning_transforms/butterfly_factor.py |
"""Compute the exact Fisher information matrix of a butterfly matrix.
For an n x n butterfly matrix, this has space complexity O(n^2 log^2 n), which is optimal, and
time complexity O(n^3 log^2 n).
The space is the bottleneck anyway.
"""
import math
from functools import partial
import numpy as np
import torch
import t... | butterfly-master | learning_transforms/fisher.py |
import torch
from torch import nn
# def semantic_loss_exactly_one(prob, dim=-1):
# """Semantic loss to encourage the multinomial probability to be "peaked",
# i.e. only one class is picked.
# The loss has the form -log sum_{i=1}^n p_i prod_{j=1, j!=i}^n (1 - p_j).
# Paper: http://web.cs.ucla.edu/~guyv... | butterfly-master | learning_transforms/semantic_loss.py |
# encoding: utf8
"""
From Softmax to Sparsemax: A Sparse Model of Attention and Multi-Label
Classification. André F. T. Martins, Ramón Fernandez Astudillo
In: Proc. of ICML 2016, https://arxiv.org/abs/1602.02068
Code adapted from https://github.com/vene/sparse-structured-attention
and https://github.com/KrisKorrel/sp... | butterfly-master | learning_transforms/sparsemax.py |
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
from numpy.polynomial import legendre
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackOb... | butterfly-master | learning_transforms/learning_legendre.py |
import torch
from torch import nn
from torch import optim
from butterfly_factor import butterfly_factor_mult
from permutation_factor import permutation_factor_even_odd_mult, permutation_factor_reverse_mult
from butterfly import Block2x2Diag, Block2x2DiagProduct, BlockPermProduct, Block2x2DiagProductBmm
def profile_b... | butterfly-master | learning_transforms/profile.py |
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackObserver
import ray
from ray.tune impor... | butterfly-master | learning_transforms/learning_vandermonde.py |
import os
from timeit import default_timer as timer
import numpy as np
from scipy.fftpack import fft, dct, dst
import torch
from torch import nn
import matplotlib.pyplot as plt
plt.switch_backend('agg')
from butterfly import Block2x2DiagProduct, BlockPermProduct
from inference import Block2x2DiagProduct_to_ABCDs, BP... | butterfly-master | learning_transforms/speed_test.py |
import numpy as np
n = 4
# x = np.random.randn(n)
x = np.arange(2, n+2)
V = np.vander(x, increasing=True)
D = np.diag(x)
D_inv = np.diag(1 / x)
Z0 = np.diag(np.ones(n-1), -1)
G = np.array(x ** n)[:, None]
H = np.array([0, 0, 0, 1])[:, None]
assert np.allclose(D @ V - V @ Z0 - G @ H.T, 0)
G = np.array(x ** (n-1))[:, No... | butterfly-master | learning_transforms/vandermonde.py |
butterfly-master | learning_transforms/__init__.py | |
"""Target matrices to factor: DFT, DCT, Hadamard, convolution, Legendre, Vandermonde.
Complex complex must be converted to real matrices with 2 as the last dimension
(for Pytorch's compatibility).
"""
import math
import numpy as np
from numpy.polynomial import legendre
import scipy.linalg as LA
from scipy.fftpack imp... | butterfly-master | learning_transforms/target_matrix.py |
import numpy as np
import torch
from torch.nn import functional as F
from numpy.polynomial import chebyshev, legendre
from utils import bitreversal_permutation
def polymatmul(A, B):
"""Batch-multiply two matrices of polynomials
Parameters:
A: (N, batch_size, n, m, d1)
B: (batch_size, m, p, d... | butterfly-master | learning_transforms/ops.py |
from distutils.core import setup
from distutils.extension import Extension
from Cython.Build import cythonize
import numpy
extensions = [
Extension('ABCD_mult', ['ABCD_mult.pyx'],
include_dirs = [numpy.get_include()],
extra_compile_args=['-O3', '-march=native']
),
]
setup(
ext_modules ... | butterfly-master | learning_transforms/setup.py |
# Copied from https://github.com/ray-project/ray/blob/master/python/ray/tune/tune.py.
# We adapt to stop early if any of the trials get good validation loss, since
# all we care about is that there exists a good factorization
from __future__ import absolute_import
from __future__ import division
from __future__ impor... | butterfly-master | learning_transforms/tune.py |
import pickle
from pathlib import Path
import numpy as np
result_dir = 'results_new'
experiment_names = []
experiment_names += [[f'dft_factorization_TrainableBP_True_{size}' for size in [8, 16, 32, 64, 128, 256, 512, 1024]]]
experiment_names += [[f'dct_factorization_TrainableBPP_True_{size}' for size in [8, 16, 32, 64... | butterfly-master | learning_transforms/print_results.py |
import argparse
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackObserver
import ray
fro... | butterfly-master | learning_transforms/learning_fft.py |
import os
import time
import numpy as np
import torch
from torch import nn
from butterfly_factor import butterfly_factor_mult_intermediate
# from butterfly import Block2x2DiagProduct
# from test_factor_multiply import twiddle_list_concat
exps = np.arange(6, 14)
sizes = 1 << exps
batch_size = 256
ntrials = [100000... | butterfly-master | learning_transforms/speed_test_training.py |
"""Convert BP model from Pytorch to Numpy for inference.
To compile Cython extension: python setup.py build_ext --inplace
"""
import numpy as np
import torch
from torch import nn
from timeit import default_timer as timer
from butterfly import Block2x2DiagProduct
from ABCD_mult import ABCD_mult, ABCD_mult_inplace, A... | butterfly-master | learning_transforms/inference.py |
import pickle
from pathlib import Path
import numpy as np
result_dir = 'results'
experiment_names = []
experiment_names += [[f'Hadamard_factorization_True_softmax_{size}' for size in [8, 16, 32, 64, 128, 256]]]
experiment_names += [[f'Hadamard_factorization_False_softmax_{size}' for size in [8, 16, 32, 64, 128, 256]]]... | butterfly-master | learning_transforms/fft_hadamard_analysis.py |
import math
import operator
import functools
import torch
from torch import nn
from butterfly.complex_utils import real_to_complex, complex_mul, complex_matmul
from sparsemax import sparsemax
from butterfly.utils import bitreversal_permutation
from butterfly_factor import butterfly_factor_mult, butterfly_factor_mult_... | butterfly-master | learning_transforms/butterfly_old.py |
import unittest
import torch
from butterfly_factor import butterfly_factor_mult, butterfly_factor_mult_intermediate
from butterfly import Block2x2DiagProduct
from complex_utils import complex_mul
from factor_multiply import butterfly_multiply_intermediate, butterfly_multiply_intermediate_backward
def twiddle_list_... | butterfly-master | learning_transforms/test_factor_multiply.py |
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import numpy as np
from scipy.linalg import hadamard
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackObserver
import ... | butterfly-master | learning_transforms/learning_hadamard.py |
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
from numpy.polynomial import legendre
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackOb... | butterfly-master | learning_transforms/learning_ops.py |
import os
import pickle
from pathlib import Path
import numpy as np
import multiprocessing as mp
import torch
from torch import nn
from torch import optim
import ray
from butterfly import ButterflyProduct
from learning_hadamard import TrainableHadamardFactorFixedOrder, TrainableHadamardFactorSoftmax, TrainableHadam... | butterfly-master | learning_transforms/polish.py |
import copy
import os
import torch
from torch import nn
from torch import optim
from ray.tune import Trainable
N_LBFGS_STEPS_VALIDATION = 15
class PytorchTrainable(Trainable):
"""Abstract Trainable class for Pytorch models, which checkpoints the model
and the optimizer.
Subclass must initialize self.m... | butterfly-master | learning_transforms/training.py |
import pickle
import numpy as np
import matplotlib.pyplot as plt
plt.switch_backend('agg')
import matplotlib.patches as mpatches
plt.rcParams['font.family'] = 'serif'
rs = [1]
markers = ['o', 'v', 'D', 'p', 's', '>']
loc = 'speed_training_data.pkl'
data = pickle.load(open(loc,'rb'))
colors = ['red', 'orange', 'green'... | butterfly-master | learning_transforms/speed_training_plot.py |
import argparse
import math
import multiprocessing as mp
import os
from pathlib import Path
import pickle
import random
import sys
import numpy as np
import torch
from torch import nn
from torch import optim
from sacred import Experiment
from sacred.observers import FileStorageObserver, SlackObserver
import ray
fro... | butterfly-master | learning_transforms/old/learning_fft_old.py |
import models
name_to_model = {
'LeNet': lambda args: models.LeNet(**args),
'AlexNet': lambda args: models.AlexNet(**args),
'MLP': lambda args: models.MLP(**args),
'ResNet18': lambda args: models.ResNet18(**args),
'PResNet18': lambda args: models.PResNet18(**args),
'Permutation': lambda args: ... | butterfly-master | cnn/model_utils.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
import torch
from cnn.models.butterfly_conv import ButterflyConv2d
from butterfly.butterfly import ButterflyBmm
from butterfly.butterfly_multiply import butterfly_conv2d
import time
nsteps = 100... | butterfly-master | cnn/benchmark_cnn.py |
import pickle
import json
from pathlib import Path
import numpy as np
# butterfly_acc = [56.4, 65.0, 70.1, 71.2]
# butterfly_param = [0.70, 1.54, 3.62, 4.04]
# Butterfly w/ channel pooling
butterfly_smpool_acc = [54.027, 62.840, 68.418]
butterfly_smpool_param = np.array([439688, 1024808, 2597480]) / 1e6
# Butterfly w... | butterfly-master | cnn/imagenet_analysis.py |
import io
import argparse, shutil, time, warnings
import subprocess
from pathlib import Path
from datetime import datetime
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
import torch.optim
import torch.utils.data
import torchvision.transforms as transforms
import torchvision.... | butterfly-master | cnn/teacher_covariance.py |
import torch
from collections import OrderedDict
def strip_prefix_if_present(state_dict, prefix):
keys = sorted(state_dict.keys())
if not all(key.startswith(prefix) for key in keys):
return state_dict
stripped_state_dict = OrderedDict()
for key, value in state_dict.items():
stripped_sta... | butterfly-master | cnn/train_utils.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import io
import argparse, shutil, time, w... | butterfly-master | cnn/teacher.py |
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os, sys
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
from torch import nn
from torch import optim
import torch.nn.functional as F
project_root = os.path.dirname(os.path... | butterfly-master | cnn/profile_perm.py |
import argparse
import os
import shutil
import time
import random
import numpy as np
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
import torch.utils.data
import torch.utils.data.d... | butterfly-master | cnn/imagenet_main.py |
import pickle
import json
from pathlib import Path
import numpy as np
butterfly_bleu = [32.99, 33.8, 34.32, 34.3, 34.23, 34.1]
lr_bleu = [30.05, 32.71, 33.6, 33.08, 34.15, 34.3]
sparse_bleu = [34.08, 34.31, 34.39, 34.49, 34.586667, 34.3]
param_fraction = np.array([9, 18, 36, 72, 108, 128]) / 128
import matplotlib.pyp... | butterfly-master | cnn/transformer_analysis.py |
import argparse
import os
import shutil
import time
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
import torchvi... | butterfly-master | cnn/imagenet_amp.py |
'''MobileNet in PyTorch.
See the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications"
for more details.
'''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sy... | butterfly-master | cnn/mobilenet_imagenet.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
def get_dataset(config_dataset):
if config_dataset['name'] == 'CIFAR10':
normalize = transforms.Normalize(
m... | butterfly-master | cnn/dataset_utils.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import math
from pathlib import Path
impor... | butterfly-master | cnn/distill_cov_experiment.py |
'''ShuffleNet in PyTorch.
See the paper "ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices" for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
s... | butterfly-master | cnn/shufflenet_imagenet.py |
# https://github.com/fastai/imagenet-fast/blob/master/imagenet_nv/distributed.py
import torch
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
import torch.distributed as dist
from torch.nn.modules import Module
'''
This version of DistributedDataParallel is designed to be used in conjunctio... | butterfly-master | cnn/distributed.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import argparse
import torchvision.models ... | butterfly-master | cnn/imagenet_model_surgery.py |
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os, sys
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add t... | butterfly-master | cnn/visualize_perm.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import argparse, shutil, time, warnings
im... | butterfly-master | cnn/imagenet_experiment.py |
import os, sys, subprocess
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import math
from pathlib impor... | butterfly-master | cnn/cifar_experiment.py |
import argparse
import os
import shutil
import time
import random
import numpy as np
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import torch.optim
import torch.utils.data
import torch.utils.data.d... | butterfly-master | cnn/imagenet_finetune.py |
import os, sys
# project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
import numpy as np
import torch
# import torchvision
def listperm2matperm(listperm):
"""Converts permutation list to matrix form.
Args:
listperm: (..., n) - tensor of list permutations of the set [n].
Return... | butterfly-master | cnn/permutation_utils.py |
# modified from https://github.com/fastai/imagenet-fast/blob/master/imagenet_nv/multiproc.py
import argparse
import torch
import sys
import subprocess
from pathlib import Path
import random
argslist = list(sys.argv)[1:]
world_size = torch.cuda.device_count()
if '--world-size' in argslist:
argslist[argslist.index... | butterfly-master | cnn/multiproc.py |
import os, sys, subprocess
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import math
from pathlib impor... | butterfly-master | cnn/permuted_experiment.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
import math
import numpy as np
def bitreversal_permutation(n):
"""Return the bit reversal permutation used in FFT.
Parameter... | butterfly-master | cnn/pdataset_utils.py |
import os, sys
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
# Add to $PYTHONPATH in addition to sys.path so that ray workers can see
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
import math
from pathlib import Path
impor... | butterfly-master | cnn/distill_experiment.py |
'''ShuffleNetV2 in PyTorch.
See the paper "ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design" for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class ShuffleBlock(nn.Module):
def __init__(self, groups=2):
super(ShuffleBlock, self).__init__()
... | butterfly-master | cnn/models/shufflenetv2.py |
import torch
from torch import nn
import torch.nn.functional as F
from butterfly import Butterfly
from butterfly.butterfly import ButterflyBmm
from butterfly.butterfly_multiply import butterfly_mult_conv2d, butterfly_mult_conv2d_svd, bbt_mult_conv2d
import math
class Butterfly1x1Conv(Butterfly):
"""Product of lo... | butterfly-master | cnn/models/butterfly_conv.py |
'''
Properly implemented ResNetOriginal-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 web is copy-paste from
torchvision's resnet a... | butterfly-master | cnn/models/resnet_original.py |
'''GoogLeNet with PyTorch.'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Inception(nn.Module):
def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
super(Inception, self).__init__()
# 1x1 conv branch
self.b1 = nn.Sequential(
... | butterfly-master | cnn/models/googlenet.py |
'''VGG11/13/16/19 in Pytorch.'''
import torch
import torch.nn as nn
cfg = {
'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512... | butterfly-master | cnn/models/vgg.py |
import torch
import torch.nn as nn
import torch.nn.init as init
import torch.utils.model_zoo as model_zoo
__all__ = ['SqueezeNet', 'squeezenet1_0', 'squeezenet1_1']
model_urls = {
'squeezenet1_0': 'https://download.pytorch.org/models/squeezenet1_0-a815701f.pth',
'squeezenet1_1': 'https://download.pytorch.or... | butterfly-master | cnn/models/squeezenet.py |
'''SENet in PyTorch.
SENet is the winner of ImageNet-2017. The paper is not released yet.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class BasicBlock(nn.Module):
def __init__(self, in_planes, planes, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(... | butterfly-master | cnn/models/senet.py |
import math
import torch
from torch import nn
import torch.nn.functional as F
class LowRankConv2d(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, bias=True, rank=1):
super().__init__()
self.in_channels = in_channels
self.out_channel... | butterfly-master | cnn/models/low_rank_conv.py |
'''DenseNet in PyTorch.'''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
class Bottleneck(nn.Module):
def __init__(self, in_planes, growth_rate):
super(Bottleneck, self).__init__()
self.bn1 = nn.BatchNorm2d(in_planes)
self.conv1 = nn.Conv2d(in_planes, 4*gr... | butterfly-master | cnn/models/densenet.py |
from .vgg import *
from .dpn import *
from .lenet import *
from .senet import *
from .pnasnet import *
from .densenet import *
from .googlenet import *
from .shufflenet import *
from .shufflenetv2 import *
from .resnet import *
from .resnet_original import *
from .resnext import *
from .preact_resnet import *
from .mob... | butterfly-master | cnn/models/__init__.py |
import math
import torch
from torch import nn
from butterfly.complex_utils import complex_mul
class CirculantLinear(nn.Module):
def __init__(self, size, nstack=1):
super().__init__()
self.size = size
self.nstack = nstack
init_stddev = math.sqrt(1. / self.size)
c = torch.r... | butterfly-master | cnn/models/circulant1x1conv.py |
'''ResNeXt in PyTorch.
See the paper "Aggregated Residual Transformations for Deep Neural Networks" for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
'''Grouped convolution block.'''
expansion = 2
def __init__(self, in_planes, cardinality=32... | butterfly-master | cnn/models/resnext.py |
'''LeNet in PyTorch.'''
import sys, os, subprocess
import torch
import torch.nn as nn
import torch.nn.functional as F
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.get('PYTHONPATH', '')
from butterf... | butterfly-master | cnn/models/lenet.py |
'''MobileNet in PyTorch.
See the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications"
for more details.
'''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from .butterfly_conv import Butterfly1x1Conv, ButterflyConv2d
from .circulant1x1conv import ... | butterfly-master | cnn/models/mobilenet.py |
'''PNASNet in PyTorch.
Paper: Progressive Neural Architecture Search
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class SepConv(nn.Module):
'''Separable Convolution.'''
def __init__(self, in_planes, out_planes, kernel_size, stride):
super(SepConv, self).__init__()
se... | butterfly-master | cnn/models/pnasnet.py |
'''ShuffleNet in PyTorch.
See the paper "ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices" for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class ShuffleBlock(nn.Module):
def __init__(self, groups):
super(ShuffleBlock, self).__init... | butterfly-master | cnn/models/shufflenet.py |
'''ResNet in PyTorch.
For Pre-activation ResNet, see 'preact_resnet.py'.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385
'''
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from cnn.models.butterfly_co... | butterfly-master | cnn/models/resnet.py |
'''Pre-activation ResNet in PyTorch.
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Identity Mappings in Deep Residual Networks. arXiv:1603.05027
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class PreActBlock(nn.Module):
'''Pre-activation version of the BasicBlock.... | butterfly-master | cnn/models/preact_resnet.py |
'''MobileNetV2 in PyTorch.
See the paper "Inverted Residuals and Linear Bottlenecks:
Mobile Networks for Classification, Detection and Segmentation" for more details.
'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Block(nn.Module):
'''expand + depthwise + pointwise'''
def __init... | butterfly-master | cnn/models/mobilenetv2.py |
import math
import numpy as np
import torch
from torch import nn
from butterfly.complex_utils import complex_mul, conjugate
def toeplitz_krylov_transpose_multiply(v, u, f=0.0):
"""Multiply Krylov(Z_f, v_i)^T @ u.
Parameters:
v: (nstack, rank, n)
u: (batch_size, n)
f: real number
R... | butterfly-master | cnn/models/toeplitzlike1x1conv.py |
import torch
import torch.nn as nn
import torch.nn.init as init
import torch.nn.functional as F
from torch.autograd import Variable
import sys
import numpy as np
from cnn.models.butterfly_conv import ButterflyConv2d
from cnn.models.low_rank_conv import LowRankConv2d
def conv3x3(in_planes, out_planes, stride=1):
... | butterfly-master | cnn/models/wide_resnet.py |
# from https://github.com/fastai/imagenet-fast/blob/master/imagenet_nv/models/layers.py
import torch
from torch import nn
class AdaptiveConcatPool2d(nn.Module):
def __init__(self, sz=None):
super().__init__()
sz = sz or (1,1)
self.ap = nn.AdaptiveAvgPool2d(sz)
self.mp = nn.Adaptiv... | butterfly-master | cnn/models/layers.py |
'''Dual Path Networks in PyTorch.'''
import torch
import torch.nn as nn
import torch.nn.functional as F
class Bottleneck(nn.Module):
def __init__(self, last_planes, in_planes, out_planes, dense_depth, stride, first_layer):
super(Bottleneck, self).__init__()
self.out_planes = out_planes
sel... | butterfly-master | cnn/models/dpn.py |
# modified from https://github.com/fastai/imagenet-fast/blob/master/imagenet_nv/models/resnet.py
import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo
from .layers import Flatten
from .butterfly_conv import ButterflyConv2d, ButterflyConv2dBBT
def conv3x3(in_planes, out_planes, stride=1):
"3... | butterfly-master | cnn/models/resnet_imagenet.py |
import os, sys
import math
import random
import torch
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
import torch.nn.functional as F
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, project_root)
os.environ['PYTHONPATH'] = project_root + ":" + os.environ.g... | butterfly-master | cnn/models/presnet.py |
import torch
import torch.nn as nn
import numpy as np
def mixup(alpha, num_classes, data, target):
with torch.no_grad():
bs = data.size(0)
c = np.random.beta(alpha, alpha)
perm = torch.randperm(bs).cuda()
md = c * data + (1-c) * data[perm, :]
mt = c * target + (1-c) * tar... | butterfly-master | cnn/imagenet/mixup.py |
import os
import torch
import numpy as np
import torchvision.datasets as datasets
import torchvision.transforms as transforms
DATA_BACKEND_CHOICES = ['pytorch']
try:
from nvidia.dali.plugin.pytorch import DALIClassificationIterator
from nvidia.dali.pipeline import Pipeline
import nvidia.dali.ops as ops
... | butterfly-master | cnn/imagenet/dataloaders.py |
import random
import json
from collections import OrderedDict
class IterationMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.last = 0
def record(self, val, n = 1):
self.last = val
def get_val(self):
return None
def get_last(self):
r... | butterfly-master | cnn/imagenet/logger.py |
import math
import torch
import torch.nn as nn
import numpy as np
__all__ = ['ResNet', 'build_resnet', 'resnet_versions', 'resnet_configs']
# ResNetBuilder {{{
class ResNetBuilder(object):
def __init__(self, version, config):
self.config = config
self.L = sum(version['layers'])
self.M = ... | butterfly-master | cnn/imagenet/resnet.py |
import os
import numpy as np
import torch
import shutil
import torch.distributed as dist
def should_backup_checkpoint(args):
def _sbc(epoch):
return args.gather_checkpoints and (epoch < 10 or epoch % 10 == 0)
return _sbc
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar', checkpoint_d... | butterfly-master | cnn/imagenet/utils.py |
import torch
import torch.nn as nn
import torch.nn.functional as F
class LabelSmoothing(nn.Module):
"""
NLL loss with label smoothing.
"""
def __init__(self, smoothing=0.0):
"""
Constructor for the LabelSmoothing module.
:param smoothing: label smoothing factor
"""
... | butterfly-master | cnn/imagenet/smoothing.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.