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 |
|---|---|---|---|---|---|---|
teacher-perception | teacher-perception-master/code/agreement_per_pos.py | import os, pyconll
import dataloader_agreement_per_pos as dataloader
import argparse
import numpy as np
np.random.seed(1)
import sklearn
from collections import defaultdict
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import GridSearchCV
from sklearn.tree import Decisio... | 50,675 | 53.607759 | 311 | py |
SMIL | SMIL-main/src/train_soundmnist.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard impo... | 7,491 | 37.818653 | 159 | py |
SMIL | SMIL-main/src/get_sound_mean_kmean.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard impo... | 4,355 | 35 | 144 | py |
SMIL | SMIL-main/src/train_missing_eval_missing.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard impo... | 14,388 | 44.391167 | 287 | py |
SMIL | SMIL-main/src/train_sound.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard impo... | 6,017 | 34.4 | 159 | py |
SMIL | SMIL-main/src/train_mnist.py | from __future__ import print_function, absolute_import, division
import os
import time
import math
import datetime
import argparse
import os.path as path
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from torch.utils.tensorboard impo... | 5,835 | 34.803681 | 159 | py |
SMIL | SMIL-main/src/dataset/mosi.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import pickle
import math
import sys
sys.path.append("../")
import h5py
import p... | 5,856 | 34.49697 | 161 | py |
SMIL | SMIL-main/src/dataset/meta_training_dataset.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc... | 4,631 | 29.473684 | 108 | py |
SMIL | SMIL-main/src/dataset/soundmnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
import sys
sys.path.append("../")
from util... | 4,900 | 27.660819 | 88 | py |
SMIL | SMIL-main/src/dataset/meta_testing_dataset.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
from PIL import Image
import math
import sys
sys.path.append("../")
from utils.wav2mfcc import wav2mfcc... | 2,109 | 23.534884 | 110 | py |
SMIL | SMIL-main/src/dataset/sound.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
import sys
sys.path.append("../")
from util... | 3,275 | 25.852459 | 88 | py |
SMIL | SMIL-main/src/dataset/testing_mnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
class TestMNIST(torch.utils.data.Dataset)... | 2,594 | 21.37069 | 70 | py |
SMIL | SMIL-main/src/dataset/mnist.py | import torch.utils.data
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import cv2
import random
# import scipy.io as scio
from PIL import Image
import math
class MNIST(torch.utils.data.Dataset):
"... | 2,573 | 21.578947 | 70 | py |
SMIL | SMIL-main/src/models/vgg13.py | import torch.nn as nn
from collections import OrderedDict
import torch.nn.functional as F
class VGG13(nn.Module):
def __init__(self, output_layers = ['default']):
super(VGG13, self).__init__()
self.output_layers = output_layers
self.conv11 = nn.Conv2d(3, 64, kernel_size=(3, 3), padding=1)... | 5,267 | 26.4375 | 100 | py |
SMIL | SMIL-main/src/models/snet.py | import torch.nn as nn
class SNet(nn.Module):
def __init__(self, ):
super(SNet, self).__init__()
self.conv1 = nn.Conv2d(1, 5, kernel_size=(2, 2))
self.pool1 = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
self.conv2 = nn.Conv2d(5, 10, kernel_size=(2, 2))
self.po... | 2,931 | 22.837398 | 70 | py |
SMIL | SMIL-main/src/models/newencoder.py | import torch.nn as nn
from collections import OrderedDict
import torch
class InferNet(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNet, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
# self.conv11 = n... | 5,719 | 28.947644 | 64 | py |
SMIL | SMIL-main/src/models/lenet5.py | import torch.nn as nn
from collections import OrderedDict
import torch.nn.functional as F
class LeNet5(nn.Module):
def __init__(self, output_layers = ['default']):
super(LeNet5, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
se... | 2,784 | 25.52381 | 99 | py |
SMIL | SMIL-main/src/models/loss.py | import torch.nn as nn
import torch
import torch.nn.functional as F
class KDFeatureLoss(nn.Module):
""" multi-label cross entropy loss """
def __init__(self, reduction = 'mean', alpha = 1, beta = 1 ):
super().__init__()
self.cross_entropy = nn.CrossEntropyLoss(reduction = reduction)
self... | 4,329 | 39.849057 | 137 | py |
SMIL | SMIL-main/src/models/classifier.py | import torch.nn as nn
from collections import OrderedDict
import torch
class ClassfierNet(nn.Module):
def __init__(self, output_layers = ['default']):
super(ClassfierNet, self).__init__()
self.output_layers = output_layers
self.fc1 = nn.Linear(160, 32)
self.fc2 = nn.Linear(32, 10)... | 2,321 | 24.8 | 69 | py |
SMIL | SMIL-main/src/models/encoder.py | import torch.nn as nn
import torch
from torch.distributions.normal import Normal
class InferenceNet(nn.Module):
def __init__(self, ):
super(InferenceNet, self).__init__()
self.fc1 = nn.Linear(320, 128)
self.fc2 = nn.Linear(128, 32*2+10*2)
self.relu = nn.ReLU(inplace=True)
... | 1,796 | 24.309859 | 61 | py |
SMIL | SMIL-main/src/models/encoder_new.py | import torch.nn as nn
from collections import OrderedDict
import torch
class InferNetNew(nn.Module):
def __init__(self, output_layers = ['default']):
super(InferNetNew, self).__init__()
self.output_layers = output_layers
self.conv1 = nn.Conv2d(1, 5, kernel_size=(5, 5))
self.pool1 ... | 5,284 | 31.826087 | 89 | py |
SMIL | SMIL-main/src/models/reconstruct.py | class IMDbFuse(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self,extractor1, extractor2, extractor_grad=False):
super(IMDbFuse, self).__init__()
self.image_extractor = extractor1
self.text_extractor = extractor2
self.fc1 = nn.Linear(4096, 2048)
self.... | 3,754 | 35.105769 | 166 | py |
SMIL | SMIL-main/src/models/soundlenet5.py | import torch
import torch.nn as nn
class SoundLenet5(nn.Module):
"""docstring forLenet5 Sound"""
def __init__(self, extractor1, extractor2, extractor_grad=False):
super(SoundLenet5, self).__init__()
self.img_extractor = extractor1
self.sound_extractor = extractor2
self.fc1 = n... | 17,652 | 35.24846 | 167 | py |
SMIL | SMIL-main/src/utils/wav2mfcc.py | import numpy as np
import librosa
import os
from PIL import Image
# from keras.utils import to_categorical
def wav2mfcc(file_path, max_pad_len=20):
wave, sr = librosa.load(file_path, mono=True, sr=None)
wave = np.asfortranarray(wave[::3])
mfcc = librosa.feature.mfcc(wave, sr=8000, n_mfcc=20)
... | 913 | 22.435897 | 76 | py |
SMIL | SMIL-main/src/utils/misc.py | import os
import shutil
import torch
class AverageMeter(object):
"""Computes and stores the average and current value"""
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):
... | 1,644 | 33.270833 | 140 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/__init__.py | """
Python bindings for
`Drake: Model-Based Design and Verification for Robotics
<https://drake.mit.edu/>`_.
This Python API documentation is a work in progress. Most of it is generated
automatically from the C++ API documentation, and thus may have some
C++-specific artifacts. For general overview and API documentati... | 5,512 | 38.661871 | 79 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/test/rtld_global_warning_test.py | import importlib
import sys
import unittest
import warnings
import pydrake
class TestRtldGlobalWarning(unittest.TestCase):
def test_mock_torch(self):
# Import the mock module.
import torch
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always", Wa... | 937 | 30.266667 | 73 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/test/mock_torch/torch.py | # This is a mock version of torch for use with `rtld_global_warning_test`,
# simulating the following line:
# https://github.com/pytorch/pytorch/blob/v1.0.0/torch/__init__.py#L75
import os as _dl_flags
import sys
# Make the check in `pydrake/__init__.py` pass, but then undo the change.
_old_flags = sys.getdlopenflag... | 397 | 29.615385 | 74 | py |
tamp-manipulation-manipulation-tamp-RAL | tamp-manipulation-manipulation-tamp-RAL/bindings/pydrake/doc/conf.py | # -*- coding: utf-8 -*-
#
# 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
# -- Project information --------------------------------------------------... | 1,465 | 23.847458 | 78 | py |
relax | relax-main/setup.py | from setuptools import setup
setup(name='relax',
url='https://github.com/mkhodak/relax',
author='Misha Khodak',
author_email='khodak@cmu.edu',
packages=['relax'],
install_requires=['torch'],
version='0.0.0',
license='MIT',
description='NAS relaxation tools',
long_... | 366 | 23.466667 | 48 | py |
relax | relax-main/examples/pde/fourier_2d.py | """
@author: Zongyi Li
This file is the Fourier Neural Operator for 2D problem such as the Darcy Flow discussed in Section 5.2 in the [paper](https://arxiv.org/pdf/2010.08895.pdf).
"""
import os
import pdb
import requests
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.... | 10,902 | 33.286164 | 157 | py |
relax | relax-main/examples/pde/utilities3.py | import torch
import numpy as np
import scipy.io
import h5py
import torch.nn as nn
#################################################
#
# Utilities
#
#################################################
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# reading data
class MatReader(object):
def _... | 6,182 | 25.766234 | 113 | py |
relax | relax-main/examples/resnet/resnet.py | '''
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 web is copy-paste from
torchvision's resnet and has w... | 5,236 | 31.73125 | 120 | py |
relax | relax-main/examples/resnet/trainer.py | import argparse
import json
import math
import os
import pdb
import shutil
import time
from functools import partial
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.datasets as datasets
fro... | 15,001 | 35.859951 | 147 | py |
relax | relax-main/relax/xd.py | import math
import pdb
from functools import lru_cache
from itertools import product
import torch
from torch import nn
from torch.nn import functional as F
from relax.ops import AvgPool, Conv, ConvTranspose, FNO, Fourier, SharedOperation, int2tuple, multichannel_prod
class TensorProduct(nn.Module):
'''applies pro... | 21,201 | 38.046041 | 230 | py |
relax | relax-main/relax/nas.py | import pdb
from copy import deepcopy
import torch
from torch import nn, optim
from torch._six import inf
from relax.ops import Conv, int2tuple
from relax.xd import XD
def get_module(model, module_string):
if module_string:
for substring in module_string.split('.'):
model = getattr(model, subs... | 10,283 | 37.954545 | 160 | py |
relax | relax-main/relax/ops.py | import math
import pdb
from itertools import product
import torch
import torch.fft
from torch import nn
from torch.nn import functional as F
if int(torch.__version__.split('.')[1]) < 8:
from torch_butterfly.complex_utils import complex_matmul
else:
from torch import matmul as complex_matmul
def Conv(dims):
... | 7,401 | 36.958974 | 155 | py |
relax | relax-main/tests/utils.py | import unittest
try:
import torch_butterfly
BUTTERFLY = True
except ImportError:
BUTTERFLY = False
class TestCase(unittest.TestCase):
def test(self, butterfly=False):
pass
@unittest.skipIf(not BUTTERFLY, "torch_butterfly not found")
def test_butterfly(self, **kwargs):
self... | 352 | 17.578947 | 64 | py |
relax | relax-main/tests/test_xd.py | import pdb
import unittest
import torch
from torch import nn
from relax.ops import Conv, ConvTranspose, FNO
from relax.xd import XD, original
from utils import TestCase
class TestConv(TestCase):
def setUp(self):
self.cases = []
with torch.no_grad():
for dims in range(1, 3):
... | 8,647 | 49.870588 | 122 | py |
relax | relax-main/tests/test_nas.py | import pdb
import unittest
import torch
from relax.nas import Supernet
from relax.xd import original
from fourier_2d import Net2d
from resnet import resnet20
from utils import TestCase
class TestResNet20(TestCase):
def setUp(self):
self.model = resnet20()
self.X = torch.randn(2, 3, 32, 32)
... | 2,994 | 40.027397 | 106 | py |
LED2-Net | LED2-Net-main/main.py | import os
import sys
import cv2
import yaml
import argparse
from tqdm import tqdm
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.tensorboard import SummaryWriter
import LED2Net
def train(train_loader, val_loader, model, config):
device = config['exp_args'][... | 8,409 | 47.057143 | 137 | py |
LED2-Net | LED2-Net-main/run_inference.py | import os
import sys
import yaml
import argparse
from tqdm import tqdm
import numpy as np
import torch
import glob
import json
from imageio import imread, imwrite
from tqdm import tqdm
import pathlib
import LED2Net
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Training script for LED^2... | 3,137 | 42.583333 | 137 | py |
LED2-Net | LED2-Net-main/LED2Net/Tools.py | import torch
import random
import numpy as np
def fixSeed(seed):
np.random.seed(seed)
torch.manual_seed(seed)
random.seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # for multiGPUs.
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
d... | 491 | 23.6 | 54 | py |
LED2-Net | LED2-Net-main/LED2Net/Visualizer.py | import cv2
import math
import numpy as np
import torch
import torch.nn as nn
from .Projection import Equirec2Cube
class LayoutVisualizer(object):
def __init__(self, cube_dim, equi_shape, camera_FoV, fp_dim, fp_meters):
self.fp_dim = fp_dim
self.fp_meters = fp_meters
self.FoV = camera_FoV / ... | 2,767 | 32.349398 | 84 | py |
LED2-Net | LED2-Net-main/LED2Net/PostProcessing.py | import torch
import torch.nn as nn
import numpy as np
from scipy.optimize import least_squares
from functools import partial
from .Conversion import EquirecTransformer
def errorCalculate(ratio, up_norm, down_norm):
error = np.abs(ratio * up_norm - down_norm)
#error = np.abs(up_norm - down_norm / ratio)
ret... | 2,261 | 36.081967 | 86 | py |
LED2-Net | LED2-Net-main/LED2Net/Network.py | import numpy as np
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.models as models
import functools
from . import BaseModule
ENCODER_RESNET = [
'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152',
'resnext50_32x4d', 'resnext101_32x8d'
]
ENCODER_DENSEN... | 8,661 | 31.935361 | 127 | py |
LED2-Net | LED2-Net-main/LED2Net/BaseModule.py | import os
import torch
import torch.nn as nn
import datetime
class BaseModule(nn.Module):
def __init__(self, path):
super().__init__()
self.path = path
os.system('mkdir -p %s'%path)
self.model_lst = [x for x in sorted(os.listdir(self.path)) if x.endswith('.pkl')]
self.best_m... | 2,308 | 36.241935 | 105 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/CubePadding.py | import torch
import torch.nn as nn
import math
import pdb
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.model_zoo as model_zoo
from torch.autograd import Variable
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class CubePad(nn.Module):
def __init__(self, pad_siz... | 6,935 | 49.627737 | 151 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/OtherPadding.py | import torch
import torch.nn as nn
import math
import pdb
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.model_zoo as model_zoo
from torch.autograd import Variable
from torch.nn.parameter import Parameter
import torch.nn.functional as F
class CustomPad(nn.Module):
def __init__(self, pad_f... | 836 | 19.925 | 71 | py |
LED2-Net | LED2-Net-main/LED2Net/Padding/SpherePadding.py | import os
import sys
import matplotlib.pyplot as plt
import numpy as np
import cv2
import torch
import torch.nn as nn
import torch.nn.functional as F
class SpherePadGrid(object):
def __init__(self, cube_dim, equ_h, FoV=90.0):
self.cube_dim = cube_dim
self.equ_h = equ_h
self.equ_w = equ_h *... | 7,986 | 44.64 | 135 | py |
LED2-Net | LED2-Net-main/LED2Net/Conversion/MatrixTools.py | import torch
import copy
import pytorch3d.transforms.rotation_conversions as p3dr
__all__ = [
'homogeneous',
'angle_axis_to_rotation_matrix',
'rotation_matrix_to_angle_axis',
'pose_vector_to_projection_matrix'
]
def homogeneous(tensor: torch.Tensor):
shape = list(copy.deepcopy(... | 1,049 | 26.631579 | 70 | py |
LED2-Net | LED2-Net-main/LED2Net/Conversion/EquirecCoordinate.py | import cv2
import torch
import numpy as np
__all__ = ['XY2lonlat', 'lonlat2xyz', 'XY2xyz', 'xyz2lonlat', 'lonlat2XY', 'xyz2XY', 'EquirecTransformer']
def XY2lonlat(xy, shape, mode='numpy'):
lon = ((xy[..., 0] - ((shape[1]-1) / 2.0)) / shape[1]) * 2 * np.pi
lat = ((xy[..., 1] - ((shape[0]-1) / 2.0)) / shape[0]... | 3,036 | 29.37 | 106 | py |
LED2-Net | LED2-Net-main/LED2Net/Loss/DepthRender.py | import os
import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.nn.functional as F
import sys
import cv2
from .. import Conversion
class RenderLoss(nn.Module):
def __init__(self, camera_height=1.6):
super(RenderLoss, self).__init__()
assert camera_heigh... | 11,607 | 40.605735 | 147 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/Realtor360Dataset.py | import os
import sys
import cv2
import json
import numpy as np
from imageio import imread
import torch
from torch.utils.data import Dataset as TorchDataset
from .BaseDataset import BaseDataset
from ..Conversion import XY2xyz, xyz2XY, xyz2lonlat, lonlat2xyz
from .SharedFunctions import *
class Realtor360Dataset(BaseDa... | 3,525 | 31.953271 | 153 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/Matterport3DDataset.py | import os
import sys
import cv2
import json
import numpy as np
from imageio import imread
import torch
from torch.utils.data import Dataset as TorchDataset
from .BaseDataset import BaseDataset
from ..Conversion import XY2xyz, xyz2XY, xyz2lonlat, lonlat2xyz
from .SharedFunctions import *
class Matterport3DDataset(Base... | 3,574 | 32.411215 | 153 | py |
LED2-Net | LED2-Net-main/LED2Net/Dataset/BaseDataset.py | import os
import sys
import cv2
import numpy as np
from imageio import imread
import matplotlib.pyplot as plt
from tqdm import tqdm
import torch
from torch.utils.data import Dataset as TorchDataset
from torch.utils.data import DataLoader as TorchDataLoader
class BaseDataset(TorchDataset):
def __init__(self, **kwa... | 516 | 22.5 | 58 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/Equirec2Cube.py | import os
import sys
import cv2
import time
from imageio import imread
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class Equirec2Cube(nn.Module):
def __init__(self, cube_dim, equ_h, FoV=90.0):
super().__init__()
self.cube_dim = cube_dim
self.equ_h =... | 3,302 | 33.051546 | 99 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/EquirecGrid.py | import torch
import torch.nn as nn
from .. import Conversion
class EquirecGrid(object):
def __init__(self):
super().__init__()
self.bag = {}
self.ET = Conversion.EquirecTransformer('torch')
def _createGrid(self, key, h, w):
X = torch.arange(w)[None, :, None].repeat(h, 1, 1)
... | 881 | 27.451613 | 76 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/EquirecRotate.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
from .. import Conversion
class EquirecRotate(nn.Module):
def __init__(self, equ_h):
super().__init__()
self.equ_h = equ_h
self.equ_w = equ_h * 2
X = torch.arange(self.equ_w)[None, :, None].repeat(self.e... | 1,164 | 39.172414 | 90 | py |
LED2-Net | LED2-Net-main/LED2Net/Projection/Cube2Equirec.py | import os
import sys
import cv2
import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import scipy.misc as sic
class Cube2Equirec(nn.Module):
def __init__(self, cube_length, equ_h):
super().__init__()
self.cube_length =... | 3,434 | 31.102804 | 120 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/complete_verification_experiments.py | import csv
import time
from comet_ml import Experiment # type: ignore[import]
import numpy as np
import pandas as pd # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_pa... | 3,572 | 35.835052 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/run_instance.py | import argparse
import os.path
import shutil
import time
from pathlib import Path
from typing import Dict, List, Optional, Sequence, Tuple
import dill # type: ignore[import]
import numpy as np
import torch
import torch.nn as nn
from torch import Tensor
from src.abstract_layers.abstract_network import AbstractNetwork... | 21,637 | 33.731942 | 135 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/vnncomp_runner.py | import os
import time
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_args, get_config_from_json
from src.utilities.c... | 4,706 | 35.773438 | 83 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_instance.py | import argparse
import csv
import os
import re
import shutil
import time
from cmath import inf
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Union
from comet_ml import Experiment # type: ignore[import]
import numpy as np
import onnx # type: ignore[import]
import torch
import torch.nn as n... | 28,592 | 34.213054 | 166 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/milp_network.py | """
Adapted from https://gitlab.inf.ethz.ch/OU-VECHEV/PARC/-/blob/MILP_encoding/MILP_Encoding/milp_utility.py
9a3a68a6bd86af27755dbf7a38595395a40baae1
"""
from __future__ import annotations
import multiprocessing
import time
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type
import numpy a... | 65,951 | 33.475693 | 105 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_subproblem.py | from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Dict, Optional, Tuple
import torch
from torch import Tensor
from src.state.constraints import PrimaConstraints
from src.state.split_state import SplitState
from src.state.subproblem_state import ReadonlySubproble... | 6,125 | 30.740933 | 93 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/branch_and_bound.py | import time
from typing import Any, Dict, Optional, OrderedDict, Sequence, Tuple
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import Tensor
from tqdm import tqdm # type: ignore[import]
from src.abstract_layers.abstract_network import AbstractNetwork
from src.exceptions.verificatio... | 19,760 | 39.828512 | 245 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verify.py | import csv
import time
import sys
from comet_ml import Experiment # type: ignore[import]
import torch
from torch import nn
from src.abstract_layers.abstract_network import AbstractNetwork
from src.mn_bab_verifier import MNBaBVerifier
from src.utilities.argument_parsing import get_args, get_config_from_json
from src.... | 4,578 | 35.632 | 139 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_verifier.py | # import itertools
import multiprocessing
import time
from typing import List, Optional, OrderedDict, Sequence, Tuple, Union
import numpy as np
import torch
import torch.nn as nn
from torch import Tensor
from tqdm import tqdm # type: ignore[import]
from src.abstract_domains.DP_f import DeepPoly_f
from src.abstract_d... | 47,627 | 36.296789 | 238 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_optimizer.py | from __future__ import annotations
import time
from typing import List, Optional, OrderedDict, Sequence, Tuple, Union
import numpy as np
import torch
from torch import Tensor, optim
from torch.optim import Optimizer
from src.abstract_domains.DP_f import DeepPoly_f
from src.abstract_domains.zonotope import HybridZono... | 30,426 | 38.362225 | 174 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/perf_benchmark.py | import argparse
import pstats
from cProfile import Profile
from torch.profiler import ProfilerActivity, profile, record_function
from src.verification_instance import VerificationInstance, create_instances_from_args
def run_torch_benchmark_on_instance(instance: VerificationInstance) -> None:
with profile(
... | 2,270 | 29.28 | 139 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/verification_subproblem_queue.py | from typing import Callable, List, Optional, Sequence
import numpy as np
import torch
from src.abstract_layers.abstract_network import AbstractNetwork
from src.state.tags import NodeTag
from src.verification_subproblem import ReadonlyVerificationSubproblem
class VerificationSubproblemQueue:
"""Priority queue of... | 8,063 | 39.93401 | 93 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/mn_bab_shape.py | from __future__ import annotations
from collections import OrderedDict
from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
import torch
from torch import Tensor
from src.state.tags import LayerTag, ParameterTag, QueryTag
from src.utilities.dependence_sets import DependenceSets
from src.utilities... | 18,716 | 36.210736 | 125 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/concat.py | from typing import Tuple
import torch
from torch import Tensor
class Concat(torch.nn.Module):
def __init__(self, dim: int) -> None:
super(Concat, self).__init__()
self.dim = dim
def forward(self, x: Tuple[Tensor, ...]) -> Tensor:
return torch.cat(x, dim=self.dim)
| 300 | 20.5 | 55 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/multi_path_block.py | from typing import List, Optional
from torch import Tensor
from torch import nn as nn
from src.concrete_layers.binary_op import BinaryOp as concreteBinaryOp
class MultiPathBlock(nn.Module):
def __init__(
self, header: Optional[nn.Module], paths: List[nn.Sequential], merge: nn.Module
) -> None:
... | 1,081 | 26.05 | 87 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/binary_op.py | import torch
from torch import Tensor
# Concrete Implementation of BinaryOp used so that we can have an abstract version that spawns multiple shapes
class BinaryOp(torch.nn.Module):
def __init__(self, op: str) -> None:
super(BinaryOp, self).__init__()
self.op = op
def forward(self, x: Tensor,... | 524 | 26.631579 | 110 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/basic_block.py | from typing import List, Tuple
import torch
from torch import nn as nn
from src.concrete_layers.residual_block import ResidualBlock
class BasicBlock(ResidualBlock, nn.Module):
expansion = 1
in_planes: int
planes: int
stride: int
bn: bool
kernel: int
out_dim: int
def __init__(
... | 3,038 | 26.378378 | 72 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/slice.py | import torch
from torch import Tensor
# Slicing limited to 1-d slices wit positive steps
class Slice(torch.nn.Module):
def __init__(self, dim: int, starts: int, ends: int, steps: int) -> None:
super(Slice, self).__init__()
self.starts = starts
self.ends = ends
self.dim = dim
... | 768 | 28.576923 | 77 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/reshape.py | from typing import Tuple
import torch
from torch import Tensor
class Reshape(torch.nn.Module):
def __init__(self, shape: Tuple[int, ...]) -> None:
super(Reshape, self).__init__()
# Assume that shape is without batch-size
self.shape = shape
def forward(self, x: Tensor) -> Tensor:
... | 368 | 23.6 | 55 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/residual_block.py | from torch import Tensor
from torch import nn as nn
class ResidualBlock(nn.Module):
def __init__(
self,
path_a: nn.Sequential,
path_b: nn.Sequential,
) -> None:
super(ResidualBlock, self).__init__()
self.path_a = path_a
self.path_b = path_b
def forward(self... | 409 | 21.777778 | 45 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/permute.py | from typing import Tuple
import torch
from torch import Tensor
class Permute(torch.nn.Module):
def __init__(self, dims: Tuple[int, ...]) -> None:
super(Permute, self).__init__()
self.dims = dims
def forward(self, x: Tensor) -> Tensor:
return x.permute(self.dims)
| 299 | 20.428571 | 54 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/normalize.py | from typing import Sequence
import torch
from torch import Tensor
class Normalize(torch.nn.Module):
means: Tensor
stds: Tensor
channel_dim: int
def __init__(
self, means: Sequence[float], stds: Sequence[float], channel_dim: int
) -> None:
super(Normalize, self).__init__()
... | 853 | 25.6875 | 77 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/split_block.py | from typing import Optional, Tuple
import torch
from torch import Tensor
from torch import nn as nn
class SplitBlock(nn.Module):
def __init__(
self,
split: Tuple[bool, Tuple[int, ...], Optional[int], int, bool],
center_path: nn.Sequential,
inner_reduce: Tuple[int, bool, bool],
... | 1,215 | 31 | 114 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/unbinary_op.py | import typing
import torch
from torch import Tensor
class UnbinaryOp(torch.nn.Module):
def __init__(self, op: str, const_val: Tensor, apply_right: bool = False) -> None:
super(UnbinaryOp, self).__init__()
self.op = op
self.register_buffer(
"const_val",
torch.as_ten... | 1,144 | 27.625 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/concrete_layers/pad.py | from typing import Tuple
import torch
import torch.nn.functional as F
from torch import Tensor
class Pad(torch.nn.Module):
def __init__(
self, pad: Tuple[int, ...], mode: str = "constant", value: float = 0.0
) -> None:
super(Pad, self).__init__()
self.pad = pad if pad is not None else... | 488 | 24.736842 | 78 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/leaky_gradient_maximum_function.py | from typing import Any, Tuple
import torch
from torch import Tensor
from torch.autograd import Function
class LeakyGradientMaximumFunction(Function):
@staticmethod
def forward(ctx: Any, input: Tensor, other: Tensor) -> Tensor: # type: ignore[override]
return torch.maximum(input, other)
@staticm... | 469 | 28.375 | 100 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/abstract_module_mapper.py | from typing import Type
from torch import nn as nn
from src.abstract_layers.abstract_avg_pool2d import AvgPool2d
from src.abstract_layers.abstract_bn2d import BatchNorm2d
from src.abstract_layers.abstract_concat import Concat
from src.abstract_layers.abstract_conv2d import Conv2d
from src.abstract_layers.abstract_con... | 4,117 | 44.252747 | 81 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/optimization.py | import time
from typing import Callable, Optional, Tuple
import numpy as np
import torch
import torch.optim as optim
from torch import Tensor
from src.exceptions.verification_timeout import VerificationTimeoutException
from src.mn_bab_shape import MN_BaB_Shape, num_queries
from src.state.subproblem_state import Reado... | 10,705 | 36.830389 | 130 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/leaky_gradient_minimum_function.py | from typing import Any, Tuple
import torch
from torch import Tensor
from torch.autograd import Function
class LeakyGradientMinimumFunction(Function):
@staticmethod
def forward(ctx: Any, input: Tensor, other: Tensor) -> Tensor: # type: ignore[override]
return torch.minimum(input, other)
@staticm... | 469 | 28.375 | 100 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/queries.py | from __future__ import annotations
from typing import Iterator, Optional, Tuple, Union, overload
import numpy as np
import torch
from torch import Tensor
from src.utilities.dependence_sets import DependenceSets
QueryCoef = Union[
Tensor, DependenceSets
] # batch_size x num_queries x current_layer_shape...
de... | 7,440 | 32.822727 | 146 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/tensor_management.py | from collections import OrderedDict
from typing import Any
import torch
def deep_copy(obj: Any) -> Any:
if obj is None:
return obj
if torch.is_tensor(obj):
assert obj.is_leaf
return obj.clone().detach()
if isinstance(obj, OrderedDict):
return OrderedDict((k, deep_copy(v)) ... | 3,491 | 35.375 | 86 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/logging.py | import os
import sys
import torch
import socket
from datetime import datetime
try:
from pip._internal.operations import freeze
except ImportError: # pip < 10.0
from pip.operations import freeze
def get_log_file_name(log_prefix=None):
log_dir = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(... | 3,382 | 30.036697 | 108 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/sig_precompute.py | from typing import Callable, List, Tuple, Union
import torch
from torch import Tensor
from src.abstract_layers.abstract_sig_base import SigBase
from src.abstract_layers.abstract_sigmoid import d_sig, sig
from src.abstract_layers.abstract_tanh import d_tanh, tanh
from src.utilities.bilinear_interpolator import Bilinea... | 7,691 | 33.648649 | 203 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/output_property_form.py | import itertools
from typing import List, Optional, Tuple
import torch
import torch.nn as nn
from torch import Tensor
class OutputPropertyForm:
"""
Represents an output property-formula in CNF.
Each atom of the formula corresponds to a gt_tuple of the form (a,b,c) <=> a - b >= c
property_matrix: a T... | 9,001 | 37.969697 | 148 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/onnx_loader.py | import warnings
from collections import defaultdict
from typing import Any, DefaultDict, Dict, List, Optional, Set, Tuple
import numpy as np
import onnx # type: ignore[import]
import torch
from onnx import numpy_helper
from torch import Tensor, nn
from onnx2pytorch.onnx2pytorch.convert.operations import ( # type: i... | 25,051 | 37.900621 | 107 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/prepare_instance.py | import argparse
import json
import os
import shutil
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import dill # type: ignore[import]
import numpy as np
import onnx # type: ignore[import]
import torch
import torch.nn as nn
from bunch import Bunch # type: ignore[import]
from torch import Ten... | 10,917 | 34.106109 | 121 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/dependence_sets.py | from __future__ import annotations
from typing import List, Tuple, Union
import numpy as np
import torch
import torch.nn.functional as F
from torch import Tensor
class DependenceSets:
"""
A memory-efficient implementation of a coefficient matrix used in backsubstitution, as described in
https://arxiv.or... | 16,881 | 37.988453 | 200 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/prima_util.py | import itertools
import multiprocessing
import sys
from enum import Enum
from typing import Callable, List, Optional, Sequence, Tuple
import matplotlib.pyplot as plt # type: ignore[import]
import numpy as np
import torch
from torch import Tensor
sys.path.insert(0, "ELINA/python_interface/")
from ELINA.python_interfa... | 22,520 | 36.286424 | 159 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/batching.py | from __future__ import annotations
from collections import OrderedDict
from typing import Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
import torch
from torch import Tensor
from src.state.constraints import Constraints, ReadonlyConstraints
from src.state.layer_bounds import LayerBounds, ReadonlyLayerBoun... | 22,636 | 33.402736 | 209 | py |
mn-bab-SABR_ready | mn-bab-SABR_ready/src/utilities/initialization.py | import os
import random
import numpy as np
import torch
def seed_everything(seed: int) -> None:
os.environ["PL_GLOBAL_SEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
torch... | 489 | 23.5 | 53 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.